יום ראשון, 26 באפריל 2015

לימוד VHDL מהבסיס דלגלגים חומר של כיתה יד' הנדסאי אלקטרוניקה מיתוג חינם הנדסאי אלקטרוניקה ומחשבים תרגילים ופתרונות איך פותרים חומרים הסברים דרך מלאה


לימוד VHDL מהבסיס דלגלגים חומר של כיתה יד' הנדסאי אלקטרוניקה מיתוג חינם הנדסאי אלקטרוניקה ומחשבים
תרגילים ופתרונות איך פותרים חומרים הסברים דרך מלאה מדריך VHDL מהי השפה VHDL

במסע הזה אני אשים דגש על עבודה מתוך חשיבה, מתוך היגיון ופחות מתוך זיכון.
המילה שכחתי נפוצה מאוד כתשובה לשאלה: את יודע איך עושים.. מה הפתרון? מה הדרך?
התשובה פה לא אמורה להיות מקובלת במסע הזה כי אין עיקר הדרך היא זיכרון, אלא עיקר הדרך היא חשיבה ובנייה תןך כדי שימוש בכלים ידועים מראש שאיתם נבנה וניצור ונפתור את כל שאלותינו.

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

יש לנו שני אפשריות: אפס לוגי ואחד לוגי. (אפס לוגי - מתח טפס, אחד לוגי - בערך חמישה וולט: הכוונה לשני שני דברים שונים אשר נבדלים ביניהם במתח מוסכם).

המבנה הכללי של הדלג-לגים (flip flops):
הכניסות של הדלגלג לפי השם שלו: למשל לדלגלג D יש כניסה D, לדלגלג JKFF יש כניסות J ו-K.
CLOCK/ENABLE - כניסה שמורה (שנותנת הוראה) לדלגלג מתי לפעול (הדלגל יכול להיות פעיל בעלייה או בירידה - יש הסבר בהמשך).
Q - הדק יציאה שבו מתקבלת התוצאה (לפי מה שהכנסנו בדלגלג).
Q גג - הוא תמיד יהיה ההפך
בהמשך נלמד על כניסות נוספות שבהם נשתמש לצרכים שונים.

הדלגלג הראשון שאנחנו נלמד הוא DFF, D FLIPFLOP, כשמו כן הוא: DATA, נתון. תפקידו הוא לשמור לנו את הנתון כמו שהוא.
למשל אנחנו רוצים לתפוס נתון של שמונה סיביות משמונה הדקים. נחבר לכל הדק D FLIPFLOP, DFF משלו. (נחבר את ההדק ל-D).
באותו רגע שנרצה את הנתון בעל שמונה הסיביות, נשלח אל הדקי ה- CLK ׁ(הדק ה- CLOCKׂ שעון) או הדק ה ENL (הדק ה-ENABLE אפשור) פולס מתח, או נוריד אותו לאפס (פולס זה לרגע) (תלוי אם הוא עובד בירידה או בעלייה, אם הוא עובד בירידה נוריד את המתח לאפס לרגע, אם הוא עובד בעלייה נעלה את המתח לרגע).
הנתונים שלנו יישמרו ב DFF, (יהיו ב Q שלהם) נוכל להשתמש בהם כרצונם, ואיננו תלויים עוד בהדקי השמונה סיביות כבר תפסו את הנתון שאנו רוצים.

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

הגדרת המושג עובד בירידה: כאשר אנו עובדים בירידה, ה-flip flop / הדלגלג יעבור רק כאשר ב-CLK יהיה מעבר בין אחד לוגי לאפס לוגי (הוא יורד מאחד לוגי (מלעלה) לאפס לוגי (למטה)).

בדלג לג DFF מה שנכנס הוא מה שיוצא.

אם נכנס ב-D אפס לוגי: יוצא ב-Q אפס לוגי. (לא משנה מה היה ב-Q לפני כן)
אם נכנס ב-D אחד לוגי: יוצא ב-Q אחד לוגי. (לא משנה מה היה ב-Q מקודם)



הדלגלג הבא הוא TFF, TOGGLE FLIPFLOP, נדנדה
באחד לוגי אנחנו עושים נדנוד בין שני מצבים: הוא ישנה את המצב הנוכחי של ה-Q. אם ה-Q היה אפס הוא יהיה אחד, אם ה-Q היה אחד הוא יהיה אפס.
במצב של אפס לוגי לא יהיה שינוי (יש להבין כי להישאר באותו מצב נחשב גם שינוי): אם ה-Q היה אפס יהיה אפס, אם ה-Q היה אחד יהיה אחד.



שימושים של TFF, T FLIP FLOP - בעזרת דלגלג הנדנדה אפשר ליצור מחלק תדר ובו בעת אנו יוצרים גם מונה: נסביר.
כאשר אנו רוצים רוצים לספור בבינארי אנו עושים טבלה: כול העמודות מתחילות מאפס. 
בעמודה הקיצונית הימנית - כל פעם אחת בלבד יש שינוי. 0 1 0 1 0 1 0...
בעמוד השנייה מימין כל פעמיים יש שינוי: 0 0 1 1 0 0 1 1 0 0 1 1...
בעמוד השלישית מימין כל ארבע פעמים יש שינוי 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
וכך הלאה.
כך בכל שורה אנחנו יוצרים מספר:
00000000=0
00000001=1
00000010=2
00000011=3
00000100=4
00000101=5
00000110=6
וכך הלאה.

אם ניצור לכל אחד מהעמודות  גל ריבועי משלו מצב זה יהיה כך:
נניח כי כל פולס הוא בזמן של 15mily second.
בטור הראשון מימין: 
זמן המחזור: 30mily second
התדר:33.33Hz

בטור השני מימין:
זמן המחזור: 60mily second
התדר: 16.66Hz

בטור השלישי מימין:
זמן המחזור: 120mily second
ותדר: 8.33Hz

אפשר לשים לב כי התדר שלנו מתחלק ב-2, ואילו זמן המחזור שלנו גודל פי 2, זה מחלק התדר שלנו, וזה מה שויצא  מכל דלגלג נדנדה אם נחבר את היציאה (Q) של הדלגלג לשעון של הדלדלג הבא, ככה בשרשרת (בתנאי שנחבר אחד לוגי בכניסה של הדלגלג. (T).

נסביר איך זה קורה:
נשתמש בכניסות T, CLK
בכניסה T נשים אחד לוגי באופן קבוע.
בכניסה CLK נחבר גל ריבועי עם DC=Duty cycle של 50% זאת אומרת משך הזמן שלו באחד לוגי שווה למשך הזמן שלו באפס לוגי. הגל הריבועי הזה הוא של ריבועי של 0.5mily second לכל פולס. 0 1 0 1 0 1 0 1 0 1 0 1 0.
נניח שהדלג-לג הזה עובד בירידה  (כל פעם שב CLK יש אחד לוגי אז ה-TFF הדלגלג שלנו יפעל). כאשר דלגלג הנדנדה מקבל (ב-T) אחד לוגי הוא ישנה את המצב הנוכחי של ה-Q. אם ה-Q היה אפס הוא יהיה אחד, אם ה-Q היה אחד הוא יהיה אפס.
נניח שב-Q יש אפס לוגי.
קיבלנו פולס של אפס לוגי במשך זמן של0.5mily second, אחר כך קיבלנו פולס של אחד לוגי אחרי 0.5mily second - יש ב-Q אפס לוגי שהופך לאחד לוגי. קיבלנו שוב פולס של אפס לוגי במשך0.5mily second, אחרי זה קיבלנו פולס של אחד לוגי במשך0.5mily second ואז ה-Q ישנה מצב הוא יהיה אפס לוגי שוב... זאת אומרת אחרי 0.5mily second ועוד 0.5mily second  יש לנו שינוי מצב. כל 1mily second יש שינוי מצב
מזכיר את 0 0 1 1 0 0 1 1 0 0 1 1 0 0
(בעצם זה אותו דבר)

היציאה ׁׁQ של הדלגלג הראשון מחוברת ל-CLK של הדלגלג השני שה-T שלו מחובר באופן קבוע לאחד לוגי.
נניח שה-Q הנוכחי שלו הוא אפס. רק כאשר יתקבל אחד לוגי ב-CLK ישתנה המצב הנוכחי של ה-Q.
ב-CLK יש 1mily second של אפס לוגי, ואז 1mily second של אחד לוגי וה-Q משנה מצב - אחד לוגי.
ב-CLK יש 1mily second של אפס לוגי, ואז 1mily second של אחד לוגי וה-Q משנה מצב - אפס לוגי.
ב-CLK יש 1mily second של אפס לוגי, ואז 1mily second של אחד לוגי וה-Q משנה מצב - אחד לוגי.
שינוי מצב: 1mily second ועוד 1mily second. כל 2mily second, זמן המחזור הוא4mily second כל פולס 0.5mily second, לכן 0 0 0 0 1 1 1 0 0 0 0 1 1 1 1

זה בידיוק מה שהסברנו למעלה.




הדלגלג הבא הוא SRFF, SET RESET FLIP FLOP, דלגלג שים אחד שים אפס.
הפירוש של SET - הוא לשים אחד לוגי.
הפירוש של RESET הוא אפס לוגי (או לאפס).
כאשר יש ב SET וב-RESET אפס לוגי - מה שהיה ב-Q הופך למה שהיה ב-Q.

כאשר יש אפס ב-SET, וב-RESET יש אחד - לא משנה מה היה ב-Q הוא יהיה אפס.

כאשר יש אחד ב-SET, וב-RESET יש אפס - לא משנה מה הי ב-Q הוא יהיה באחד.

כאשר יש אחד ב-SET, וב-RESET יש אחד - זה מצב שאסור שיקרה! מצב אחד אומרים לו לשים אפס לוגי, ומצד שני אומרים לו לשים אחד לוגי. (זה יגרום למצב שבו Q יהיה זהה ל-Q גג וזה יתקע את הדלגלג שלנו).





הדלגלג האחרון שאנחנו נלמד עליו (יש בסך הכל ארבעה) הוא JKFF, JK FLIP FLOP
J - עובד בידיוק כמו SET
K - עובד בדיוק כמו RESET
הדלגלג האחרון בא לפתור את הבעיה של הSRFF (של דלגלג שים אחד שים אפס) בכך שאם J ו-K באחד לוגי ה-Q שלו משנה מצב: אם במצב הנוכחי ה-Q היה אפס אז הוא יהיה אחד, אם במצב הנוכחי ה-Q היה אחד אז הוא יהיה אפס.




לכל הדלגלגים יש שני כניסת נוספות:
RESET/CLEAR - מאפס את הכל
PRESET - שמה אחד לוגי.
בעזרת הכניסות  הבאות ניתן לשלוט בצורה יותר מבוקרת על הנעשה בדלגלג.



שאלה תרגיל משימה
בנה בעזרת כל הדלגלגים את הדלגלג TFF ׁׁׁ(דלגלג הנדנדה).
פתרון:
דלגלג נדנדה אומר שכל פעם שהדלגלג יופעל אז המצב של Q ישנה מצב, אם Q היה אחד אז הוא יהיה אפס, אם Q היה אפס הוא יהיה אחד.

ב-JKFF יש לנו את המצב הזה, כאשר J באחד לוגי וגם K באחד לוגי, לכן אנחנו נבחר באופן קבוע אחד לוגי ל-J ול-K.

ב-DFF
אנו רוצים לשנות את מצבו של Q ברגע שהדלגלג ייפעל.
אם ה-Q אפס אנחנו רוצים שהוא יהיה אחד.
אם ה-Q אחד אנחנו רוצים שהוא יהיה אפס.
מה שנכנס ל-D זה מה שיוצר ב-Q.
אם יהיה אפס ב-Q אנו צריכים שהוא יהיה אחד: אז נכניס ל-D אחד ואז זה יתרחש

אם יהיה אחד ב-Q אנו צריכים שהוא יהיה אפס: אז נכנס ל-D אפס ואז זה יתרחש.

בעצם אם נכניס ל-D את Q גג זה בידיוק מה שזה יעשה. (זה הפתרון).

ב-SRFF אנחנו רוצים
 שאם יהיה אפס ב-Q אז הוא יהיה אחד, כדי שיהיה אחד אנו צריכים:
S=1
R=0
לתוך S נכניס את ההפוך של Q
לתוך R נכניס את Q


אם יהיה אחד ב-Q אנחנו רוצים שיהיה בו אפס, זאת אומרת צריך:
S=0
R=1
לתוך S אנחנו נכניס את ההפוך של Q.
לתוך R אנחנו נכניס את Q.

שמנו לב שבשני המקרים (מעבר של Q לאפס מאחד, ומעבר של Q לאחד מאםס) אנחנו עושים את אותו דבר.

ההפוך של Q = Q גג.

לכן אנחנו נחבר את Q גג אל S.
ואנחנו נחבר את R  לQ.

והנה לנו הפתרון.






ניתוח מעגלי דלגלגים:





אני אלמד אתכם את כל מה שאתם צריכים לדעת על התרגיל הזה:

נתחיל בניתוח המעגל באמצעות טבלה:

יש לנו חלק שמאלי של הטבלה וחלק ימני.
אנחנו מתחיל בחלק השמאלי (יציאות הדלגלגים (המוצא) - אם לא צויין אחרת כולם אפס בהתחלה.
אחר כך אנחנו מלא את החלק הימני: הוא כל החוטים שמתחברים אל כל הדלגלגים.

המעבר מהחלק השמאלי לחלק הימני כרוך במה שרואים זה מה שמעבירים.

המעבר מחלק הימני לשמאלי כרוך בחוקי הדלגלגים.

כך נבנה את הטבלה שלנו:


K2='1'
J2=Q0ANDQ1
K1=Q0
J1=Q0
D0=Q0GAG
////////////
Q2
Q1
Q0





////////////








////////////








////////////











VHDL היא שפה של רכיבים מתכנתי.
אין הגבלה לדברים שאפשר ליצור ולבנות בשפ הזו, ברכיב אחד יש עשרות אלפי שערים לוגיים, דלגלגים: ניתן לבנות בעזרת שפה זו כל כך הרבה דברים: האפשרויות עם פרי המתכנת בלבד.


מבנה השפה:
בשפה שלנו אנו יוצרים ישות (ENTITYׂ) אחת בלבד. בישות אנחנו נגדיר את כל הכניסות (in) ואת כל היציאות (out) של המערכת ואת הטיפוס שלהם.
יש ארכיטקטורה (architecture)  אחת בלבד אשר מקושרת לישות: בארכיטקטורה אנחנו נגדיר את כל הקשר בין הכניסות והיציאות, קשרים לוגיים (AND, XOR, NOR... על פי הנדרש)

אנחנו כותבים את השפה, בשפה האנגלית בלבד.
השם של הקובץ בסיומת vhd. למשל: name.vhd.
השם של הישות חייב להיות אותו שם של הקובץ.
אין הבדל בין אותיות קטנות או גדולות (Entity ENTITY eNtity - הכל נחשב אותו דבר).
בין סוף פקודה לפקודה יש נקודה פסיק (;).
אם אנחנו רצים לכתוב הערה אנחנו נשתמש בסימן --.

מבנה הכתיבה:

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

סיום התכנית.


פקודות אתחול

LIBRARY IEEE;
USE IEEE.std_logic_1164.all;


ניצור ישות

entity name1 is
port (a,b : in type;
     c,d : out type);
end entity;


הסברים:

name1 - השם של הישות, זה אותו של של הקובץ, שם הקובץ חייב להיות nam1,vhd

type - טיפוס הכניסה, בינתיים נלמד על סוג אחד: bit. יכול להיות שני אפשרויות: או אפס או אחד.

architecture name2 of name1 is
begin
name_of_bit<= name_of_bit xor name_of_bit;
name_of_bit <= name_of_bit xnor name_of_bit;
name_of_bit<= name_of_bit or name_of_bit;
name_of_bit <= name_of_bit nor name_of_bit;
name_of_bit <= name_of_bit and name_of_bit;
name_of_bit <= name_of_bit nand name_of_bit;

end architecture;



פעולות לוגיות שניתן לעשו בין ביטים
xor
xnor
or
nor
and



כתוב תכנית בעלת שתי כניסות A.B אשר הכניסות הללו מניבות לנו את כל השערים הלוגיים הקיימים.


פתרון:
LIBRARY IEEE;
USE IEEE.std_logic_1164.all;

entity gamzolla is
port (a,b : in bit;
      Xor_out, xnor_out, or_out, nor_out, and_out, nand_out : out bit);
end entity;


architecture gam of gamzolla is
begin
Xor_out <= a xor b;
Xnor_out <= a xnor b;
or_out<= a or b;
nor_out <= a nor b;
and_out <= a and b;
nand_out <= a nand b;

end architecture;




משימה
תכנן מפענח בעל שתי S0  ו-S1  וארבע מוצאים     Y0 Y1 Y2 Y3


Y3
Y2
Y1
Y0
S1
S0
1
1
1
0
0
0
1
1
0
1
1
0
1
0
1
1
0
1
0
1
1
1
1
1


איך ניגשים לתרגיל כזה, אנו צריכים להשתמש במפות קרנו על מנת שנבנה לנו פונקציות מצומצמות עם פעולות לוגיות (AND XOR OR..)

אנחנו נעשה מפת קרנו של שני משתנים (המשתנים שלנו הם הכניסות) ונעשה מפת קרנו ארבע פעמים לכל מוצא (כמספר המוצאים).

בישות אנחנו נגדיר את כל הכניסות ואת כל המוצאים.

בארכיטקטורה אנחנו נרשום את כל תוצאות הפונקציות.


מי שלא זוכר מפות קרנו או רוצה ללמוד, נא ללחוץ כאן


התוצאות של מפת קרנו:

Y0= S0+S1
Y1=S0+S1 GAG
Y2=S0 GAG + S1
Y3 = S1 GAG + S0 GAG

לכן התכנית תהיה


LIBRARY IEEE;
USE IEEE.std_logic_1164.all;

entity gamzolla is
port (S0,S1 : in bit;
         Y0, Y1, Y2,Y3 : out bit);
end entity;


architecture gam of gamzolla is
begin
Y0 <= S0 and S1;
Y1 <=  S0 and not (S1);
Y2 <= NOT (S0) and  S1;
Y3 <=  not (S1)  and NOT (S0) ;

end architecture;



בנה מערכת בעלת 3 כניסות A B C ובעלת 2 מוצאים X Z
X=B XOR C    Z=A OR B

LIBRARY IEEE;
USE IEEE.std_logic_1164.all;

entity gamzolla is
port (A,B,C : in bit;
        X, Z : out bit);
end entity;


architecture gam of gamzolla is
begin
X <= B xor C;
Z <=  A OR B;

end architecture;






ההבדלים בין signal ו variable

signal מוגדר בין הארכיטקטורה ל-begin וקיים לאורך לכל כל הארכיטקטורה, ואילו variable מוגדר בין ה-process ל-begin שלו ומוכר רק ב-process עצמו, לכן הוא יותר חסכוני במשאבי זיכרון.

אופן עדכון הנתונים ב-signal הוא בסיום ה-process, כלומר רק בסיום ה-process מבוצעת פעולת ההשמה =>, בניגוד לכך עדכון הנתונים ב-variable הוא מיידי! כלומר פעולת ההשמה =: חלה מיד.

שמו של ה-signal נשמר, ואילו שמו של ה-variable נאבד ומקבל שם חדש




signal הוא משתנה גלובלי שמגדירים בארכיטקטורה.
variable משנה מקומי לוקאלי, מוגדר אל ורק בתוך ה-PROCESS. מטרתו הוא להעביר מידע מ-process אחד לשני. משתנה ביניים שמאפשר לנו לאחסן תוצאות ביניים, בדרך כלל לא נוצרת לנו חומרה שלו. את תוצאות הביניים שלו אנחנו מאחסנים בחומרה. ההשמה מתבצעת בזמן אמיתי real time ולא מחכה לסיום ה-PROCESS.


אחרי עליית שעון אסור לכתוב else!


אין תגובות:

הוסף רשומת תגובה