VHDL Basys3: Connect 4 משחק: 5 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:15

מבוא:

זהו משחק היגיון דיגיטלי של Connect 4 שעוצב ב- VHDL באמצעות תוכנת Vivado ומתוכנת ללוח Basys3. בנייתו ועיצובו של פרויקט זה הם ביניים, אך עולים חדשים יכולים להעתיק את השלבים ולבנות את המשחק הדיגיטלי.

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

שלב 1: פרטים וחומרים מהירים

פרטים טכניים מהירים:

• מנצל שלוש קבוצות של חיבורי PMOD בלוח (JA, JB, JC)

  • 8 סיכות (לא כולל סיכות Vcc ו- GND) המשמשות לכל מחבר PMOD
  • JA - שליטה בשורות
  • JB - שליטה על עמודות ירוקות
  • JC - שליטה על עמודות אדומות

• שעון מסך פועל במהירות 960Hz

  רק 8 נוריות דולקות בזמן נתון. המסך מתרענן במהירות שעון מהירה מספיק עד כי ניתן לאשליה כי יותר מ 8 נוריות דולקות בזמן נתון

• שעון כפתורים פועל במהירות 5 הרץ; אופציונלי ניתן לקנוס מכוון על ידי עריכת קוד VHDL.
• התנגדות פנימית של מערכי דרלינגטון מספיקה למניעת צריבה של LED

המשחק בנוי באמצעות הרכיבים והכלים הבאים:

• (1) לוח Basys3
• (2) LED Matrix Bi-color 8x5:
• (2) ULN2803 - מערכי טרנזיסטור של דרלינגטון - גליון נתונים
• סלילי חוט
• חוטי מגשר
• חשפן חוטים
• לוחות לחם (ריבוע גדול אמור להספיק)
• מולטימטר ואספקת חשמל (פתרון בעיות)

שלב 2: חיבור החומרה

הנחיות:

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

הפרויקט כולל שימוש בשני מסכי LED אך משולבים יחד ליצירת מסך אחד גדול. ניתן להשיג זאת על ידי חיבור כל השורות לאותה נקודה. מכיוון שכל מסך הוא דו-צבעי, השורות האדומות והירוקות של מסך אחד חייבות להיות קשורות גם לשורות האדומות והירוקות של המסך השני. על ידי כך, אנו יכולים לשלוט בכל השורות עם 8 סיכות בלבד. 16 הסיכות הנוספות משמשות לשליטה בעמודות התצוגה. את 8 הפינים עבור ניתן לחבר ישירות באמצעות כבלי מגשר למחברי pmod. חיבורי Pmod נכנסים תחילה לקלט של ULN2083A והפלט של ULN2083A מחובר ישירות לטור במסך. מכיוון שהעיצוב הוא 8x8, כמה עמודות לא יהיו מחוברות פיזית.

• JA: חיבורי שורה: שורה 1 עד JA: 1 לשורה 8 עבור JA: 10.
• JA: חיבורי עמודה אדומה:
• JC: חיבורי עמוד ירוק

עיין בתמונות שפורסמו כדי לדעת אילו סיכות תואמות לאילו שורות/עמודות.

הערה: הטרנזיסטורים בנויים התנגדות, ולכן נוריות ה- LED אינן דורשות התנגדות נוספת כדי להתחבר אליהן בסדרה.

שלב 3: הסבר טכני: מסך

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

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

אחסון הנתונים לתצוגה מאתחל מיד לאחר הארכיטקטורה בקובץ VHDL באופן הבא:

אות RedA, RedB, RedC, RedD, RedE, RedF, RedG, RedH: std_logic_vector (7 downto 0): = "00000000";

אות GreenA, GreenB, GreenC, GreenD, GreenE, GreenF, GreenG, GreenH: std_logic_vector (7 downto 0): = "00000000"; - נתוני שורות בהתאם לעמודה: ירוק

להלן קטע קטן של התהליך השולט במטריצת תצוגת LED.

- תהליך השולט במטריצת תצוגת LED: תהליך (ColCLK) - 0 - 16 לרענון שני משתני המטריצה 8X8 RED ו- 8x8 GREEn RowCount: טווח שלם 0 עד 16: = 0; התחל אם (rising_edge (ColCLK)) ואז אם (RowCount = 0) ואז DORow <= RedA; - נתוני שורות עבור העמודה המקבילה DOCol <= "1000000000000000"; - טריגר העמודה- חזור על קוד זה עד "0000000000000001"- שנה ל- RedB, RedC … GreenA, GreenB … GreenH

בסוף ה- GreenH, ממש לפני שהתהליך מסתיים, קטע זה נכלל כדי לאפס את RowCount לאפס.

אם (RowCount = 15) אז - הפעל מחדש את הרענון מעמודה A RowCount: = 0; אחרת RowCount: = RowCount + 1; - מעבר בין העמודות מסתיים אם;

עכשיו, כדי להסביר את השעון שנמצא ברשימת הרגישות של תהליך התצוגה. ללוח Basys3 יש שעון פנימי הפועל ב -100 מגה -הרץ. למטרותינו, זהו שעון מהיר מדי ולכן נצטרך לחלק את השעון לשעון של 960 הרץ באמצעות התהליך הבא.

- תהליך שעון הפועל ב 960Hz CLKDivider: משתנה clkcount תהליך (CLK): טווח מספר שלם 0 עד 52083: = 0; התחל אם (rising_edge (CLK)) ואז clkcount: = clkcount + 1; אם (clkcount = 52083) אז ColCLK <= not (ColCLK); clkcount: = 0; סוף אם; סוף אם; סוף תהליך;

שלב 4: הסבר טכני: שינוי המידע המוצג

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

- תהליך שעון הפועל ב -5 הרץ. ButtonCLK: משתנה תהליך (CLK) btnclkcount: טווח מספר שלם 0 עד 10000001: = 0; התחל אם (rising_edge (CLK)) ואז אם (btnclkcount = 10000000) אז btnclkcount: = 0; BtnCLK <= not (BtnCLK); אחר btnclkcount: = btnclkcount + 1; סוף אם; סוף אם; סוף תהליך;

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

סמן: משתנה process (BtnCLK) OCursorCol: STD_LOGIC_VECTOR (2 עד 0): = "000"; - OCursorCol עוקב אחר משתנה הטור הקודם NCursorCol: STD_LOGIC_VECTOR (2 downto 0): = "000"; -NCursorCol מגדיר את עמודת הסמן החדשה מתחילה-מצב RESET (לחצן UP)-הלוח מוסר למשחק כדי להפעיל מחדש אם (rising_edge (BtnCLK)) ואז אם (RST = '1') ואז RedA <= "00000000"; RedB <= "00000000"; RedC <= "00000000"; RedD <= "00000000"; RedE <= "00000000"; RedF <= "00000000"; RedG <= "00000000"; RedH <= "00000000"; GreenA <= "00000000"; GreenB <= "00000000"; GreenC <= "00000000"; GreenD <= "00000000"; GreenE <= "00000000"; GreenF <= "00000000"; GreenG <= "00000000"; GreenH if (Lbtn = '1') אז NCursorCol: = "111"; - עמ 'H elsif (Rbtn =' 1 ') ואז NCursorCol: = "001"; - עמוד B elsif (Cbtn = '1') ואז NCursorCol: = OCursorCol; - העמודה נשארת אותו NTurnState <= not (TurnState); - מפעיל את התור של השחקן הבא- בודק את העמודה הנוכחית מלמטה למעלה ומדליק נורית LED ראשונה שאינה דולקת. הצבע תלוי בצבע הסמן של השחקן הנוכחי. עבור ck ב- 7 downto 1 לולאה אם (RedA (0) = '1') ו- (RedA (ck) = '0') ו- (GreenA (ck) = '0') ואז RedA (Ck) <= '1'; RedA (0) <= '0'; יְצִיאָה; סוף אם;

אם (GreenA (0) = '1') ו- (RedA (ck) = '0') ו- (GreenA (ck) = '0') אז

GreenA (Ck) <= '1'; GreenA (0) - שחקן אדום GreenA (0) <= '0'; if (NCursorCol = OCursorCol) אז - אם לא נלחץ דבר RedA (0) <= '1'; elsif (NCursorCol = "111") אז - אם Lbtn נלחץ RedH (0) <= '1'; RedA (0) <= '0'; elsif (NCursorCol = "001") אז - Iff Rbtn נלחץ RedB (0) <= '1'; RedA (0) - Green Player RedA (0) <= '0'; אם (NCursorCol = OCursorCol) אז GreenA (0) <= '1'; elsif (NCursorCol = "111") ואז GreenH (0) <= '1'; GreenA (0) <= '0'; elsif (NCursorCol = "001") ואז GreenB (0) <= '1'; GreenA (0) <= '0'; סוף אם; מקרה סיום;

שים לב, הצהרת המקרה הראשונה הנקראת: OCursorCol (המייצגת את עמוד הסמן הישן) היא תחילתה של מכונת המצב הסופי. כל עמודה בתצוגה מטופלת כמצב משלה ב- FSM. ישנם 8 עמודות ולכן נעשה שימוש במערך מספרים בינארי של 3 סיביות לזיהוי כל עמודה כמצב. האופן שבו FSM נע בין המדינה תלוי בכפתור שלוחצים עליו. בקטע שלמעלה, אם תלחץ על הלחצן השמאלי, FSM יעבור ל" 111 "שתהיה העמודה האחרונה של התצוגה. אם תלחץ על הכפתור הימני, FSM יעבור ל "001" שתהיה העמודה השנייה של התצוגה.

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

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

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

שלב 5: קוד

זהו הקוד הפונקציונלי של ה- Connect 4 שניתן להרכיב ב- VHDL באמצעות תוכנת Vivado.

יש גם אילוץ שיאפשר לך להפעיל את המשחק.

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