כיצד לעבוד עם vhdl באמצעות תוכנה חופשית

השיעורים של הנדסת אלקטרוניקה בדרך כלל מוכתבים באמצעות כלים פופולרייםאז אני תמיד מבלה כמה שעות בחיפושים לעשות איתי את העבודה שלי תוכנה חופשית. מסיבה זו החלטתי לשתף את הדברים הבאים להנחות את.

התקנת הצורך

כדי להרכיב ולדמות את התוכניות שלנו נשתמש ב- GHDL, מהדר חינם המבוסס על GCC. כדי לראות את תוצאות הסימולציה, נשתמש ב- GTKWAVE. כעורך אני ממליץ על Geany מכיוון שהוא מכיר כמעט בכל שפות התכנות.

sudo apt-get להתקין ghdl gtkwave geany

פרויקט לדוגמא

בואו נשתמש במשווה זה כדוגמה:

לפני יצירת פרויקט, נתחיל ביצירת תיקיה בה יתארחו כל הקבצים. במקרה זה, / home / user / vhdl. שם נשמור את קוד המקור של התוכניות שלנו עם סיומת .vhd.

לאחר מכן אנו כותבים את התוכנית שלנו באמצעות Geany, כפי שנראה בתמונת המסך.

אנו שומרים את זה כ- compar.vhd.

כעת נצטרך ליצור את האותות לסימולציה. לשם כך ניצור רכיב המשתמש בבלוק הקודם ונפרט את האותות.

הקווים A <= "0011" אחרי 0 ns, "0111" אחרי 5 ns, "0111" אחרי 10 ns; הם אלה שמגדירים את אותות הקלט בזמן

אנו שומרים את הקבצים ב- / home / user / vhdl. לאחר מכן אנו פותחים מסוף ומקבצים:

ghdl -a Compare.vhd

אם אין הודעות שגיאה, האוסף מצליח.

כעת אנו מרכיבים את "הרכיב"

ghdl -a Compare_tb.vhd

אם אין שגיאות, אנו יוצרים את הפעלת ההפעלה:

ghdl -e השווה_טב

לבסוף נותר לבצע את הסימולציה ולשמור את התוצאות בשם "Compare.vcd"

ghdl -r השווה_טב - vcd = השווה. vcd

על מנת לראות את התוצאות נשתמש ב- gtkwave:

gtkwave Compare.vcd

לאחר הפתיחה, השתמש במקש Ctrl ובעכבר כדי להצביע על האותות שמעניינים אותנו ולחץ על הכנס. לאחר מכן לחץ פעמיים על הווקטורים כדי לראות את האותות הנפרדים. לאחר מכן לחץ לחיצה ימנית על האותות לבחירת הפורמט (בינארי, hex, אוקטלי, עשרוני וכו ')

במידת הצורך, כפתור הזכוכית המגדלת עם ריבוע במרכז מכוון את הגרף למסך.

ALU: יחידת חשבון ולוגיקה

אוקיי, עכשיו בואו נעשה משהו יותר מעניין: ALU (יחידה אריתמטית והגיונית). זו תהיה יחידה לוגית, יחידת חשבון ומולטיפקסר.

כונן לוגי (LoU.vhdl)

     ספריה ieee; השתמש ב- IEEE.STD_LOGIC_1164.all; השתמש ב- IEEE.NUMERIC_STD.all;

ישות אתה
PORT (op1: IN std_logic_vector (7 DOWNTO 0);
op2: IN std_logic_vector (7 DOWNTO 0);
תהליך: IN std_logic_vector (3 DOWNTO 0);
res: OUT std_logic_vector (7 DOWNTO 0));
END לו;

ארכיטקטורה synth2 של Lou IS
איתות א, ב: לא חתום (op1'range);
איתות ג: לא חתום (סידור מחדש);
התחל
תהליך (a, b, תהליך)
התחל
תהליך המקרה הוא
מתי "0000" => c <= RESIZE ((לא a), c'length);
מתי "0001" => c <= גודל ((a ו- b), c'length);
מתי "0010" => c <= גודל ((a או b), אורך c);

מתי "0011" => c <= גודל ((א x או ב), אורך c);
מתי "0100" => c <= RESIZE ((a nand b), c'length);
מתי "0101" => c <= RESIZE ((a ולא b), c'length);
מתי אחרים => null;
מקרה סיום;
לסיים תהליך;

a <= לא חתום (op1);
b <= לא חתום (op2);
res <= std_logic_vector (c);

END synth2;

יחידת חשבון (ArU.vhd)

     ספריה ieee; השתמש ב- IEEE.STD_LOGIC_1164.all; השתמש ב- IEEE.NUMERIC_STD.all;

ENTITY aru IS
PORT (op1: IN std_logic_vector (7 DOWNTO 0);
op2: IN std_logic_vector (7 DOWNTO 0);
תהליך: IN std_logic_vector (3 DOWNTO 0);
res: OUT std_logic_vector (7 DOWNTO 0));
END aru;

ארכיטקטורה סינטטי של ארו IS
איתות א, ב: לא חתום (op1'range);
איתות ג: לא חתום (סידור מחדש);
התחל
תהליך (a, b, תהליך)
התחל
תהליך המקרה הוא
מתי "0000" => c <= גודל ((a + b), אורך c);
מתי "0001" => ג <= גודל ((א - ב), אורך c);
מתי "0010" => c <= RESIZE ((a * b), c'length);

מתי "0011" => c <= RESIZE ((a / b), c'length);
מתי "0100" => c <= גודל ((a + "1"), אורך c);
מתי "0101" => c <= RESIZE ((b + "1"), c'length);
מתי אחרים => null;
מקרה סיום;
לסיים תהליך;

a <= לא חתום (op1);
b <= לא חתום (op2);
res <= std_logic_vector (c);

סיומת סיום;

מרבב (muxVector.vhd)

     ספריה ieee; השתמש ב- IEEE.STD_LOGIC_1164.all; השתמש ב- IEEE.NUMERIC_STD.all;

ENTITY muxVector IS
נמל (מ- ARU: IN std_logic_vector (7 DOWNTO 0);
fromLOU: IN std_logic_vector (7 DOWNTO 0);
מתג: IN std_logic;
פלט: החוצה std_logic_vector (7 DOWNTO 0));
סוף muxVector;

שינוי ארכיטקטורה של muxVector IS
התחל
עם מתג בחר
פלט <= מ- ARU כאשר '0', מ- LOU כאשר אחרים;
שינוי END;

רכיב ALU (aluComponent.vhd)

     ספריה ieee; השתמש ב- IEEE.STD_LOGIC_1164.all; השתמש ב- IEEE.NUMERIC_STD.all;

ENTITY alu רכיב IS
END aluComponent;

ארכיטקטורה inputs_alu רכיב של alu רכיב IS

רכיב aru
PORT (op1: IN std_logic_vector (7 DOWNTO 0);
op2: IN std_logic_vector (7 DOWNTO 0);
תהליך: IN std_logic_vector (3 DOWNTO 0);
res: OUT std_logic_vector (7 DOWNTO 0));
רכיב סיום;

רכיב לו
PORT (op1: IN std_logic_vector (7 DOWNTO 0);
op2: IN std_logic_vector (7 DOWNTO 0);
תהליך: IN std_logic_vector (3 DOWNTO 0);
res: OUT std_logic_vector (7 DOWNTO 0));
רכיב סיום;

רכיב muxVector
נמל (מ- ARU: IN std_logic_vector (7 DOWNTO 0);
fromLOU: IN std_logic_vector (7 DOWNTO 0);
מתג: IN std_logic;
פלט: החוצה std_logic_vector (7 DOWNTO 0));
רכיב סיום;

SIGNAL outputARU: std_logic_vector (7 DOWNTO 0);
SIGNAL outputLOU: std_logic_vector (7 DOWNTO 0);
מתג אות: std_logic;
תהליך אות: std_logic_vector (3 DOWNTO 0);
פלט אות: std_logic_vector (7 DOWNTO 0);
איתות A: std_logic_vector (7 DOWNTO 0);
אות B: std_logic_vector (7 DOWNTO 0);

התחל
u0: aru PORT MAP (A, B, process, ARU exit);
u1: lou PORT MAP (A, B, process, LOU output);
u2: muxVector PORT MAP (פלט ARU, פלט LOU, מתג, פלט);

A <= "00000011" אחרי 0 ns, "00000111" אחרי 5 ns, "00000111" אחרי 10 ns, "00001001" אחרי 15 ns, "00000000" אחרי 20 ns, "00000101" אחרי 25 ns, "00001111" אחרי 30 ns, "00000101" לאחר 35 ns;
B <= "00000010" אחרי 0 ns, "00000100" אחרי 5 ns, "00000010" אחרי 10 ns, "00000011" אחרי 15 ns, "00000100" אחרי 20 ns, "00000110" אחרי 25 ns, "00001111" אחרי 30 ns, "00000011" לאחר 35 ns;
החלף <= '1' אחרי 0 ns, '0' אחרי 5 ns, '1' אחרי 10 ns, '0' אחרי 15 ns, '1' אחרי 20 ns, '0' אחרי 25 ns, '1' אחרי 30 ns, '0' אחרי 35 ns, '1' אחרי 40 ns;
תהליך <= "0000" אחרי 0 ns, "0001" אחרי 5 ns, "0010" אחרי 10 ns, "0011" אחרי 15 ns, "0100" אחרי 20 ns, "0101" אחרי 25 ns, "0110" אחרי 30 ns;
END inputs_aluComponent;

כדי לא לבזבז זמן על קומפילציה של פקודה לפי פקודה בזמן העבודה על התוכנית, אנו שומרים קובץ בשם compilar.sh עם התוכן הבא באותה תיקייה:

ghdl -a lou.vhd && ghdl -a aru.vhd && ghdl -a muxVector.vhd && ghdl -a aluComponente.vhd && ghdl -e aluComponente && ghdl -r aluComponent --vcd = alu & componente.wave

פתח מסוף, הזן את התיקיה והפעל את הסקריפט:

cd / home / user / vhdl sh compile.sh

אם אין שגיאות gtkwave ייפתח ואנחנו יכולים לראות את האותות:

כלים אלה היו מאוד שימושיים וקלים יותר לשימוש מאשר הכלים הקנייניים בהם אנו משתמשים בכיתה, שלוקח באופן חשוד זמן רב להידור. עם ghdl לוקח יותר זמן להחליף חלונות מאשר לקמפל.

מידע נוסף על VHDL

לאלה החדשים ב- vhdl, כאן יש להם דוגמה בסיסית להכחיש.

סרטון לדוגמא:
http://www.youtube.com/watch?v=feVMXsyLSOU

זכור כי בגירסאות האחרונות של אובונטו אין מאגר GHDL. ניתן להוריד את זה עבור Linux / Windows מדף הפרויקט:
http://ghdl.free.fr/site/pmwiki.php?n=Main.Download