משחק המוח ב- VHDL: 3 שלבים

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

עבור הפרויקט שלנו, יצרנו את משחק "Mastermind" ב- VHDL שישוחק על לוח Basys3. Mastermind הוא משחק שבירת קוד המשוחק באופן מסורתי עם יתדות ולוח משחקים. השחקן הראשון מציב יתדות של צבעים מגוונים בשורה של 4, מוסתרות מהשחקן השני. לשחקן השני יש אז מספר 'ניחושים' המניחים יתדות על הלוח בשורה הנראית לשחקן הראשון. לאחר כל ניחוש, שחקן שני נודע ל -2 מספרים: כמה יתדות הן הצבע הנכון, וכמה יתדות נמצאות במיקום הנכון בשורה. באמצעות רמזים אלה, שחקן שני חייב לנחש את רצף הסיכות הנכון שהשחקן הראשון הניח במספר הניחושים שהוקצו.

ביישום שלנו, המשחק הוא שחקן יחיד. התוכנית יוצרת שילוב אקראי של יתדות, והשחקן חייב להשתמש בלוח Basys3 כדי לנחש את הרצף הנכון. ישנם ארבעה "צבעים", המיוצגים על ידי ערכים בינאריים. התצוגה בת 7 החלקים מציגה שלושה ערכים: סיבובים שנותרו, מספר הפינים במיקום הנכון ומספר הפינים שהם הצבע הנכון במיקום הלא נכון (ערכים אלה מתחילים ב -9, 0 ו -0). השחקן משתמש במתגים שעל הלוח כדי לבחור את הערכים הבינאריים עבור הניחוש שלו, ומעיף מתג נוסף כדי להגיש את הניחוש. אם הם נכונים, המשחק מסתיים ותצוגת 7 הפלחים מציגה "GG". אם לא, מונה הסיבובים יורד ב -1 והשחקן מקבל משוב על סמך כמה סיכות בניחוש שלו תואמות את הצבע או המיקום של הסיכות בשילוב. אם לשחקן נגמרות הסיבובים מבלי לנחש נכון, התצוגה מציגה "GO" (מייצג משחק נגמר). השחקן יכול גם להפוך את מתג האיפוס כדי להתחיל מחדש בכל עת.

שלב 1: חומרים

מכיוון שניתן לשחק את כל המשחק על הלוח עצמו, החומרים היחידים הנדרשים הם לוח Basys3, כבל מיקרו USB לחיבור הלוח ומחשב/מחשב נייד שניתן להשתמש בו כדי לקודד אותו!

שלב 2: הקוד

כדי שהמשחק הזה יעבוד על ה- FPGA, הדרך הפשוטה ביותר לכתוב אותו תהיה ליצור מכונת מדינה. החזקת מכונת מדינה מאפשרת לחוויה הרצופה והאינטראקטיבית הדרושה כדי שהמשחק יעבוד בפועל. על מנת שהכל יתנהל בצורה חלקה, מכונת המדינה תתבסס על אות השעון הפנימי של ה- FPGA, ותבטיח שהכל מסונכרן. המודול הראשי הוא מכונת מדינה עם ארבע מצבים; מצב ראשוני (ראשוני), מצב SubmitAnswer (SubAns), מצב תצוגה (Dis) ומצב CheckEndGame (CheckEnd). יחד עם מכשיר המדינה, המודול הראשי כולל שני מודולי משנה, תצוגת שבעה קטעים בת 4 ספרות (שיש לה מודול משנה משלה ClkDivider) ומחולל המספרים האקראיים (למעשה מחולל מספר אקראי). יש גם בלוק תהליכים בסיסי כדי להדליק את נוריות ה- LED מעל כל מתג כשהוא מופעל כדרך לאנשים לראות מה הם מכניסים קל יותר. ניתן לראות סקירה בסיסית של הקוד במפת המוח בתמונה.

המרכיב הראשון שצריך להסתכל עליו הוא מחולל המספרים האקראיים (randomgen). מכיוון שלא ניתן מבחינה טכנית להשיג מספרים אקראיים אמיתיים שנוצרו מחומרה, הפתרון הפשוט ביותר היה שהאקראגן יהיה למעשה רישום משמרות לינארי (LFSR). ל- LFSR יש קלט של clk ופלט "a" (מספר 12 סיביות). בכל מחזור שעון נוצר מספר 12 סיביות חדש החל מ- "000000000001", ובסופו של דבר עובר את כל שילובי 12 סיביות של 1 ו 0 לפני שחוזר על עצמו. הפלט "a" ניתן לכל מחזור שעון, כך שהוא פועל ללא הרף. ה- clk ממופה ל- Clk מהמודול הראשי, ו- "a" ממופה לאות RandNum במודול הראשי.

תת המודול השני הוא תצוגת שבעה הפלגים בת 4 הספרות. זוהי דרך די פשוטה להציג לראווה תצוגה בת 7 ספרות בת 4 ספרות. התצוגה מוגדרת על ה- Clk מהמודול הראשי, אך תת -מודול זה כולל תת מודול משלו של ClkDivider. ClkDivider (מוגדר ל- 1298 הרץ) משמש להאיץ את השעון עבור שבעה הקטעים כך שנראה כי כל הספרות פועלות בו זמנית (מכיוון שרק ספרה אחת יכולה להיות מופעלת בכל פעם). המשתנה "ספרה" משמש למעבר בין הנקודות בתצוגה, ובכל ספרה מגיעים התנאים של תצוגת קלט בסיסית של 4 סיביות, עם אפשרויות להצגת הספרות 0 עד 9 וגם כלום. הספרה השמאלית הרחוקה ביותר בתצוגה מוגדרת לשום דבר מכיוון שהיא לא משמשת במשחק הזה.

המודול הראשי מורכב ממכשיר המדינה. ארבעת המצבים בתהליך הם Initial, SubAns, Dis ו- CheckEnd. כשהוא במצב ההתחלתי, אם SubmitBtn (המתג המשמש להגשת התשובה שלך לבדיקה) מוגדר ל- '1', המכונה עוברת למצב SubAns. בכל פעם Rbtn (מתג המשמש לאיפוס המכונה) מוגדר ל- '1', ואז המכונה חוזרת למצב ההתחלתי. כאשר הוא נמצא במצב SubAns, כאשר SubmitBtn = '0' שוב, הוא עובר למצב Dis. כשהוא במצב Dis, אם הספירה לאחור = 0 (הפניות שמאלה כדי לנחש נופלות ל -0) או אם ה- RSpotCount = 4 (כלומר השחקן הוא כל הצבעים הנכונים בנקודות הנכונות), המכונה עוברת למצב CheckEnd. אם אף אחד מאלה לא יתרחש, אז כאשר SubmitBtn = '1' שוב, הוא יחזור למצב SubAns כדי לאפשר ניחוש נוסף. כאשר נמצאים ב- CheckEnd State, זהו סוף המשחק, והדרך היחידה לצאת היא להכות את האיפוס ולהחזיר אותו למצב הראשוני. ניתן לראות זאת בקלות בתרשים מכונת המדינה. מבחינה התנהגותית המצב הראשוני מאתחל הכל בחזרה לעמדת ההתחלה. הספירה לאחור (אות שחוסך כמה סיבובים נותרו לשחקן) מוגדר ל- 9, RSpotCount (אות שחוסך כמה מהצבעים שניחשתם במקום הנכון) מוגדר ל- 0, RColorCount (אות שחוסך כמה מתוך הצבעים שניחשתם נכונים אך במקום הלא נכון) מוגדרים ל- 0, והספירה הקטנה (אות שמופה בסופו של דבר לספירה לאחור שמשנה למעשה כל סיבוב במצבים מאוחרים יותר) מוגדרת ל- 9. כמו כן, במצב הראשוני RandNum (מספר שנוצר psuedo אקראי) מחולק לארבע בדיקות שונות (אחת לכל צבע 3 סיביות) ונשמרות לאותות check1, check2, check3, check4. בדיקות אלה הן מה שההשערה שלך משווה למעשה, כך שלמרות ש- LFSR תמיד גורם ל- RandNum לשנות כל מחזור, ברגע שאתה עוזב את המצב הראשוני הבדיקות נשארות זהות, ומאפשרות לערך נשמר להשוות את התשובה שלך כנגד. זה אומר גם שבכל פעם שהמכונה מתאפסת, יש לשחקן ערך חדש לנחש.

מדינת SubmitAnswer (SubAns) משנה את מאפשרת הספירה לאחור (אות "שינוי") ל- '1'. זה נחוץ מאוחר יותר כדי שמעקב התורים יפעל. לאחר מכן, המדינה משווה את תשומות השחקנים מהמתגים לבדיקות שבוצעו במצב הנ"ל. אות rs1, rs2, rs3, rs4 ואותות rc1, rc2, rc3, rc4 הם סוגים שלמים אשר תלויים ב- אם משפטים מוגדרים ל- 1 או 0. האות rs מיועדים למקום הנכון ו- rc לצבע הנכון. לדוגמה, אם ניחוש שחקן הצבע 1 שווה לצ'ק 1 של RandNum, אז rs1 = 1 מכיוון שזה אומר שהצבע הנכון נמצא במקום הנכון. אם צבע 1 אינו שווה לבדיקה 1, אך הוא שווה לאחד מהבדיקות האחרות, אז rc = 1. זה נעשה עבור כל צבע וכל בדיקה.

מצב התצוגה (Dis) מחפש תחילה את המאפשר הספירה לאחור. אם זה '1', מספר קטן אחרון יורד 1 (כך שבפנייה הראשונה הוא עובר מ -9 ל -8 וכו '). אחרת התור לא משתנה. ללא קשר לאפשרות ההפעלה, כל ערכי rs מלמעלה מתווספים ומוקצים לאות RSpotCounter. כמו כן כל ערכי rc מתווספים ומוקצים ל- RColorCounter. לבסוף מוקצה לספירה לאחור הערך של הספירה לאחור. האותות RSpotCounter, RColorCounter ו- Countdown מומרים כולם ל- 4-bit std_logic_vectors מחוץ לתהליך, ונדחקים אל תת מודול התצוגה של שבעת הפלחים באמצעות מפת יציאה. בדרך זו, התצוגה מציגה את הדברים הנכונים עד שתשלח תשובה חדשה.

מצב CheckEnd מיועד אם ניצחת או הפסדת. אם זכית (כל 4 הצבעים נמצאים במקום הנכון, הידוע גם בשם RSpotCounter = 4), אז "GG" (מוצג מבחינה טכנית כ -66) מוצג בשבעת הקטעים כדי להראות שזכית. אם הפסדת (הספירה לאחור הגיעה ל -0) אז "GO" (מוצג טכנית כ -60) יוצג על המסך עבור Game Over. בכל אחת מהתוצאות, לחיצה על מתג האיפוס למצב מופעל תעביר את המכשיר חזרה למצב ההתחלתי כדי לשחק שוב.

קוד המקור ניתן למצוא כאן.

שלב 3: מסקנה

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