ქსელის მეტოქეობა: დაბალი ლატენტური თამაში BBC მიკროსადგურისთვის: ცოტა: 10 ნაბიჯი (სურათებით)

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

ამ გაკვეთილში მე აგიხსნით როგორ განვახორციელოთ ძირითადი მულტიპლიკატორული თამაში BBC მიკრო: ბიტი შემდეგი მახასიათებლებით:

• მარტივი ინტერფეისი
• დაბალი შეყოვნება ღილაკების დაჭერასა და ეკრანის განახლებებს შორის
• მონაწილეთა მოქნილი რაოდენობა
• მარტივი კონტროლი თამაშზე სამაგისტრო დისტანციური ("root") მოწყობილობის გამოყენებით

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

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

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

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

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

ზემოთ დიაგრამა განსაზღვრავს შემდეგ მდგომარეობებს:

• დაუნიშნავი
• მოუსმინეთ ა
• მოუსმინეთ ბ
• გუნდი ა
• გუნდი B

თამაშის კოდის გაშვებული მოწყობილობა შეიძლება იყოს ამ ხუთიდან რომელიმეში, მაგრამ მხოლოდ ერთ დროს და მხოლოდ ამ ხუთში.

მთელი მეგზური ვივარაუდებ, რომ თქვენ იყენებთ Microsoft– ის MakeCode რედაქტორს, რომელიც შეგიძლიათ იხილოთ აქ:

თამაშის სრული განხორციელება შეგიძლიათ იხილოთ აქ:

makecode.microbit.org/_CvRMtheLbRR3 ("მიკრობიტ-დემო-მომხმარებელი" არის პროექტის სახელი)

და სამაგისტრო ("root") ქსელის კონტროლერის განხორციელება შეგიძლიათ იხილოთ აქ:

makecode.microbit.org/_1kKE6TRc9TgE ("microbit-demo-root" არის პროექტის სახელი)

მე მივმართავ ამ მაგალითებს მთელი ჩემი გაკვეთილის განმავლობაში.

ნაბიჯი 1: დიდი სურათის დიზაინის გათვალისწინება

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

1. ჩვენ გვინდა გავაკონტროლოთ მოწყობილობის მოქმედებები მისი ამჟამინდელი მდგომარეობიდან გამომდინარე
2. ჩვენ გვინდა, რომ მოწყობილობა რეაგირებდეს მომხმარებლის შეყვანაზე
3. ჩვენ შეიძლება გვსურს ანიმაციის და გრაფიკის ჩვენება 5 x 5 LED ეკრანის გამოყენებით
4. ჩვენ გვინდა მონაცემების მნიშვნელობების ინიციალიზაცია მოწყობილობების მეხსიერებაში, როდესაც მოწყობილობა ჩატვირთვისას
5. ჩვენ გვინდა მონაცემების უკაბელო გადაცემა მოწყობილობის რადიოს გამოყენებით
6. ჩვენ გვსურს მოვისმინოთ და მივიღოთ მონაცემები მოწყობილობის რადიოთი და შესაბამისად დავამუშაოთ იგი

ნება მომეცით ცოტა უფრო დეტალურად განვიხილო თითოეული მათგანი.

1. ჩვენ გვინდა გავაკონტროლოთ მოწყობილობის მოქმედებები მისი ამჟამინდელი მდგომარეობიდან გამომდინარე

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

2. ჩვენ გვინდა, რომ მოწყობილობა რეაგირებდეს მომხმარებლის შეყვანაზე

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

3. ჩვენ გვსურს ანიმაციის და გრაფიკის ჩვენება 5 x 5 LED ეკრანის გამოყენებით

ამის მექანიზმი, როგორც ჩანს, მარტივია, მაგრამ სურათის ჩვენების ბლოკი ამატებს ფარული შეფერხებას 400 ms. იმის გამო, რომ ჩვენ გვინდა, რომ ჩვენმა მოწყობილობამ გააგრძელოს თავისი მდგომარეობის მარყუჟის შესრულება რაც შეიძლება მცირე დაგვიანებით, ჩვენ დაგვჭირდება javascript კოდის რედაქტირება, რომ შეფერხება მინიმუმამდე დავიყვანოთ.

4. ჩვენ გვსურს მონაცემების ინიციალიზაცია მოწყობილობების მეხსიერებაში, როდესაც მოწყობილობა ჩატვირთვისას

სანამ ჩვენი მოწყობილობა რამეს გააკეთებს, პროგრამას სჭირდება მონაცემების მეხსიერებაში ჩატვირთვა. ეს მოიცავს მუდმივ ცვლადებს, რომლებიც დასახელებულია კოდის წაკითხვისთვის, ცვლადები, რომლებიც შეიცავს სურათებს, რომლებიც შეიძლება იყოს ანიმაციის ნაწილი და მრიცხველ ცვლადებს, რომლებიც უნდა მუშაობდნენ 0 -დან, რომ სწორად იმუშაონ. ჩვენ დავასრულებთ ცვლადი სახელების და მათ ახლად მინიჭებული მნიშვნელობების დიდ ჩამონათვალს. როგორც პირადი სტილის არჩევანი, მე აღვნიშნავ მუდმივ მნიშვნელობებს, ანუ ღირებულებებს, რომელთა შეცვლა არასდროს დამჭირდება, ALL_CAPS- ის გამოყენებით. მე ასევე დავამატებ ძირითად ცვლადის იდენტიფიკატორებს კატეგორიის სახელით, რომელიც ეხება ერთგვარ ობიექტს ან ტიპს, რომლის იდენტიფიკატორიც მოხვდება. ეს არის მცდელობა გაუადვილოს კოდის დაცვა. მე არასოდეს გამოვიყენებ ცვლადის სახელს, როგორიცაა "ელემენტი" ან "x" იმ გაურკვევლობის გამო, რომელიც წარმოიქმნება კოდის გაშიფვრის მცდელობისას.

5. ჩვენ გვინდა მონაცემების უკაბელო გადაცემა მოწყობილობის რადიოს გამოყენებით

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

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

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

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

1. ჩვენ გვინდა, რომ შეგვეძლოს სიგნალის არჩევა
2. ჩვენ გვინდა, რომ შეგვეძლოს სიგნალის გადაცემა

-

1. ჩვენ გვსურს შეგვეძლოს სიგნალის შერჩევა

ეს შეიძლება გაკეთდეს მხოლოდ ღილაკის გამეორებით შესაძლო სიგნალების საშუალებით. ვინაიდან მხოლოდ სამია, ეს მიდგომა საკმარისი იქნება. ამავე დროს, ჩვენ შეგვიძლია გვქონდეს მარყუჟი, რომელიც მუდმივად ხელახლა აჩვენებს არჩეულ სიგნალს, რაც მომხმარებელს საშუალებას აძლევს დააჭიროს ღილაკს და დაინახოს, რომ შერჩეული სიგნალი გამოჩნდება LED ეკრანზე ძალიან მცირე დაგვიანებით.

2. ჩვენ გვინდა, რომ შეგვეძლოს სიგნალის გადაცემა

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

მე უფრო მეტს ვისაუბრებ სიგნალის უბრალო პროტოკოლზე მომდევნო ნაწილში.

ნაბიჯი 2: სიგნალის პროტოკოლი: მარტივი ენა ქსელური კომუნიკაციისთვის

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

0. გადატვირთვა

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

1. კონვერსია A

• იდენტიფიკატორი კოდში: SIG-A
• მთელი რიცხვის მნიშვნელობა: 1
• მიზანი: უთხარით ნებისმიერ მოწყობილობას, რომელიც არის LISTEN_A მდგომარეობაში, კონვერტაციის სიგნალის მიღებისთანავე, გადავიდეს მდგომარეობაზე TEAM_A.

2. კონვერსია ბ

1. იდენტიფიკატორი კოდში: SIG-B
2. მთელი რიცხვის მნიშვნელობა: 2
3. მიზანი: უთხარით ნებისმიერ მოწყობილობას, რომელიც იმყოფება LISTEN_B მდგომარეობაში, კონვერტაციის სიგნალის მიღების შემდეგ, გადავიდეს მდგომარეობაზე TEAM_B.

ნაბიჯი 3: ჩვენ გვინდა გავაკონტროლოთ მოწყობილობის მოქმედებები მისი ამჟამინდელი მდგომარეობიდან გამომდინარე

დაბოლოს, ჩვენ შეგვიძლია დავიწყოთ კოდის წერა.

პირველი, გახსენით ახალი პროექტი Make Code- ში

• შექმენით ახალი ფუნქცია. მე დავურეკე ჩემს მარყუჟს, რადგან ეს არის პროგრამის ძირითადი მარყუჟი
• დაამატეთ მარყუჟის ბლოკი, რომელიც განმეორებით განმეორდება. მე ვიყენებ სანამ (ჭეშმარიტი), რადგან სიტყვასიტყვითი ჭეშმარიტი არასოდეს იქნება ყალბი, ამიტომ პროგრამის საკონტროლო ნაკადი არასოდეს გამოვა მარყუჟიდან
• დაამატეთ იმდენი ბლოკი, რომ შეამოწმოთ არის თუ არა მოწყობილობა მისი ხუთი შესაძლო მდგომარეობიდან
• შექმენით ცვლადი მოწყობილობის მიმდინარე მდგომარეობის შესანარჩუნებლად

• შექმენით ცვლადები, რომ წარმოადგინონ ხუთი შესაძლო მდგომარეობიდან თითოეული

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

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

შენიშვნა: არ ინერვიულოთ ნაცრისფერი ბლოკების შესახებ მესამე სურათზე. მე მოგვიანებით მივალ მათთან.

ნაბიჯი 4: ჩვენ გვინდა რეაგირება მოახდინოთ მომხმარებლის შეყვანაზე

ახლა, ჩვენ გვინდა ვუთხრათ მოწყობილობას, თუ როგორ უნდა გაუმკლავდეს ღილაკების დაჭერებს. ერთი პირველი აზრი შეიძლება იყოს უბრალოდ შეყვანის კატეგორიაში ბლოკების "როდესაც ღილაკზე დაჭერილია" გამოყენება, მაგრამ ჩვენ გვსურს ამაზე უფრო გრანულირებული კონტროლი. ჩვენ გამოვიყენებთ "on event from (X) with value (Y)" ბლოკი საკონტროლო კატეგორიიდან მოწინავე განყოფილების ქვეშ, რადგან ჩვენ წინ ვართ ამ სახელმძღვანელოში.

• შექმენით ოთხი ბლოკი "ღონისძიებიდან…"

  • აქედან ორმა უნდა შეამოწმოს ღონისძიების წყარო "MICROBIT_ID_BUTTON_A"
  • აქედან ორმა უნდა შეამოწმოს ღონისძიების წყარო "MICROBIT_ID_BUTTON_B"

  • ორი მოვლენიდან, რომელიც მიზნად ისახავს თითოეულ ღილაკს:

    • თქვენ უნდა შეამოწმოთ მოვლენის ტიპი "MICROBIT_BUTTON_EVT_UP"
    • თქვენ უნდა შეამოწმოთ მოვლენის ტიპი "MICROBIT_BUTTON_EVT_DOWN"
  • შენიშვნა: ეს პარამეტრები ყველა დიდი ასოებით არის ეტიკეტები, რომლებიც გამოიყენება ქვედა დონის მიკრო: ბიტის კოდში. ისინი უბრალოდ ადგილის შემცვლელები არიან, რომლებიც შემდგომ შეიცვალა მთელი რიცხვებით, როდესაც კოდი შედგენილია შესრულებად ორობაში. ადამიანებისთვის უფრო ადვილია ამ ეტიკეტების გამოყენება, ვიდრე მოიძიონ რომელი რიცხვი ჩადონ, თუმცა ორივე ერთნაირად იმუშავებს.

• მე ავირჩიე, როგორც სტილის საკითხი, რომ თითოეული „ღონისძიებიდან…“დაბლოკოს ფუნქცია, რომელიც აღწერს ამაღლებულ მოვლენას. მიუხედავად იმისა, რომ არ არის მკაცრად აუცილებელი, ჩემი აზრით, ეს აუმჯობესებს წაკითხვას. თუ ვინმეს სურს ამის გაკეთება, მათ შეუძლიათ განათავსონ თავიანთი ღონისძიების დამუშავების კოდი "ჩართული ღონისძიებიდან…" ბლოკში.

  შენიშვნა: კოდის ბლოკს, რომელიც ახორციელებს მოწყობილობის რეაქციას მოვლენაზე, ინტუიციურად ეწოდება "ღონისძიების დამმუშავებელი"

• დაამატეთ თითოეულ მოვლენის დამმუშავებელს იგივე სტრუქტურა, რომელიც გამოიყენება კონტროლის ნაკადის გასაყოფად მოწყობილობის მდგომარეობიდან გამომდინარე, როგორც სტრუქტურა მთავარ მდგომარეობის მარყუჟში.

• დაამატეთ დავალების ბლოკები, რომლებიც ცვლის მოწყობილობის მდგომარეობას, როგორც ეს მითითებულია ჩვენი სახელმწიფო დიაგრამაში

  • ჩვენ ვიცით, რომ როდესაც მოწყობილობა მდგომარეობს UNASSIGNED– ში, მოწყობილობა უნდა რეაგირებდეს ღილაკზე A, რომელიც დაჭერილია LISTEN_A მდგომარეობაზე გადასვლით და B ღილაკზე დაჭერილია LISTEN_B მდგომარეობაზე გადასვლით
  • ჩვენ ასევე ვიცით, რომ როდესაც მოწყობილობა მდგომარეობს LISTEN_A ან LISTEN_B მდგომარეობაში, მოწყობილობა უნდა რეაგირებდეს გამოშვებულ ღილაკზე A და გამოთავისუფლებულ ღილაკზე, შესაბამისად, უკანა მდგომარეობაზე გადასვლისას UNASSIGNED.

  • დაბოლოს, ჩვენ ვიცით, რომ როდესაც მოწყობილობა TEAM_A ან TEAM_B მდგომარეობაშია, მოწყობილობა უნდა რეაგირებდეს ღილაკზე A დაჭერით და B ღილაკზე დაჭერით SIG_A და SIG_B მაუწყებლობით შესაბამისად.

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

ნაბიჯი 5: ჩვენ გვსურს დავიწყოთ მონაცემების ღირებულებების ინიციალიზაცია მოწყობილობების მეხსიერებაში, როდესაც მოწყობილობა ჩატვირთვისას

ამ ეტაპზე, ჩვენ გამოვიყენეთ ბევრი ცვლადი (მონაცემების სახელები), მაგრამ ჩვენ რეალურად არ მივანიჭეთ მნიშვნელობები ამ სახელებს. ჩვენ გვინდა, რომ მოწყობილობამ ჩატვირთვისას ჩამტვირთოს ყველა ამ ცვლადის მნიშვნელობა, ამიტომ ამ ცვლადების ინიციალიზაციას ვათავსებთ "დაწყების" ბლოკში.

ეს არის ღირებულებები, რომლებიც უნდა დავიწყოთ:

• სიგნალის მუდმივები, სიგნალის პროტოკოლის მიხედვით. ღირებულებები უნდა იყოს:

  • SIG_R = 0
  • SIG_A = 1
  • SIG_B = 2
  • შენიშვნა: მე ეს კონსტანტები შევიტანე "EnumSignals" - ით, რათა აღვნიშნო, რომ ეს ცვლადები უნდა მოიქცნენ ისე, თითქოს ისინი იყვნენ აღრიცხული ტიპის ნაწილი, სახელწოდებით Signals. ეს არის ის, თუ როგორ შეიძლება განხორციელდეს ეს ცვლადები სხვა პროგრამირების ენებზე. ჩამოთვლილი ტიპების განსაზღვრა და ახსნა სცილდება ჩემი გაკვეთილის ფარგლებს. სურვილისამებრ შეიძლება ვინმემ Google მოიძიოს. ეს პრეფიქსი უბრალოდ სტილისტური არჩევანია და სულაც არ არის აუცილებელი პროგრამის სათანადო ფუნქციონირებისათვის.

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

  • დაუნიშნავი = 0
  • LISTEN_A = 1
  • LISTEN_B = 2
  • TEAM_A = 3
  • TEAM_B = 4
  • შენიშვნა: მე მივიღე იგივე სტილის გადაწყვეტილება ამ ცვლადების პრეფიქსებთან დაკავშირებითაც. გარდა ამისა, მე აღვნიშნავ, რომ ყველაფერი ამ დავალებების, ღირებულებებისა და წესრიგის შესახებ არის სრულიად თვითნებური. არც კი აქვს მნიშვნელობა, რომ ეს მნიშვნელობები შეესაბამება მოწყობილობას მოწყობილობას, რადგან ისინი გამოიყენება მხოლოდ შინაგანად და არა ქსელში კომუნიკაციისთვის. მნიშვნელოვანია მხოლოდ ის, რომ ცვლადებს აქვთ მნიშვნელობა და რომ ისინი შეიძლება შევადაროთ ერთმანეთს რომ ნახოთ ისინი ექვივალენტია თუ არა.
• წაკითხვის მიზნით, მუდმივმა დაარქვა BOOT_STATE და დააყენა UNASSIGNED. ეს ხდის იმ ფაქტს, რომ ჩვენ გადატვირთავთ ჩატვირთვის მდგომარეობას, უფრო თვითნებური მდგომარეობის ნაცვლად, უფრო ნათელს ხდის, როდესაც მოწყობილობა მიიღებს გადატვირთვის სიგნალს, რომელსაც ჩვენ მოგვიანებით განვახორციელებთ.

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

  • TICKS_PER_FRAME_LOADING_ANIMATION = 50
  • MS_PER_DEVICE_TICK = 10
  • MS_PER_FRAME_BROADCAST_ANIMATION = 500
  • MICROSECONDS_PER_MILLISECOND = 1000
  • NUMBER_OF_FRAMES_IN_LOADING_ANIMATION = 4

• ანიმაციის კიდევ ერთი ცვლადი, ამჯერად მრიცხველი, რომელიც ნამდვილად არ არის მუდმივი. მრიცხველების უმეტესობის მსგავსად, ჩვენ მას ინიციალიზაციას ვაძლევთ 0 -ზე

  iTickLoadingAnimation = 0

• შექმენით ცვლადების ორი სერია ანიმაციების ჩარჩოების შესანახად. პირველს, რომელსაც მე ვუწოდებ "ჩატვირთვის ანიმაციას", უნდა ჰქონდეს ოთხი სურათი (რაც თქვენ ალბათ მიხვდით ბოლო მუდმივი ინიციალიზაციით) და მეორეს, რომელსაც მე ვუწოდებ "მაუწყებლობის ანიმაციას", რომელსაც უნდა ჰქონდეს სამი სურათი. მე გირჩევთ ცვლადების დასახელება ანიმაციის ჩარჩოებს, მაგ. ბეჭედი ანიმაცია 0, ბეჭედი ანიმაცია 1…

  შექმენით იგივე გამოსახულების მნიშვნელობები, როგორც მე, ან შექმენით უფრო ორიგინალური და მაგარი სურათები

• ბოლო, მაგრამ არანაკლებ მნიშვნელოვანი, ჩვენ უნდა დავაყენოთ მოწყობილობის რადიო ჯგუფი 0 -ზე "რადიო ნაკრების ჯგუფის (X)" ბლოკის გამოყენებით
• სურვილისამებრ, ჩაწერეთ შეტყობინება "ინიციალიზაცია დასრულებულია" სერიულ გამოშვებაზე, რათა უთხრათ მომხმარებელს, რომ ყველაფერი მწყობრში წავიდა.
• ახლა, როდესაც ჩვენ დავასრულეთ მოწყობილობის დაყენება, ჩვენ შეგვიძლია მოვუწოდოთ ჩვენი სახელმწიფოს მარყუჟის ფუნქციას.

ნაბიჯი 6: ჩვენ გვსურს ანიმაციისა და გრაფიკის ჩვენება 5 X 5 LED ეკრანის გამოყენებით

და ახლა რაღაც სრულიად განსხვავებული.

ჩვენ გვსურს რამდენიმე ანიმაციის ჩვენება და რამდენიმე პერსონაჟი, მაგრამ ჩვენ არ გვინდა შევაჩეროთ მთავარი მდგომარეობის მარყუჟი. სამწუხაროდ, ბლოკებს, რომლებიც აჩვენებენ სურათებს და ტექსტურ სტრიქონებს, აქვთ 400 ms შეფერხება. არ არსებობს ამის შეცვლის საშუალება javascript კოდის წარმოდგენის რედაქტირების გარეშე. ასე რომ, ეს არის ის, რასაც ჩვენ გავაკეთებთ.

• შექმენით ფუნქცია თითოეული სურათისთვის. ეს საშუალებას მისცემს გამოიყენოს ერთი ბლოკი გამოსახულების ჩვენების ნაცვლად, ყოველ ჯერზე javascript– ის რედაქტირების ნაცვლად. ამ კონკრეტულ პროგრამაში არცერთი სურათი არ გამოიყენება ერთზე მეტჯერ, მაგრამ მე მაინც ვფიქრობ, რომ ეს სტილი კოდს უფრო ადვილად იკითხავს.
• დაამატეთ, ყოველ ახალ ფუნქციაში, "გამოსახულების ჩვენება (X) ოფსეტში 0" ბლოკი შესაბამისი სურათის ცვლადის სახელის შეცვლით (X)

• დაამატეთ, მთავარ მდგომარეობის მარყუჟში. "აჩვენეთ სტრიქონი (X)" ბლოკები თითოეულ ბლოკზე გარდა იმ ბლოკისა, რომელიც ამუშავებს მდგომარეობას UNASSIGNED. დაამატეთ სიმბოლოს მოწყობილობის ჩვენება, რომ მიუთითოს მისი განსხვავებული მდგომარეობა. აი რა გავაკეთე:

  • LISTEN_A: 'a'
  • LISTEN_B: 'ბ'
  • TEAM_A: 'A'

  • TEAM_B: 'B'

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

• გადაერთეთ javascript რეჟიმში.
• იპოვეთ ყველა ზარი X.showImage (0) და basic.showString (X)

• შეცვალეთ თითოეული ან X.showImage (0, 0) ან basic.showString (X, 0)

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

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

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

• დაამატეთ "დაველოდოთ (ჩვენ) (X)" ბლოკს თითოეული ზარის შემდეგ გამოსახულების ჩვენების ფუნქციაზე.

  შენიშვნა: ეს ბლოკი, მოწინავე კონტროლის განყოფილებიდან, კიდევ უფრო შორს მიდის ვიდრე „პაუზა (ms)“, რადგან ის მთლიანად გაყინავს პროცესორს განსაზღვრული დროის გასვლამდე. როდესაც პაუზის ბლოკი გამოიყენება, შესაძლებელია, რომ მოწყობილობა შეასრულოს სხვა ამოცანები კულისებში. ეს შეუძლებელია ლოდინის ბლოკით

• შეცვალეთ (X) (MS_PER_FRAME_BROADCAST_ANIMATION x MICROSECONDS_PER_MILLISECOND)
• ანიმაცია ახლა სწორად უნდა მუშაობდეს

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

• შექმენით ფუნქცია, რომელიც განაახლებს ჩატვირთვის ანიმაციას

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

  თუ პირობა მართალია, გადატვირთეთ iTickLoadingAnimation 0 -ზე

• დაამატეთ თუ სხვა პირობების ბლოკი. ეს განსაზღვრავს ანიმაციის რომელი ჩარჩოს ჩვენებას.

  ანიმაციის თითოეული ჩარჩოსთვის, თუ ტკიპის მრიცხველი ნაკლებია თითოეულ ანიმაციაში ტკიპების რაოდენობაზე გამრავლებული ანიმაციის ჩარჩოს ნომერზე (დაწყებული 1 – დან), შემდეგ აჩვენეთ ეს ჩარჩო, წინააღმდეგ შემთხვევაში შეამოწმეთ არის თუ არა შემდეგი ჩარჩო იყოს ნაჩვენები

• ბლოკის ბოლოში, გაზარდეთ iTickLoadingAnimation
• ანიმაცია ახლა სწორად უნდა მუშაობდეს

შენიშვნა: ყველა ნაცრისფერი ბლოკი, რომელიც ჩემს მაგალითში ჩანს, გენერირდება, როდესაც ერთი ბლოკის javascript წარმოდგენას რედაქტირებს. ეს უბრალოდ ნიშნავს იმას, რომ ბლოკი წარმოადგენს javascript კოდს, რომელიც არ შეიძლება იყოს წარმოდგენილი სტანდარტული ბლოკების გამოყენებით და უნდა იყოს რედაქტირებული ტექსტური ფორმით.

ნაბიჯი 7: ჩვენ გვინდა მონაცემების უკაბელო გადაცემა მოწყობილობის რადიოს გამოყენებით

ეს ნაბიჯი ბევრად უფრო მოკლეა ვიდრე წინა. სინამდვილეში, ეს ალბათ ყველაზე მოკლე ნაბიჯია ამ გაკვეთილზე.

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

• ღილაკზე A დაჭერით:

  • თუ მოწყობილობა მდგომარეობს TEAM_A- ის მდგომარეობაში:

    მაუწყებლობის სიგნალი SIG_A

• B ღილაკზე დაჭერით:

  • თუ მოწყობილობა TEAM_B მდგომარეობაშია

    მაუწყებლობის სიგნალი SIG_B

შექმენით ეს ფუნქციები, თუ ისინი უკვე არ არსებობენ.

თითოეულ ფუნქციაში:

• დარეკეთ მაუწყებლობის ანიმაციის ფუნქცია. ეს დაბლოკავს სხვა ყველაფერს, სანამ არ დასრულდება, რაც იქნება MS_PER_FRAME_BROADCAST_ANIMATION * 3 = 1.5 წამში. მუდმივი გამრავლებულია სამზე, რადგან ანიმაციაში არის სამი ჩარჩო. ეს არის თვითნებური და მეტი შეიძლება დაემატოს, თუ ესთეტიკური განახლება საკმარისად დიდია. ამ ანიმაციის მეორე მიზანია ხელი შეუშალოს მომხმარებელს სპამისგან სამაუწყებლო ფუნქციისგან.
• დაამატეთ "რადიო გაგზავნის ნომერი (X)" ბლოკი, სადაც არის სიგნალის მუდმივი ნახსენები ფუნქციის სახელში

ეს არის ყველაფერი რაც საჭიროა რადიოთი მაუწყებლობისთვის.

ნაბიჯი 8: ჩვენ გვსურს მოვისმინოთ და მივიღოთ მონაცემები მოწყობილობის რადიოთი და შესაბამისად დავამუშაოთ იგი

ეს არის ბოლო ნაბიჯი ძირითადი პროგრამის შესაქმნელად.

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

Პირველი:

1. შექმენით კოდის ბლოკი, რომელიც იწყება "მიღებული რადიოში (X)" ბლოკით.
2. სურვილისამებრ, მიანიჭეთ მიღებული მნიშვნელობა სხვა ცვლადს უფრო აღწერითი სახელით.
3. დარეკეთ ფუნქცია, რომელიც დაამუშავებს სიგნალს

მეორე, სიგნალის დამუშავების ფუნქციაში:

1. შექმენით თუ სხვა განცხადებების ბლოკი, რომელიც ფილიალს აკონტროლებს დინებას სიგნალის მნიშვნელობიდან გამომდინარე.

2. თუ სიგნალი იყო SIG_R

   დააყენეთ მოწყობილობის მდგომარეობა BOOT_STATE (ამიტომაც შევქმენით ეს მუდმივი ადრე)

3. თუ სიგნალი იყო SIG_A და თუ ამჟამინდელი მდგომარეობა არის LISTEN_A

   დააყენეთ მოწყობილობის მდგომარეობა TEAM_A

4. თუ სიგნალი იყო SIG_B და თუ ამჟამინდელი მდგომარეობა არის LISTEN_B

   დააყენეთ მოწყობილობის მდგომარეობა TEAM_B

Ის არის. განაცხადი დასრულებულია.

ნაბიჯი 9: ძირეული მოწყობილობა: ჩვენ გვსურს შეგვეძლოს სიგნალის არჩევა

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

ამ მოწყობილობას უნდა შეასრულოს ორი ფუნქცია:

• ჩვენ გვსურს მომხმარებელს მივცეთ საშუალება აირჩიოს ჩვენი სიგნალებიდან ერთი
• ჩვენ გვსურს მომხმარებელს მივცეთ სიგნალის გადაცემის უფლება

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

იმისათვის, რომ მომხმარებელს შეეძლოს აირჩიოს სიგნალი:

1. 5 ცვლადის ინიციალიზაცია "დაწყების" ბლოკში:

   1. სამი სიგნალი (0, 1, 2)
   2. სიგნალების რაოდენობა (3)
   3. ცვლადი, რომელიც ახორციელებს ამჟამად არჩეულ სიგნალს (თავდაპირველად დაყენებულია პირველ სიგნალზე, 0)

2. გაუმკლავდეს A ღილაკს:

   1. გაზარდეთ არჩეული სიგნალი

   2. შეამოწმეთ არის თუ არა არჩეული სიგნალი სიგნალების რაოდენობაზე მეტი ან ტოლი

      თუ ასეა, დააყენეთ არჩეული სიგნალი 0 -ზე

3. დაწყების ბლოკის შემდეგ გაუშვით "სამუდამოდ" მარყუჟი, რომელიც აჩვენებს მიმდინარე შერჩეული სიგნალის მნიშვნელობას დაყოვნების გარეშე

რათა მომხმარებელს შეეძლოს სიგნალის გადაცემა

1. დააყენეთ რადიო ჯგუფი 0 -ზე "დაწყების" ბლოკში

2. გაუმკლავდეთ B ღილაკის დაჭერას:

   გაავრცელეთ არჩეული სიგნალი "რადიო გაგზავნის ნომრის (X)" ბლოკის გამოყენებით

Ის არის. ძირეული კვანძის პროგრამა ძალიან მარტივია.

ნაბიჯი 10: ჩვენ დავასრულეთ

ზემოთ არის აპლიკაციის გაშვებული მოწყობილობების სურათი. ორი მარჯვნივ მუშაობს მთავარი "მომხმარებლის" აპლიკაცია, ხოლო მარცხნივ ერთი "root" პროგრამას.

მე ვაჩვენე ეს თამაში CS Connections 2018– ში, ერთკვირიანი საზაფხულო კონფერენცია საშუალო და უმაღლესი სკოლის მასწავლებლებისთვის კომპიუტერული მეცნიერების განათლების შესახებ. მასწავლებლებს მივუტანე 40 -მდე მოწყობილობა და ავუხსენი წესები. უმეტესობა თამაშს გასართობად მიიჩნევდა და ბევრს გაუგებარია, სანამ არ გაერკვნენ, როგორ ეთამაშათ. დემონსტრაცია ხანმოკლე იყო, მაგრამ ჩვენ აღმოვაჩინეთ, რომ თამაში სასიამოვნო იყო საკმაოდ მრავალფეროვან ხალხში.

დამატებითი ინფორმაცია CS Connections 2018 -ის შესახებ შეგიძლიათ იხილოთ აქ.