VHDL Basys3: Connect 4 თამაში: 5 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:18

შესავალი:

ეს არის Connect 4 ციფრული ლოგიკური თამაში, რომელიც შექმნილია VHDL– ში Vivado პროგრამული უზრუნველყოფის გამოყენებით და დაპროგრამებულია Basys3 დაფაზე. ამ პროექტის მშენებლობა და დიზაინი შუალედურია, მაგრამ ახალბედებს შეუძლიათ გადაწერონ ნაბიჯები და შექმნან ციფრული თამაში.

თამაში მუშაობს Connect 4 თამაშის მსგავსად. მოთამაშეებს შეუძლიათ თავიანთი კურსორის გადატანა ეკრანზე დაფაზე არსებული მარცხენა და მარჯვენა ღილაკების გამოყენებით. დაფაზე შუა ღილაკის დაჭერით მოთამაშემ უნდა დააყენოს მარკერი იმ სვეტზე და შემდეგ ის გახდება შემდეგი მოთამაშის ჯერი. როგორც კი მოთამაშე იმარჯვებს, თამაშის გადატვირთვა შესაძლებელია დაფის ზემოთ ღილაკის დაჭერით.

ნაბიჯი 1: სწრაფი დეტალები და მასალები

სწრაფი ტექნიკური დეტალები:

• იყენებს PMOD კავშირების სამ კომპლექტს დაფაზე (JA, JB, JC)

  • 8 ქინძისთავები (გამორიცხულია Vcc & GND ქინძისთავები) გამოიყენება თითოეული PMOD კონექტორისთვის
  • JA - რიგების კონტროლი
  • JB - მწვანე სვეტების კონტროლი
  • JC - წითელი სვეტების კონტროლი

• ეკრანის საათი მუშაობს 960 Hz

  მხოლოდ 8 LED არის ჩართული მოცემულ დროს. ეკრანი განახლდება იმდენად სწრაფი საათის სიჩქარით, რომ ილუზიას ეძლევა, რომ მოცემულ დროს 8 -ზე მეტი LED არის ჩართული

• ღილაკის საათი მუშაობს 5 ჰც -ზე; სურვილისამებრ შეიძლება დაჯარიმდეს VHDL კოდის რედაქტირებით.
• დარლინგტონის მასივების შიდა წინააღმდეგობა საკმარისია იმისათვის, რომ თავიდან აიცილოს LED- ის დაწვა

თამაში აგებულია შემდეგი კომპონენტების და ინსტრუმენტების გამოყენებით:

• (1) Basys3 დაფა
• (2) LED მატრიცა ბი-ფერი 8x5:
• (2) ULN2803 - დარლინგტონის ტრანზისტორი მასივები - მონაცემთა ცხრილი
• მავთულის კოჭები
• Jumper Wires
• მავთულის გამხსნელი
• პურის დაფები (დიდი მოედანი საკმარისი უნდა იყოს)
• მულტიმეტრი და ელექტრომომარაგება (პრობლემების მოგვარება)

ნაბიჯი 2: აპარატურის დაკავშირება

მითითებები:

პროექტის გაყვანილობა შეიძლება იყოს უკიდურესად ჩახლართული, გთხოვთ მიიღოთ დრო და შეამოწმოთ, რომ ყველა კავშირი სწორია ერთ ჯერზე.

პროექტი მოიცავს ორი LED ეკრანის გამოყენებას, მაგრამ გაერთიანებულია ერთი დიდი ეკრანის შესაქმნელად. ეს შეიძლება გაკეთდეს ყველა რიგის ერთ წერტილთან დაკავშირებით. იმის გამო, რომ თითოეული ეკრანი ორფერია, ერთი ეკრანის წითელი და მწვანე რიგები ასევე უნდა იყოს მიბმული მეორე ეკრანის წითელ და მწვანე რიგებზე. ამით ჩვენ შეგვიძლია გავაკონტროლოთ ყველა რიგი მხოლოდ 8 ქინძისთავით. დანარჩენი 16 ქინძისთავები გამოიყენება ეკრანის სვეტების გასაკონტროლებლად. 8 ქინძისთავის დასაკავშირებლად შესაძლებელია პირდაპირ jumper კაბელების საშუალებით pmod კონექტორებთან დაკავშირება. Pmod კავშირები პირველ რიგში მიდის ULN2083A– ს შესასვლელთან და ULN2083A გამომავალი პირდაპირ კავშირშია ეკრანზე არსებულ სვეტთან. რადგან დიზაინი არის 8x8, ზოგიერთი სვეტი ფიზიკურად არ იქნება დაკავშირებული.

• JA: რიგები
• JA: წითელი სვეტის კავშირები:
• JC: მწვანე სვეტის კავშირები

გთხოვთ, მიმართოთ გამოქვეყნებულ სურათებს, რათა იცოდეთ რომელი ქინძისთავები რომელ სტრიქონებს/სვეტებს შეესაბამება.

შენიშვნა: ტრანზისტორებს აქვთ ჩამონტაჟებული წინააღმდეგობები, ამიტომ LED- ები არ საჭიროებს დამატებით წინააღმდეგობას სერიულად მათთან დასაკავშირებლად.

ნაბიჯი 3: ტექნიკური ახსნა: ეკრანი

ეკრანი მუშაობს მხედველობის გამძლეობაზე. ეკრანი იმდენად სწრაფად განახლდება, რომ ადამიანის თვალი ვერ ხვდება, რომ ზოგიერთი LED სწრაფად ითიშება და ირთვება. სინამდვილეში, ჩვენების საათის შენელებით შეიძლება შეამჩნიოთ მოციმციმე.

ეკრანი რვა რიგით რიგდება ამ სტრიქონებისთვის შენახული მონაცემების მიხედვით და ეკრანი ერთ სვეტზე გადადის. შემდეგ ის სწრაფად გადადის მონაცემების შემდგომ ჩანაწერში რვა რიგისთვის და გადადის შემდეგ სვეტზე - ყველა სხვა სვეტის გამორთვისას. ეს პროცესი გრძელდება საკმაოდ სწრაფი საათის სიჩქარით, რომ LED- ის ციმციმა შეუმჩნეველი ხდება.

ჩვენების მონაცემების შენახვა ინიციალიზებულია VHDL ფაილში არქიტექტურისთანავე შემდეგნაირად:

სიგნალი RedA, RedB, RedC, RedD, RedE, RedF, RedG, RedH: std_logic_vector (7 ქვემოთ 0): = "00000000";

სიგნალი GreenA, GreenB, GreenC, GreenD, GreenE, GreenF, GreenG, GreenH: std_logic_vector (7 ქვემოთ 0): = "00000000"; - სვეტის მონაცემები დამოკიდებულია სვეტზე: მწვანე

ქვემოთ მოცემულია პროცესის მცირე მონაკვეთი, რომელიც აკონტროლებს LED ჩვენების მატრიცას.

- პროცესი, რომელიც აკონტროლებს LED ჩვენების მატრიცას ჩვენება: პროცესი (ColCLK) - 0 - 16, რათა განაახლოთ როგორც 8X8 RED, ასევე 8x8 GREEn მატრიცის ცვლადი RowCount: მთელი დიაპაზონი 0 -დან 16 -მდე: = 0; დაიწყება თუ (მზარდი_ ზღვარი (ColCLK)) შემდეგ თუ (RowCount = 0) შემდეგ DORow <= RedA; - რიგის მონაცემები შესაბამისი სვეტის DOCol <= "1000000000000000"; - სვეტის გამომწვევი- გაიმეორეთ ეს კოდი ბოლომდე "0000000000000001"- შეცვალეთ RedB, RedC… GreenA, GreenB… GreenH

GreenH- ის დასასრულს, პროცესის დასრულებამდე, ეს ფრაგმენტი შედის RowCount– ის ნულამდე დასაბრუნებლად.

თუ (RowCount = 15) მაშინ - გადატვირთეთ განახლება სვეტიდან RowCount: = 0; სხვაგან RowCount: = RowCount + 1; - გადაიტანეთ სვეტების ბოლომდე, თუ;

ახლა, აგიხსნათ საათი, რომელიც არის ჩვენების პროცესის მგრძნობელობის სიაში. Basys3 დაფაზე არის შიდა საათი, რომელიც მუშაობს 100 MHz. ჩვენი მიზნებისათვის, ეს არის ძალიან სწრაფი საათი, ასე რომ ჩვენ დაგვჭირდება ამ საათის გაყოფა 960Hz საათის შემდეგ პროცესის გამოყენებით.

- საათის პროცესი, რომელიც მუშაობს 960HzCLKDivider: პროცესი (CLK) ცვლადი clkcount: მთელი დიაპაზონი 0-დან 52083-მდე: = 0; დაიწყება თუ (მზარდი_ ზღვარი (CLK)) შემდეგ clkcount: = clkcount + 1; თუ (clkcount = 52083) მაშინ ColCLK <= არა (ColCLK); clkcount: = 0; დაასრულე თუ; დაასრულე თუ; პროცესის დასრულება;

ნაბიჯი 4: ტექნიკური ახსნა: ნაჩვენები ინფორმაციის შეცვლა

VHDL კოდში, ინფორმაცია ან მონაცემები, რომლებიც ეკრანზე გამოჩნდება, კონტროლდება კურსორის პროცესით, რომელსაც აქვს მგრძნობელობის სიაში განსხვავებული საათი. ამ კოდს ეწოდა BtnCLK, საათი, რომელიც შექმნილია ღილაკების დაჭერისას მინიმუმამდე შემცირების მიზნით. ეს შედის ისე, რომ ღილაკზე დაჭერის შემთხვევაში, კურსორის ზედა სტრიქონი არ მოძრაობს ძალიან სწრაფად სვეტებზე.

- საათის პროცესი, რომელიც მუშაობს 5 ჰერცზე. ღილაკი CLK: პროცესი (CLK) ცვლადი btnclkcount: მთელი დიაპაზონი 0-დან 10000001: = 0; დაიწყება თუ (აღმავალი_ ზღვარი (CLK)) შემდეგ თუ (btnclkcount = 10000000) შემდეგ btnclkcount: = 0; BtnCLK <= არა (BtnCLK); სხვაგან btnclkcount: = btnclkcount + 1; დაასრულე თუ; დაასრულე თუ; პროცესის დასრულება;

ამ პროცესის BtnCLK სიგნალის გამომუშავებით, ჩვენ ახლა შეგვიძლია ავუხსნათ კურსორის პროცესი. კურსორის პროცესს აქვს მხოლოდ BtnCLK მგრძნობელობის სიაში, მაგრამ კოდის ბლოკში, ღილაკების მდგომარეობა შემოწმებულია და ეს გამოიწვევს მონაცემების შეცვლას RedA, RedB… GreenH. აქ არის კურსორის კოდის ნაწყვეტი, რომელიც მოიცავს გადატვირთვის ბლოკს და ბლოკს პირველი სვეტისთვის.

კურსორი: პროცესი (BtnCLK) ცვლადი OCursorCol: STD_LOGIC_VECTOR (2 ქვემოთ 0): = "000"; - OCursorCol თვალყურს ადევნებს წინა სვეტის ცვლადს NCursorCol: STD_LOGIC_VECTOR (2 ქვემოთ 0): = "000"; -NCursorCol ადგენს კურსორის ახალ სვეტს-ხელახლა დაყენება (UP ღილაკი) RedB <= "00000000"; RedC <= "00000000"; RedD <= "00000000"; წითელი <= "00000000"; RedF <= "00000000"; RedG <= "00000000"; RedH <= "00000000"; მწვანე A <= "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 <= არა (TurnState); - იწვევს მომდევნო მოთამაშის რიგს- ამოწმებს მიმდინარე სვეტს ქვემოდან ზემოდან და ჩართავს პირველ LED- ს, რომელიც არ არის ჩართული. ფერი დამოკიდებულია მიმდინარე მოთამაშის კურსორის ფერიზე. ck for 7 downto 1 loop if (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'; თუ (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) - მწვანე მოთამაშე RedA (0) <= '0'; if (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 პროგრამის გამოყენებით.

ასევე არსებობს შეზღუდვა, რომელიც საშუალებას მოგცემთ დაიწყოთ თამაში.

ჩვენ მოგვაწოდეთ ბლოკ -დიაგრამა, რომელიც განმარტავს, თუ როგორ არის დაკავშირებული თითოეული პროცესის შეყვანა და გამოსავალი.