Műszaki és Humántudományok Kar Marosvásárhely

Villamosmérnöki Tanszék
2021-2022
1. félév

Tantárgy: MMME
Beágyazott elektronikai rendszerek

Terv
A terv címe: Léptető motor irányításának tervezése

Név: NAGY Csaba Sámuel

Mesteri 2. év
FMR - Fejlett Mechatronikai Rendszerek szak
Kivonat

Ez a tanulmány egy léptetőmotor irányításának a matematikai modellezéséről és

programozásáról szól. A léptetőmotor irányítása a Zybo, FPGA (field-programmable gate array)

rendszerének programozásával, illetve annak modellezése a MATLAB, Simulink programjával van

megvalósítva. A terv fel van bontva a következő elemekre: VHDL program, program feltöltése az

FPGA-ba, MATLAB modell.

Bevezetés

A cél a projekt egy olyan digitális rendszer volt, ami három tengely mentén tud elmozdulni

(x,y,z). A koordináta rendszerben való elmozdulást a cnc világban jól ismert G-kódu algoritmus

alapján érdemes építeni. A rendszer programját VHDL-ben sikerült megvalósítani, illetve annak

modellezését a Simulinkben. Az irányításhoz szükséges hardver Zybo FPGA rendszerrel ami Linuxos

operációs rendszerrel van betöltve.

A követelmények a gép koordináták megadásával mozduljon el olyan irányban amilyen

parancsot kap. Képesnek kell lennie, egyszerre több tengelyen elmozdulnia. Azonkívül az elmozdulás

legyen menedékes, fokozatosan gyorsuló, és megállás előtt fokozatosan lassuló. A gép működés során

legyen pontos, illetve a mozdulatokat, a parancsok legyen ismételhetők. Legyen internet kapcsolata,

hogy távolról lehessen irányítani. Érintős képernyős legyen a kezelői rendszer. Sebessége legyen

cm/sec-ban.

A rendszer a léptető motorok vezérlésével legyen képes pontos pályát követni.

A digitális rendszerek tervezésére két tervezési módszert különböztetünk meg: – fentről lefelé (top

down): egy magasabb absztrakciós szintről apró lépésekkel ér el a részletekig, – lentről felfelé: az apró

részletekből kiindulva jut el a magasabb absztrakciós szintig. A tervezés során figyelembe kell

vennünk: teljesítmény=ford∙nyomaték
 A logikai tervezés során megvalósítjuk a regiszterátviteli szinten leírt elemeket. A logikai

tervezést kapuszintű tervezésnek is nevezik, mivel ezen a szinten logikai kapukat, multiplexer

áramköröket, bistabil áramköröket, vagyis úgymond kapuszintű elemeket alkalmaznak a

megvalósításra. A logikai tervezést követi az áramkörtervezés, majd a fizikai megvalósítással

(implementálással) jön létre a digitális áramkör.

A rendszert a vhdl segítségével tervezzük meg, illetve itt tudjuk tesztelni is. A VHDL nyelv

tulajdonságai: – újrahasználható; – technológiafüggetlen: – nem kötődik egyetlen szimulátorhoz vagy

adatbázishoz sem, – nem erőltet rá a tervezőre egyetlen tervezési módszertant sem, – független a

berendezési és IC-gyártási eljárástól; – könnyen használható tervek módosítására vagy kiegészítésére.

Összefoglalva: a VHDL nyelv leírja egy elektronikus áramkör vagy rendszer viselkedését, struktúráját,

amely alapján elemezhető vagy megvalósítható a fizikai áramkör. A VHDL mint szabványosított

hardverleíró nyelv a következő esetekben alkalmazható: – szintézisre, áramköri leírásra, – FPGA vagy

CPLD áramköri tervezésre, – áramköri szimulációra. (Brassai, 2018)

Működés közbeni ellenőrzésre több lehetőség van: külső méréstechnikai eszközök

alkalmazása (oszcilloszkóp, logikai analizátor) vagy az FPGA áramkörbe integrált logikai analizátor.

A XILINX típusú FPGA-án megvalósított hardver működés közbeni tesztelésére alkalmazható a

hardver-koszimulációs módszer. A hardverkoszimulációval működés közben az FPGA áramkörből a

jelek megjeleníthetők a számítógép képernyőjén.

1. VHDL program

A VHDL (Very High-Speed Integrated Circuit Hardware Description Language)

programozási nyelv az Egyesült Államok Védelmi Minisztériumának utasítására fejlesztették ki, mivel

az volt a cél, hogy minden IC-t (integrated circuit) könnyen dokumentálni lehessen. (VHDL, 2021) Az
IC belső áramkörei bár nem ismertek, a viselkedése alapján meg lehet állapitani az IC strukturális

illetve fizikai modeljét. A digitális rendszer tervezésének a lépései a következők: a

rendszerkövetelmények meghatározása, a rendszer-specifikációjának (pl. algoritmus) megszerkesztése,

architektura kiválasztása (pl. processzor architektura), modulok tervezése (pl. kapuszintű

logikatervezés, illetve áramkörtervezés), magas szintű logikai szintézis (HLS - viselkedés model

átvitele RTL modelbe), az áramkör fizikai megvalósítása, rendszerintegráció, tesztelés. (Brassai, 2018)

A léptetőmotor irányításának rendszerkövetelménye, hogy a rendszer előállítson egy olyan

jelet vagy jeleket amelyek fokozatosan felgyorsitsa a léptető motort egy bizonyos sebességig, illetve

lelassítsa a léptetőmotort a célba érése előtt. Tehát a léptető motor vezérléséhez szükséges egy

impulzusszélesség-moduláció jel, egy irány jel és egy engedély jel. Mind a három jelnek elegendő két

bitt viszont az impulzusszélesség-moduláció jelnek meg kell határozni a három különböző részét, ami

gyorsítja, sebességét tartja, és lassítja a motort. Így meg kell határozni a gyorsulás idejét, legyen T1, a

gyorsulás értékét, legyen d1, és a gyorsulás frekvenciáját, legyen N1. Ugyanakkor meghatározzuk az

impulzusszélesség-moduláció jelnek a maradék két részét T2, N2-el, és T3, d3, N3-el. Bementi jelnek

még meghatározzuk a sart és reset bemeneteleket. A start jel elindítja a motort a kitűzött irányba,

illetve a reset törli a vezérlő utasításait és új utasítások befogadását teszi lehetővé. Az 1.1 és 1.2

ábrákon találhatóak a vezérlőnek a be és kimenetek ábrázolása, illetve az

impulzusszélesség-moduláció jel (imp_out) gyorsítási és lassítási tulajdonságokkal.

1.1 Ábra
1.2 Ábra

A program folyamatábrája az 1.3as ábrán található.

1.3 Ábra

A VHDL program a következő:

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_SIGNED.ALL; -- osszehasonlitás integer std_logic_vector kozott

entity lepteto_vezerlo is

Generic (T_bit_szam : natural := 32); --local konstans

Port ( src_clk : in STD_LOGIC; --bemeneti/kimeneti portok

src_ce : in STD_LOGIC;
 start : in std_logic;

reset : in std_logic;

en : in std_logic;

dir : in std_logic;

T1 : in STD_LOGIC_VECTOR (T_bit_szam-1 downto 0); --Csökkenő indextartomány

N1 : in STD_LOGIC_VECTOR (T_bit_szam-1 downto 0);

d1 : in STD_LOGIC_VECTOR (T_bit_szam-1 downto 0);

T2 : in STD_LOGIC_VECTOR (T_bit_szam-1 downto 0);

N2 : in STD_LOGIC_VECTOR (T_bit_szam-1 downto 0);

T3 : in STD_LOGIC_VECTOR (T_bit_szam-1 downto 0);

N3 : in STD_LOGIC_VECTOR (T_bit_szam-1 downto 0);

d3 : in STD_LOGIC_VECTOR (T_bit_szam-1 downto 0);

IMP_out : out std_logic;

dir_out : out std_logic;

en_out : out std_logic;

state : out std_logic

);

end lepteto_vezerlo;

architecture Behavioral of lepteto_vezerlo is

-- deklarációs rész

type allapot_tipus is (RDY, INIT_A, T1_CIKL, DEK_T1, INIT_B, T2_CIKL, KONST, INIT_C,

T3_CIKL, INK_T3, VEGE, RVEGE);

signal akt_all, kov_all : allapot_tipus;

signal RK1, RK1_next : std_logic_vector(T_bit_szam-1 downto 0);

signal RK2, RK2_next : std_logic_vector(T_bit_szam-1 downto 0);

signal RT1, RT1_next : std_logic_vector(T_bit_szam-1 downto 0);

signal RT2, RT2_next : std_logic_vector(T_bit_szam-1 downto 0);

signal RT3, RT3_next : std_logic_vector(T_bit_szam-1 downto 0);

signal RIMP, RIMP_next :std_logic; if start = '1'then

begin kov_all <= INIT_A;

AR :process(src_clk, reset) else

--RDY állapot meghatározása kov_all <= RDY;

begin end if;

if reset = '1' then when INIT_A =>

akt_all <= RDY; kov_all <= T1_CIKL;

elsif src_clk'event and src_clk='1' then when T1_CIKL =>

akt_all <= kov_all; if RK1 > 0 then

end if; kov_all <= T1_CIKL;

end process AR; else

kov_all <= DEK_T1;

KAL : process(akt_all, start) end if;

--Állapotok inicializálása when DEK_T1 =>

begin if RK2 > 0 then

case akt_all is kov_all <= T1_CIKL;

when RDY => else

 kov_all <= INIT_B; end if;

end if; when INK_T3 =>

when INIT_B => if Rk2 > 0 then

kov_all <= T2_CIKL; kov_all <= T3_CIKL;

when T2_CIKL => else

if RK1 > 0 then kov_all <= VEGE;

kov_all <= T2_CIKL; end if;

else when vege =>

kov_all <= KONST; kov_all<=RDY;

end if; end case;

when KONST => end process KAL;

if Rk2 > 0 then

kov_all <= T2_CIKL; RT1_reg: process(src_clk)

else --Delay1 állapot meghatárpzása

kov_all <= INIT_C; begin

end if; if src_clk'event and src_clk ='1' then

when init_C => RT1 <= RT1_next;

kov_all <=T3_CIKL; end if;

when T3_CIKL => end process RT1_reg;

if RK1 > 0 then WITH akt_all select

kov_all <= T3_CIKL; RT1_next <= RT1 when RDY,

else T1 when INIT_A,

kov_all<= INK_T3; RT1 when T1_CIKL,

 RT1 -d1 when DEK_T1, end process RT3_reg;

RT1 when others; WITH akt_all select

RT3_next <= RT3 when rdy,

RT2_reg: process (src_clk) T3 when INIT_C,

--Delay2 állapot meghatározása RT3 when T3_CIKL,

begin RT3 +d3 when INK_T3,

if src_clk'event and src_clk= '1' then RT3 when others;

RT2 <= RT2_next;

end if; RK1_reg: process (src_clk)

end process RT2_reg; --Frekvencia meghatározása

WITH akt_all select begin

RT2_next <= RT2 when rdy, if src_clk'event and src_clk = '1' then

T2 when INIT_B, Rk1 <= Rk1_next;

RT2 when T2_CIKL, end if;

RT2 when DEK_T1, end process RK1_reg;

RT2 when others; WITH akt_all select

Rk1_next <= Rk1 when rdy,

RT3_reg: process (src_clk) T1 when INIT_A,

--Delay3 állapot meghatározása Rk1-1 when T1_CIKL,

begin RT1 when DEK_T1,

if src_clk'event and src_clk = '1' then T2 when INIT_B,

RT3 <= RT3_next; Rk1-1 when T2_CIKL,

end if; RT2 when KONST,

 T3 when INIT_C, Rk2 when VEGE;

Rk1-1 when T3_CIKL,

RT3 when INK_T3, --impulzus kimenet meghatározása

Rk1 when VEGE; begin

RK2_reg: process (src_clk) if src_clk'event and src_clk = '1' then

begin RIMP <= RIMP_next;

if src_clk'event and src_clk = '1' then end if;

Rk2 <= Rk2_next; end process RIMP_REG;

end if; WITH akt_all select

end process RK2_reg; RIMP_next <= RIMP when rdy,

WITH akt_all select '0' when INIT_A,

Rk2_next <= Rk2 when rdy, RIMP when T1_CIKL,

N1 when INIT_A, not RIMP when DEK_T1,

RK2 when T1_CIKL, RIMP when INIT_B,

Rk2-1 when DEK_T1, RIMP when T2_CIKL,

N2 when INIT_B, not RIMP when KONST,

Rk2 when T2_CIKL, RIMP when INIT_C,

Rk2-1 when KONST, RIMP when T3_CIKL,

N3 when INIT_C, not RIMP when INK_T3,

Rk2 when T3_CIKL, RIMP when VEGE;

Rk2-1 when INK_T3, --A state kimenet meghatározása

WITH akt_all select

RIMP_REG: process (src_clk) RVEGE <= '1' when VEGE,

'0' when others imp_out <= RIMP;

--Kimenetek és változók hozzárendelése state <=RVEGE

dir_out <=dir; end Behavioral

en_out <=en;

2. Program feltöltése az FPGA-ba

A program lefutása az FPGA-n egy executable (végrehajtható) fáj által történik aminek a

kiterjesztése elf. A fájl az FPGA processzor magjába letöltődik bootoláskor és majd onnan végzi a

processzor az utasításokat. A Zybo rendszer konfigurálható egy operációs rendszerrel és mivel ez

előnyös, több szempontból is, a programot egy linux operációs rendszer segítségével fogjuk betölteni a

az FPGA-ba. A linux operációs rendszer segítségével el lehet érni, hogy a lehessen kommunikálni a

rendszerrel akár egy wifi készüléken keresztül. A Linux operációs rendszer végrehajtható fájl mellé

még kell egy devicetree fájl ami tartalmazza a rendszer perifériás eszközeinek működtetéséhez

szükséges információkat. A devicetree fájl dts kiterjesztését elő lehet állítani a xilinx szoftverrel, de

azt át kell alakítani bináris állománnyá, hogy a devicetree fájl olvasható legyen a linux rendszer

számára. A dts fájl kiterjesztésének átalakítását a linux rendszerben a dtc -o dtb -i dts

-devictree_fájl_neve.dts paranccsal lehet megvalósítani ami a dts kiterjesztésű fájlból a linux

rendszer számára olvasható dtc kiterjesztésű fájllá alakítja.

Ahhoz, hogy tudjunk kommunikálni a rendszerrel még szükség lesz egy driverre ami a

hardver inicializálását biztositja és ugyanakkor regisztrálja az eszközt a megfelelő frameworkban. A

driver fordítását a makefile paranccsal lehet megvalósítani, hogy olvasható legyen az operációs

rendszer számára és insmod-al lehet beiktatni a rendszerbe. Ami még szükséges, hogy találjon a
kernel verzió a fájlokban a megfelelő kernellel és egy olvasható fájlon keresztül lehet utasításokat

küldeni a processzornak.

Ahhoz, hogy tesztelni tudjuk a rendszert az FPGA-ban a következő program betáplálása

szükséges, hogy megadjuk a változók értékeit:

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#define START_ADDR 0

#define RESET_ADDR 4

#define EN__ADDR 8

#define DIR_ADDR 12

#define D3_ADDR 16

#define D2_ADDR 20

#define D1_ADDR 24

#define T3_ADDR 28

#define T2_ADDR 32

#define T1_ADDR 36

#define N3_ADDR 40

#define N2_ADDR 44

#define N1_ADDR 48

#include <sys/types.h>

typedef struct {

unsigned long addr;

unsigned long data;

}data_w;

int main(){

FILE* fp;

data_w buff_out;

unsigned short T1, T2, T3, dir, en;

fp = fopen("/proc/cncdriver","w+");

buff_out.addr=EN_ADDR;

buff_out.data=0;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=RESET_ADDR;

buff_out.data=1;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=START_ADDR;

buff_out.data=0;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=RESET_ADDR;

buff_out.data=0;
fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=T1_ADDR;

buff_out.data=500;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=D1_ADDR;

buff_out.data=100;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=N1_ADDR;

buff_out.data=100;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=T2_ADDR;

buff_out.data=500;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=N2_ADDR;

buff_out.data=0;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=D2_ADDR;

buff_out.data=0;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=N3_ADDR;

buff_out.data=100;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

buff_out.addr=D3_ADDR;

buff_out.data=0;

fwrite (&buff_out , sizeof(data_w), 1, fp);

buff_out.addr=T3_ADDR;

buff_out.data=500;

fwrite (&buff_out , sizeof(data_w), 1, fp);

buff_out.addr=RESET_ADDR;

buff_out.data=0;

fwrite (&buff_out , sizeof(data_w), 1, fp);

fflush(fp);

fflush(fp);
sleep(1);

fclose(fp);

return 0;

A programban, a változók mellett még a regiszterek címét kell megadni amit a xilinx programból le

lehet kérni egy htm kiterjesztésű fájlban:

Ugyanakkor a rendszert lehet szimulálni a system generátor segítségével az alábbi összeállítás

segitségével:
A rendszer strukturális illetve fizikai modellje található az alábbi ábrákon:
 3. MATLAB modell

A rendszer modellezése megvalósítható Simulink segítségével. Egyszerűsítés céljából az

impulzusszélesség-moduláció jelet előállítjuk egy háromszög hullám és egy saját szerkesztésű irányító

jellel amint az látható a 3.1 ábrán. A két jel összehasonlításának eredménye egy

impulzusszélesség-modulált jel mivel amint az irányító jel növekszik -20-ról nulláig, az

impulzusszélesség-moduláció munkaciklusa csökken. Így egy fordított trapéz alakú irányító jellel el

lehet érni azt a gyorsító és lassító jelet ami hasonló a vhdl programban meghatározott jelhez. Az

irányító jel az ábra 3.2-ben található.

3.1 Ábra
3.2 Ábra
 Az impulzusszélesség-moduláció jel előállításának a rendszere a 3.3 ábrán található. Mivel a

háromszög hullám generátornak nincs frekvencia bemenete, így az N változó nem szükséges. A

léptető motor ábrája a 3.4 ábrám található. A léptető motor le van egyszerűsítve annyiból, hogy nincs

számba véve a tehetetlensége, és amíg az irányító jel 1 addig van a motornak egy adott sebessége,

másképp nyugalomban van. A 3.5 ábrán látható a motor válasza az impulzusszélesség-moduláció jelre.

Látható amint a motor gyorsulás alatt van a ciklus elején és lassulás alatt a ciklus vége felé mielőtt a

motor nyugalomba ér. A 3.6 ábrán látható a rendszer. A rendszer egyenesen arányos 30 egység

távolság megtevés felett, így a bemenetet elegendő szorozni egy állandóval. Viszont 30 egység alatt a

rendszer már nem lineáris mivel az adott idő (T1) alatt a motor nem éri el a maximum végsebességet,

így görbeillesztés szükséges ami látható a 3.7es ábrán. A görbeillesztés eredményének a függvényének

a behelyetesitése a 3.8 és ennek eredménye a 3.9es és 3.10es ábrákon található.

3.3 Ábra

3.4 Ábra
3.5 Ábra

3.6 Ábra
3.7 Ábra

3.8 Ábra
3.9 Ábra

3.10 Ábra

Összefoglalás

Ebben a tanulmányban egy digitális rendszer volt bemutava, amely irányítja a léptető motor

sebességét illetve irányát. A rendszer programját VHDL-ben sikerült megvalósítani, illetve annak

modellezését a Simulinkben. Az irányításhoz szükséges hardver Zybo FPGA rendszerrel ami Linuxos

operációs rendszerrel van betöltve.

 Irodalomjegyzék

1. T. Brassai, Újrakonfigurálható digitális áramkörök tervezési és tesztelési módszerei. Scientia

Kiadó, 2018.

2. VHDL. (2021, December 3). In Wikipedia. https://en.wikipedia.org/wiki/VHDL