Programozás kategória bejegyzései

Új eszközök a LabVIEW programozásban: csatorna vezetékek

A 2016-os LabVIEW egy új eszközt vezetett be a programozásba, a csatorna vezetékeket (Channel Wires). Ezek jelentősen megkönnyítik az adatok átadását a ciklusok között. E bejegyzésben egy egyszerű példát mutatok be, ahol a feladat az, hogy egyszerre két, egymástól független ciklust állíthassunk le egy nyomógomb segítségével.

Számos módszer volt eddig is a feladat megvalósítására, többek között használhattunk lokális változókat is. A helyzetet bonyolította, hogy ekkor a Stop Button alapértelmezett Latch When Released üzemmódját nem lehet használni, vagyis az alapértelmezett Off állapotát nekünk kell biztosítani mind a program indulásakor, mind pedig a két ciklus lefutása után. A Flat Sequence-ek valamint a boolean vezetékek biztosítják a megfelelő sorrendiséget.

tag-classic

A feladatot lényegesen leegyszerűsítené, hogy ha az első ciklusból a Stop gomb értékét egyszerű módszerrel át tudnánk adni a második ciklusnak. Erre kivallóan alkalmas a Nofifier, de ez talán még bonyolítaná is az előző kódot. A 2016-os LabVIEW-ban a Tag channel ad egy egyszerű megoldást a feladatra. Először létre kell hozzunk egy Channel Writer csomópontot, ezt a kívánt típusú vezetékre jobb gombbal kattintva, a Create/Channel Writer… opciót választva tehetjük meg.

createchannelwriter

A megjelenő párbeszédablakban válasszuk ki a kívánt opciót, jelenleg a Tag csatorna mintát, ezen belül pedig a sima Write végpontot.

selectchannelendpoint

Az adatok csatornából való kiolvasására a helyi menü Create/Channel Reader opcióját használhatjuk.

createchannelreader

A végeredményként előálló program a következő ábrán látható. (Ahogy a képen látható, a ciklus címkéje részben elfedi a vezetéket, ez azonban bármilyen másik vezetékkel is megtörténne.)

tag

Memória kezelése NI FPGA-n

Adatok tárolásáról az FPGA-n találhatunk leírást itt és itt. Ebben a bejegyzésben bemutatok egy egyszerű projektet, ami a memóriát olvasva állít elő egy periodikus analóg jelet.

Memóriát legegyszerűbben a Project Explorerben adhatunk hozzá az FPGA target-hez. A kiválasztott memória esetén a Memory Properties párbeszédablakban állíthatjuk be többek között a memória nevét, méretét, típusát (nagyobb adatmennyiség tárolására a Block Memory a legjobb opció) és a tárolt adatok típusát.

Memória hozzáadása az FPGA target-hez

Memória hozzáadása az FPGA target-hez

Az alábbi ciklus állítja elő a memória tartalom alapján a kimenő analóg jelet. A shift regiszter az index léptetésére szolgál. A bemutatott logika helyett elvileg maradékos osztást is lehetne alkalmazni, azonban FPGA target esetén kifejezetten nem javasolják bármilyen osztás vagy maradékos osztás használatát azok jelentős erőforrás igénye miatt. A memória olvasó node-ot a Project Explorer-ből egyszerűen elhelyezhetjük a programunkban, ekkor az alapértelmezett Memory Write metódus kerül kiválasztásra. Olvasássá úgy alakíthatjuk át a node-ot, hogy a helyi menüben kiválasztjuk a Select Method/Read opciót. A példában az N határozza meg, hogy hány pontból álljon a periodikus jel, a Count határozza meg a kimenet frissítésének gyakoriságát, az i és a Data változó pedig hibakeresési célokra szolgál.

Egyszerű példa a memória olvasására

Egyszerű példa a memória olvasására

Ami fontos kérdés ebben a példában: hogyan kerülnek az adatok a memóriába?

Egyrészt, fel tudjuk tölteni kezdő adatokkal az Initial Values fülön a Memory Properties párbeszédablakban. Ugyanakkor a legtöbb esetben azt szeretnénk, hogy a PC-ről bármikor frissíthessük a memória tartalmát, hogy az éppen kívánt jelet állíthassuk elő. Sajnos erre nincs beépített megoldás, nekünk kell írni egy apró programot, ami elvégzi a feladatot.

Memória írása a DMA FIFO-t felhasználva

Memória írása a DMA FIFO-t felhasználva

A fenti kódban a DMA FIFO-t használjuk arra, hogy lehetőséget adjunk a PC-nek a memória kezelésére. DMA FIFO-t a memóriához hasonlóan adhatunk hozzá az FPGA target-hez, jelen esetben a „Host to Target - DMA” opciót kell kiválasszuk, adattípusként pedig az U64-et választottam. Ebben az esetben a felső 32 bit a memória címét tartalmazza, az alsó 32 bit pedig a memória értékeket. Természetesen, szükség esetén lehet optimalizálni a felhasznált adattípust. Azért választottam, hogy így legyenek egybecsomagolva az adatok, mert ebben az esetben semmiképp sem fordulhat elő, hogy véletlenül felcserélődik a két adat. A kapott 32 bit-es adatot először átalakítom a kívánt adattípusba, majd pedig eltárolom a memóriába a kapott címre.

A memória feltöltése és a többi paraméter írása a LabVIEW FPGA interfészen keresztül történik. Az alábbi példaprogramban először az N és a Count paraméterek vannak beállítva (Read/Write control), majd pedig egy ciklusban le vannak töltve az adatok (Invoke Method; Method / FIFO neve / Write). Alapértelmezésben a Close FPGA Reference le fogja állítani az FPGA kódot, ezért azt át kell konfigurálni a helyi menüből (a Close and Reset is Last Reference helyett az egyszerű Close).

A Host VI

A Host VI

A teljes megoldás PC-n való tesztelésére használhatjuk a Desktop Execution Node-ot, egy egyszerű VI látható a következő ábrán. A VI-t futtatva, látjuk, hogy az FPGA épp hogy működik, a Host VI-t futtatva pedig frissíthetjük az FPGA beállításait és a memória tartamát. A teljes projekt letölthető innen: NI-7856R-MemoryDemo.zip

Egyszerű példa a Desktop Execution Node használatára

Az előző posztban mutattam egy egyszerű FPGA-ra írt programot. Ebben a bejegyzésben azt mutatom be, hogy az FPGA kódot hogyan tudjuk egyszerűen tesztelni a számítógépen, ráadásul anélkül, hogy azt le kellene fordítsuk. Megjegyzés: az FPGA interfész használatához célszerű ha van egy megfelelően konfigurált Build Specification, ami pl. az első fordításkor is automatikusan létrejön, de manuálisan is létrehozhatjuk.

Ahhoz, hogy az FPGA kód a PC-n fusson, a Project Explorer ablakában az FPGA target helyi menüjében ki kell válasszuk, hogy a kód a PC-n hajtódjon végre. Ezt követően a VI az FPGA helyett a PC-n fog futni.

FPGA konfigurálása, hogy a kód a PC-n fusson. Ugyanezt a beállítást az FPGA Target Properties Execution Mode lapján is elérhetjük.

FPGA konfigurálása, hogy a kód a PC-n fusson. Ugyanezt a beállítást az FPGA Target Properties Execution Mode lapján is elérhetjük.

A számítógépen futó kód alapesetben szimulált I/O változókkal fut, ami általában véletlenszerű jeleket jelent. Amennyiben mi akarjuk meghatározni ezen jelek értékét két fő megoldásunk van. A FPGA Target Properties Execution Mode lapján kiválaszthatjuk, hogy a szimuláció ne véletlenszerű adatokkal fusson, hanem egy saját magunk által elkészített VI szolgáltassa a bemenő jeleket és kezelje a kimenő jeleket. Erre a LabVIEW egy Template-et biztosít, a módszerről bővebben itt lehet olvasni.

A másik, sok esetben egyszerűbb módszer, az FPGA Desktop Execution Node (DEN) használata. Ezen csomópont használata esetén a PC megadott mennyiségű FPGA órajelet szimulál le, miközben felülírhatjuk az FPGA I/O változóit, valamint az FPGA előlapi be és kimeneteit is. Az aktuális példában a DEN-t úgy konfiguráltam, hogy 1 us-ot hajtson végre, így 1 MHz-es mintavételezéssel tudjuk vizsgálni az FPGA állapotát.

A Dectop Execution Node konfigurálása. A Terminal Configuration segítségével meghatározhatjuk, hogy mely I/O vagy előlapi változókhoz szeretnénk hozzáférni.

A Dectop Execution Node konfigurálása. A Terminal Configuration segítségével meghatározhatjuk, hogy mely I/O vagy előlapi változókhoz szeretnénk hozzáférni.

A DEN akár önmagában is jól használható az FPGA működésének szimulálására, ugyanakkor az esetek többségében a host-vi-al, az FPGA interfész használatával együtt szeretnénk tesztelni az alkalmazásunkat. Az ehhez szükséges, viszonylag egyszerű demó kód a következő ábrán látható:

Az FPGA kód szimulálása PC-n a Desctop Execution Node segítségével.

Az FPGA kód szimulálása PC-n a Desktop Execution Node segítségével.

A kódban lévő Running változó arra szolgál, hogy a FPGA interfész csak akkor kezdje el az FPGA kód vezérlését, hogy ha a szimuláció fut, ha pedig megállítjuk a szimulációt, álljon le a Host interface loop is. Lokális változók helyett azért használok property node-okat, hogy a hibavezetékek segítségével biztosíthassam a végrehajtás sorrendjét. Profibb megoldásként használhatunk funkcionális globális változókat vagy egyéb eszközöket, mint Queue vagy Notifier. A Simulation loop nagyjából 10 ms-onként hajtódik végre, 1 s alatt 100 us-nyi FPGA időt szimulál le. Ha a dt 10 us, akkor minden 10 szimulációs ciklusra kapunk egy-egy új mintavételt. Természetesen, hogy ha az FPGA viselkedését komolyabb vizsgálatoknak szeretnénk alávetni (pl. átviteli függvény mérése), akkor a bemutatott egyszerű példánál lényegesen komplexebb kódot kell létrehozni. Erre nagyon jó példa a következő beépített LabVIEW példa: Simulation Analog Singnals with the DEN.lvproj (keresőszavak: desktop execution). Megjegyzés: a program indulása némi időt vehet figyelembe (akár fél percet), türelmesen kell várni.

Az aktuális példa futás közben

Az aktuális példa futás közben

A minta projekt letölthető innen: NI-7856R-FilterDemo

Egyszerű példa a LabVIEW FPGA interfész használatára

Ebben a bejegyzésben egy egyszerű példaprogramot mutatok be, amely a LabVIEW FPGA interfészt használja. A megvalósított feladat egy egyszerű elsőfokú IIR szűrő, a kód pedig az NI USB-7856R-on fut. Az FPGA kódja a következő ábrán látható:

Az FPGA-n futó elsőfokú IIR szűrőt megvalósító kód

Az FPGA-n futó elsőfokú IIR szűrőt megvalósító kód

A bemenet az AI0 csatorna, a kimenet pedig az AO0 csatorna, az IIR szűrőt megvalósító képlet: y_n = b_0 x_n + b_1 x_{n-1}+a_1 y_{n-1}. A számolás fixpontos számokkal történik, a szorzás műveletek úgy vannak konfigurálva, hogy a számok mérete ne váljon kezelhetetlenül naggyá. A felhasznált számok szóhossza nincsenek optimalizálva méret szempontjából, egy végső alkalmazás esetén erre külön figyelmet illik fordítani. A ciklusidőt a Loop Timer állítja be, 10 us esetén 100 kHz-es mintavételezési frekvenciát érhetünk el (a maximális mintavételi frekvencia 1 MHz). A program futtatásához megfelelően be kell állítani a paramétereket, ezt követően tesztelhetjük is az eredményt egy oszcilloszkóp segítségével.

Az FPGA-n futó kód előlapja a PC-ről futtatva.

Az FPGA-n futó kód előlapja a PC-ről futtatva.

Oszcilloszkóppal mért jelalakok

Oszcilloszkóppal mért jelalakok

Gyors tesztelést leszámítva nem szoktuk az FPGA kód előlapját közvetlenül használni a kód konfigurálására, hanem a PC-n futó szoftver irányítja az FPGA kódot, miközben egy megfelelő felhasználói interfészt biztosít. Az aktuális esetben is a szűrő megvalósításához szükséges konstansokat sem az FPGA-n célszerű számolni, hanem a PC-n először kiszámoljuk, majd pedig az eredményekkel felkonfigurálhatjuk az FPGA-t. A művelet megvalósításához a LabVIEW FPGA interfészt használhatjuk. Az alábbi példában, azért, hogy a kód minél egyszerűbb legyen, nem végzem el a paraméterek kiszámolását.

Az FPGA PC-ről vagy cRIO-ról való vezérlésének műveletei az FPGA Interface palettán találhatók.

Az FPGA Interface paletta

Az FPGA Interface paletta

A számítógépen futó host VI

A számítógépen futó host VI

Ahhoz, hogy hozzáférjünk az FPGA-hoz, először meg kell nyitnunk egy referenciát. Ezt követően a Read/Write Control csomópont segítségével írhatjuk vagy olvashatjuk az FPGA VI előlapi elemeit. A Close FPGA VI reference-vel felszabadíthatjuk az erőforrásokat. Az Open FPGA VI Reference-t megfelelően fel kell konfigurálni, ekkor meghatározhatjuk azt is, hogy a referencia megnyitásakor el is induljon az FPGA.

Az Open FPGA VI Reference konfigurálása

Az Open FPGA VI Reference konfigurálása

Az elkészített projekt

Az elkészített projekt

Az FPGA kódot egyrészt kipróbálhatjuk magán az USB adatgyűjtőn, ugyanakkor lehetőségünk van arra is, hogy az FPGA működését a számítógépen szimuláljuk. Erre a következő posztban mutatok egy egyszerű példát.

Egyedi LabVIEW subVI ikonok készítése

Ha saját subVI-t készítünk, célszerű annak az ikonját is megszerkeszteni, mégpedig úgy, hogy annak formája minél jobban tükrözze a végrehajtott funkciót. Ha a VI jobb felső sarkára az ikonra duplán kattintunk (vagy a helyi menüből kiválasztjuk az Edit Icon … opciót), megnyílik az ikonszerkesztő. Ebben egy hagyományos képszerkesztő programhoz hasonlóan tudjuk szerkeszteni az ikon kinézetét. Néhány extra opció azért elérhető. Egyrészt a Layer fülön különböző rétegeket definiálhatunk, illetve ki-be kapcsolhatunk rétegeket. Tudunk különböző előre definiált alakzatokat is használni és elhelyezni a Glyphs fülön. Tudunk egyszerűen többsoros szöveget írni az Icon Text fülön. A Templates fülön pedig kiválaszthatunk előre elkészített mintákat. A Template-eket valamint a Glyphs-eket egyszerűen tudjuk bővíteni, ha új fájlokat helyezünk el a megfelelő könyvtárakba. A Tools menü List Glyps and Icon Templates menüje segítségével kilistázhatjuk az aktuális fájlokat, valamint azt is, hogy a számítógépen ezeket mely könyvtárakban találhatjuk meg. Az Edit menü Show Terminal menüjével bekapcsolhatjuk a terminálok helyét, ezzel láthatjuk, hogy a vezetékek hova fognak befutni.

Az alábbi példában egy egyszerű várakozást végrehajtó VI-t mutatok be. A megvalósított funkció az előző posthoz kapcsolódik, és lényegében az Express Time Delay funkcióját valósítja meg. Annyiban jobb a bemutatott VI, hogy nem lebegőpontos számokkal dolgozik (amit az Express VI átszámol ms-ba), hanem eleve ms-ban kéri a kívánt várakozás idejét.

Várakozást megvalósító VI diagramja

Várakozást megvalósító VI diagramja

Várakozást megvalósító VI ikonja

Várakozást megvalósító VI ikonja

subVI felhasználása

subVI felhasználása

Ahogy a fenti képen látszik, a saját magunk által készített VI ki tudja váltani az Express VI feladatát, azonban mérete miatt megzavarja a vezetékezést. Szerencsére ezen segíthetünk, a LabVIEW-ban nem szükséges, hogy a VI a megadott négyzet méretű legyen. Ehhez töröljük ki az eredeti ikon szélét, majd rajzoljunk egy olyan alakot, ami megfelel a kívánalmainknak. A VI széle (ahogy az ikonszerkesztő is mutatja), átlátszó lesz. Célszerű még a vezetékek bekötését is átrendezni, hogy a legjobban tudjuk felhasználni az elkészített subVI-t. Az elkészült VI az alábbi képeken látható.

Egyedi méretű ikon szerkesztése

Egyedi méretű ikon szerkesztése

Egyedi méretű subVI felhasználása

Egyedi méretű subVI felhasználása

Késleltetések a LabVIEW-ban

LabVIEW program írása közben sokszor szükség van arra, hogy bizonyos műveletek végrehajtása közé valamennyi várakozást iktassunk be. Erre a legegyszerűbb módszer az, hogy ha a Flat sequence struktúrát használjuk fel. A következő példában a műszer digitális kimenetén változtatjuk meg a bit-ek állását egy megadott idő után (megjegyzés: mivel nem valós idejű rendszert programozunk, a váltás ideje nem lesz determinisztikus). Az azt követő példában pedig az előlapon lévő LED kijelző-n hozunk létre egy impulzust.

Időzítések Flat Sequence segítségével

Időzítések Flat Sequence segítségével

Előlapi kijelzés időzítése Flat Sequence segítségével

Előlapi kijelzés időzítése Flat Sequence segítségével

A megadott példákkal az a probléma, hogy azok nem követik a LabVIEW adatfolyam programozási elvét (data flow programming), vagyis nem az adatok rendelkezésre állása időzíti a program végrehajtását. A problémát az okozza, hogy a várakozó rutin (mely eléggé „ősi”) nem rendelkezik a szokásos Error In és Error out vezetékekkel, melyekkel könnyen megoldható lenne a sorrendiség biztosítása. Megoldásként használhatjuk az Express Time Delay rutint, mely elsőre elég bumfordinak tűnik, de van ikonnézete is, amikor már egész használható. (Megjegyzés: ms helyett másodpercben kéri a várakozási időt).

Express Time Delay

Express Time Delay

Az Express vi-t felhasználva máris elkészíthetjük az előző példák sequence nélküli verzióját. Az előlapi kijelző elérésénél még azt kell módosítsuk, hogy a lokális változók helyett property node segítségével módosítsuk a kijelző értékét, mely ugyanúgy rendelkezik Error In és Error Out vezetékkel mint a többi sorba fűzhető VI.

Időzítés Express Time Delay segítségével

Időzítés Express Time Delay segítségével

Példa property node-ok használatára

Példa property node-ok használatára

Új lények a laborban: Wonder Gecko

A vicces nevű mikrovezérlő-családot a Silicon Labs adta ki, és a TOMI pályázat keretében sikerült beszerezni két Starter kit-et.

A Wonder Gecko Starter kit

A Wonder Gecko Starter kit

A mikrovezérlő család előnye, hogy miközben a ARM Cortex M4 magnak köszönhetően kivallóan alkalmas nagyobb számításigényű feladatokra, elsősorban alacsony fogyasztású, elemes táplálásra optimalizálták. Ennek megfelelően elsősorban elemes táplálású műszerek megvalósításánál vagy szenzorhálózatos alkalmazásokban tervezzük használni.

A mikrovezérlő család legfontosabb paraméterei:

  • 48 MHz-es ARM Cortex M4 mag, hardveres lebegőpontos egységgel
  • 32kB RAM és akár 256 kB flash
  • 12 bit 1 MS/s ADC és 500 kS/s DAC
  • Számos alacsony fogyasztású üzemmód (0.4 µA is elérhető RTC használata mellett)
  • USB host és OTG támogatás

A kit a mikrovezérlőn kívül többek között tartalmaz 32 MB NAND Flash-t, integrált debuggert és LCD kijelzőt.

A mikrovezérlő számára programokat a Silicon Labs által kiadott Simplicity Studio fejlesztőkörnyezettel lehet fejleszteni. Bár, tapasztalataink szerint ez a legkönnyebben feltelepíthető és használható fejlesztőkörnyezet ARM mikrovezérlők számára, sajnos vannak hátrányai is. Pl. az, hogy a hozzá adott konfigurátor eszköz nem igazán használható: a mikrovezérlő számos, létfontosságú belső perifériáját (megszakításkezelő, órajelkiválasztás …) nem lehet segítségével konfigurálni, e mellett csak korlátozottan használható együtt a példakódokkal. Így, eddigi tapasztalataink alapján legjobb, ha saját magunk írjuk meg a konfiguráló kódot, a Simplicity Configurator-t pedig csak példaként használjuk.

Kezdő lépések a NI USB-7856R programozásában

Ahhoz, hogy az NI USB-7856R eszközt programozzuk, mindenképp szükség lesz egy LabVIEW projektre. Egyrészt fel lehet használni a Create Projekt párbeszédablakban a Templates/Desctop/LabVIEW FPGA Projekt template-et, ugyanakkor nem sokkal körülményesebb (sőt, talán még egyszerűbb is), hogy ha egy üres projektből (Blank Projekt) indulunk ki. Mivel a mérőeszköz közvetlenül, USB kapcsolaton keresztül, kapcsolódik a számítógéphez, ezért a My Computer-hez kell hozzáadjuk a helyi menü New/Target and Devices... menü segítségével.

Az FPGA target hozzáadása a projekthez

Az FPGA target hozzáadása a projekthez

Ha az eszköz csatlakoztatva van a számítógéphez, akkor az Existing target or device segítségével megtalálhatjuk és kiválaszthatjuk, egyébként a New target or device menü segítségével kiválaszthatjuk egy listából.

Az aktuális műszer kiválasztása

Az aktuális műszer kiválasztása

A műszer bemeneteit és kimenetei, a DAQmx driverrel szemben, a Project Explorer window-ban érhetők el (IO változóként). A szükséges IO elemeket az FPGA targetre kattintva a helyi menü New/FPGA I/O menüje segítségével választhatjuk ki.

VI-ok létrehozásánál figyelnünk kell, hogy az adott kódot hol is szeretnénk futtatni. Amennyiben a kód a My Computer-hez van hozzárendelve, akkor a kód a számítógépen fog futni. Ahhoz, hogy az FPGA-t programozzuk, a VI-t az FPGA Target csomópont alá kell hozzáadni a helyi menü New/VI parancsa segítségével. A kód elkészítése után a VI a hagyományos módon futtatható. A LabVIEW először legenerálja a fordításhoz szükséges ideiglenes fájlokat, majd pedig elindul a fordító, mely véges idő után elkészíti az FPGA-n futó bit-fájlt. A fájl automatikusan letöltődik, majd az FPGA elkezdi a kód végrehajtását. A kódot futás közben felügyelhetjük a PC-ről továbbra is elérhető vi előlapja segítségével.

Az aktuális program futtatása

Az aktuális program futtatása

Megjegyzések:

  • Az FPGAn a LabVIEW műveleteknek csak egy részhalmaza érhető el, e mellett a szokásostól kissé eltérő programozási stratégiákat érdemes követni (ezekről később még lesz szó).
  • A fordítószerver indulásáig néha kicsit várni kell, a fordítás maga pedig hosszas időt vehet igénybe (rövid programok esetén általában legalább 5 perc, bonyolultabb kódok esetén akár órákig is tarthat a fordítás).
  • Fordítás közben kaphatunk fordítási hibát, pl. azért mert túl sok erőforrást szeretnénk felhasználni, vagy azért, mert valamely műveletet az FPGA nem tudná a kívánt időtartam alatt elvégezni. Utóbbi könnyel előfordulhat, amennyiben nem figyelünk oda a felhasznált adattípusok nagyságára, pl. fixpontos műveletek esetén a szóhosszúság hajlamos egyre nagyobb és nagyobb lenni.

Számolás fixpontos számokkal

A programozás során legelterjedtebb számformátumok az egész számok, valamint a lebegőpontos számok. Utóbbiak előnye, hogy nem csak egész számokat tudnak ábrázolni, így komoly szerepük van jelfeldolgozási feladatok közben. Hátrányuk viszont, hogy a velük végzett műveletek komoly erőforrásokat igényelnek, e mellett számos platform nem, vagy csak nagyon korlátozottan támogatja felhasználásukat. Éppen ezét, amennyiben beágyazott rendszereken szeretnénk jeleket feldolgozni, találkozni fogunk a fixpontos számok fogalmával.

 

Lebegőpontos és fixpontos számok összehasonlítása

Lebegőpontos és fixpontos számok összehasonlítása

A fixpontos számok egy egészrészt valamint egy törtrészt tartalmaznak. A szám deklarálásakor dönthetjük el, hogy mekkora az egész rész és a törtrész bithossza. A két rész összege tipikusan 8, 16, 32 vagy 64 bit lehet, azonban vannak olyan platformok (pl. FPGA), melyek tetszőleges bithosszt támogatnak.

Fixpontos számok esetén a számokat a feldolgozó egység (processzor, FPGA) egész számként kezeli a számokat, és csak a fordító (valamint a programozó) foglalkozik azzal, hogy éppen hol van a tizedes pont. Ennek köszönhetően a fixpontos számokkal végzett számolások nagyságrendekkel kevesebb időt és/vagy erőforrást igényelnek, mint a lebegőpontos számok.

A NI FPGA alapú eszközei, bár korlátozottan támogatják a lebegőpontos számokat (egyszeres pontosságúakat), jelfeldolgozási célokra fixpontos számokat célszerű használni. LabVIEW esetén a fixpontos számokat a következő paraméterekkel tudjuk felkonfigurálni:

  • Word length: teljes szóhosszúság (egészrész + törtrész)
  • Integer word length: egészrész hossza
  • Signd/unsigned: előjeles vagy előjel nélküli szám (a negatív számok kettes komplemens alakban vannak tárolva)
  • Include overflow status: a fixpontos szám egy extra biten tárolni fogja, hogy történt-e túlcsordulás a számolások közben

A megadott paraméterek alapján a LabVIEW kiszámolja, hogy mi az ábrázolható számtartomány (Minimum, Maximum), valamint az aktuális felbontás (Delta). FPGA analóg bemenetek és kimenetek tipikusan a <±,20,5> adattípust használják, ami egy előjeles 20 bit-es fixpontos számot jelöl, melynek egészrésze 5 bit-es. Ezzel az adattípussal a ±10 V-os mérési tartomány kényelmesen lefedhető 30 µV felbontással.

Fixpontos adattípus konfigurálása a Properties menü segítségével

Fixpontos adattípus konfigurálása a Properties menü segítségével

Fixpontos számokon végzett műveletek közben az alapműveleteket végző node-ok automatikusan adaptálják magukat a forrás adatokhoz, szükség esetén bővítve a végeredmény méretét, hogy ne történhessen túlcsordulás. Amennyiben ez a végeredmény nem felel meg számunkra, pl. nem akarjuk tovább növelni az adatméretet, akkor azt manuálisan is tudjuk konfigurálni, megadva a kívánt formátumot, a kerekítés módját, valamint, hogy túlcsordulás esetén mi legyen az alapértelmezett viselkedés. Amennyiben nem az alapértelmezett formátumot választjuk, a művelet végén egy kék pötty jelöli a típuskonverziót. Megjegyzés: ha egy művelet végén egy piros pötty jelenik meg, az azt jelöli, hogy az eredmény túllépné a 64 bit-et, így a LabVIEW egy automatikus típuskonverziót kénytelen végrehajtani.

A műveletek eredményének konfigurálása (adattípus, kerekítés és szaturációs mód)

A műveletek eredményének konfigurálása (adattípus, kerekítés és szaturációs mód)

Amikor fixpontos számokat konvertálunk egész számokká, két fő funkcióra lehet szükségünk. Az egyik, amikor a fixpontos szám egészre kerekített értékére vagyunk kíváncsiak. Ez a konverzió történhet automatikusan, implicit castolással, vagy expliciten, a Numeric/Conversion paletta segítségével. Ugyanakkor sokszor az összes olyan bitre kíváncsiak vagyunk, melyek a fixpontos számot alkották, a végeredményt egész szám alakjában szeretnénk feldolgozni. Erre a feladatra a Numeric/Fixed point/Fixed Point to Integer Cast funkciót használhatjuk. A művelet fordítottját valósítja meg az Integer to Fixed Point Cast funkció. Utóbbit konfigurálhatjuk manuálisan, a Properties menü segítségével, vagy a függvény középső bemenetére adott „minta” segítségével.

A megfelelő erőforrás-felhasználás szempontjából célszerű a fixpontos adattípusokat a lehető legkisebb nagyságon tartani. Ellenkező esetben a számolások FPGA esetén túlzottan sok FPGA felületet fognak igényelni, megnő a fordítási idő, illetve, szélsőséges esetén le sem fordul a kód.

Irodalom:

Szimulációk automatizált futtatása

Gyakori eset, hogy egy tudományos kérdés vizsgálatára számos szimulációt kell futtatni különböző paraméterekkel. A szimulációk egyenkénti futtatása nem a legkényelmesebb, hiszen egy-egy szimuláció órákig is eltarthat, és figyelni kell, mikor indíthatjuk a következőt. Jobb megoldás az automatizált végrehajtás, ekkor a szimulációk paraméterezését nem feltétlenül triviális úgy végrehajtani, hogy közben karbantartható maradjon a kód. Éppen ezért fejlesztettem ki egy olyan környezetet szimulációk automatizált futtatására, mely a korábban ismertetett paraméterezésen alapul.

Az egymás után futtatandó szimulációkat egyszerűen, egy táblázatban lehet paraméterezni, ahol az egymás utáni oszlopok tartalmazzák az egymás utáni paramétereket. A szimulációt végrehajtó VI-t dinamikusan lehet betölteni. A VI-nak megadott be és kimenetekkel (is) kell rendelkeznie ahhoz, hogy a rendszerbe integrálható legyen, a szimulációt végrehajtó kódba viszont csak néhány subVI-t kell beilleszteni. Ezzel a megoldással könnyű olyan szimulációkat írni, melyek futtatását a keretprogrammal kényelmesen végre lehet hajtani.

A környezet a következő fő funkciókkal rendelkezik:

  • Szimulációk egyszerű konfigurálhatósága
  • Munkakönyvtár meghatározása
  • Szimulációk dinamikus betöltése (a VI front panelje is követhető)
  • Hátralévő iterációk és idő előrejelzése
  • Félbehagyott szimulációk folytatása

A környezet továbbfejlesztését is tervezem többek között a következő funkciókkal:

  • Egy futtatás során különböző szimulációs VI-ok betöltése
  • Konfigurációs fájlok betöltése az egyes iterációkhoz
  • Szimulációk futtatása több gépen, párhuhamosan

A következő képeken bemutatok néhány képernyőképet és a feladatok végrehajtását VI-t.

Feladatok végrehajtása

Feladatok végrehajtása

A szimulációt végrehajtó VI front panelje futtatás közben

A szimulációt végrehajtó VI front panelje futtatás közben

A keretprogram diagramja

A keretprogram diagramja

A program még fejlesztés alatt áll, de kérésre bárkinek elküldöm a forrásokat.