Networkանցային մրցակցություն. Ցածր ուշացման խաղ BBC Micro- ի համար. Բիթ ՝ 10 քայլ (նկարներով)

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:48

Այս ձեռնարկում ես կբացատրեմ, թե ինչպես կարելի է իրականացնել հիմնական բազմաֆունկցիոնալ խաղ BBC- ի միկրո -բիթում հետևյալ հատկանիշներով.

• Պարզ ինտերֆեյս
• Buttonածր ուշացում կոճակների սեղմումների և էկրանի թարմացումների միջև
• Flexibleկուն թվով մասնակիցներ
• Հեշտ վերահսկողություն խաղի վրա `օգտագործելով հիմնական հեռակառավարման (« արմատ ») սարքը

Խաղն ըստ էության քաղաքականության մոդելավորում է: Բոլոր խաղացողները սկսում են չտրամադրված որևէ թիմի, բացառությամբ երկու խաղացողների: Այս խաղացողներից մեկը նշանակված է A թիմին, իսկ մյուսը `B թիմին:

Խաղի նպատակը յուրաքանչյուր խաղացողի համար թիմում լինել այն խաղացողների մեծամասնության հետ, երբ բոլորը դարձի են եկել:

Վերևի դիագրամը պատկերում է վերջավոր վիճակի մեքենա, այսինքն ՝ այն վիճակների հստակեցում, որոնցում կարող է լինել սարքը և այդ վիճակների միջև անցումները:

Պետությունը կարող է ընկալվել որպես տվյալների ներկա հավաքածու, որը նկարագրում է սարքի հիշողությունը այն միացնելուց ի վեր: Այդ տվյալների հիման վրա սարքը կարող է որոշակի գործողություններ կատարել կամ այլ կերպ արձագանքել օգտվողի մուտքին:

Անցումը տրամաբանական պայման է, որը, երբ ճշմարիտ է, սարքի վիճակի փոփոխման պատճառ է դառնում: Անցումը կարող է լինել մեկ վիճակից ցանկացած այլ վիճակի: Պետությունը կարող է ունենալ բազմաթիվ անցումներ:

Վերը նշված դիագրամը սահմանում է հետևյալ վիճակները.

• Չնշանակված
• Լսեք Ա
• Լսեք Բ
• Թիմ Ա
• Թիմ Բ

Խաղի կոդը աշխատող սարքը կարող է լինել այս հինգ վիճակներից որևէ մեկում, բայց միաժամանակ միայն մեկը, և միայն այս հինգը:

Ուղեցույցում ես ենթադրելու եմ, որ դուք օգտագործում եք Microsoft- ի MakeCode խմբագիրը, որը կարելի է գտնել հետևյալ հասցեով ՝

Խաղի ամբողջական իրականացմանը կարող եք ծանոթանալ այստեղ ՝

makecode.microbit.org/_CvRMtheLbRR3 («microbit-demo-user» նախագծի անունն է)

Իսկ հիմնական («արմատ») ցանցի վերահսկիչի ներդրումը կարելի է գտնել այստեղ.

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. Մենք ցանկանում ենք լսել և ստանալ տվյալներ սարքի ռադիոյով և համապատասխանաբար մշակել դրանք

Հաշվի առնելով նույն նկատառումները, ինչ նախորդ նյութը, մենք կլսենք մուտքային հաղորդումները այնպես, ինչպես կլսենք օգտվողի մուտքը `իրադարձությունների կառավարիչով: Մենք կգրենք կոդի բլոկ, որը կուսումնասիրի ցանկացած մուտքային ազդանշաններ և կստուգի, թե արդյոք որևէ գործողություն պետք է ձեռնարկվի առանց հիմնական վիճակի խախտման:

Բացի այդ, մենք պետք է հակիրճ դիտարկենք շատ ավելի պարզ արմատային ծրագրի դիզայնը, ծրագիր, որը թույլ կտա սարքին վերահսկել ամբողջ ցանցը: Ես շատ ժամանակ չեմ ծախսի դրա վրա, քանի որ այն շատ ավելի պարզ է, քան վերը նշված դիզայնը, և դրա մեծ մասն ուղղակի կրկնություն է: Ես արմատային դեզի ֆունկցիոնալությունը բաժանել եմ երեք կատեգորիայի:

1. Մենք ցանկանում ենք, որ կարողանանք ազդանշան ընտրել
2. Մենք ցանկանում ենք, որ կարողանանք ազդանշան փոխանցել

-

1. Մենք ցանկանում ենք, որ կարողանանք ազդանշան ընտրել

Դա կարելի է անել ՝ պարզապես կոճակը կրկնելով հնարավոր ազդանշանների միջոցով: Քանի որ դրանք ընդամենը երեքն են, այս մոտեցումը բավական կլինի: Միևնույն ժամանակ, մենք կարող ենք ունենալ մի հանգույց, որն անընդհատ նորից ցուցադրում է ընտրված ազդանշանը ՝ թույլ տալով օգտվողին սեղմել կոճակը և տեսնել, որ ընտրված ազդանշանը հայտնվում է LED էկրանին ՝ շատ փոքր ուշացումով:

2. Մենք ցանկանում ենք, որ կարողանանք ազդանշան փոխանցել

Քանի որ կան երկու կոճակներ, մենք կարող ենք նշանակել մեկը ընտրության, իսկ մյուսը ՝ հաստատման համար: Օգտվողի հավելվածի պես, մենք պարզապես ազդանշանը ուղարկում ենք ցանցով որպես թիվ: Այլ տեղեկություններ չեն պահանջվում:

Հաջորդ բաժնում ես ավելի շատ կխոսեմ ազդանշանային պարզ արձանագրության մասին:

Քայլ 2. Ազդանշանային արձանագրություն. Պարզ լեզու ցանցային հաղորդակցության համար

Հետևյալ ազդանշանները կարելի է համարել որպես բոլոր հնարավոր բառերի հավաքածու, որոնք սարքերը կարող են օգտագործել միմյանց հետ խոսելու համար: Քանի որ ցանցը շատ պարզ է, շատ բան չկա ասելու, և մենք կարող ենք ներկայացնել այս երեք ազդանշանները պարզ ամբողջ թվերով:

0. Վերագործարկեք

• Նույնացուցիչը ծածկագրում ՝ SIG-R
• Ամբողջ արժեք `0
• Նպատակը. Հեռահար տիրույթում գտնվող բոլոր սարքերին ասեք, որ թողնեն այն, ինչ անում են և վարվեն այնպես, կարծես դրանք պարզապես բեռնված են: Եթե այս ազդանշանը հասնի ցանցի բոլոր սարքերին, ամբողջ ցանցը կվերակայվի, և օգտվողները կարող են նոր խաղ սկսել: Այս ազդանշանը կարող է հեռարձակվել միայն արմատային սարքով:

1. Փոխակերպում Ա

• Նույնացուցիչը ծածկագրում ՝ SIG-A
• Ամբողջ արժեք `1
• Նպատակը. LISTEN_A վիճակում գտնվող ցանկացած սարքի ասեք, երբ նրանք ստանան փոխարկման ազդանշանը, անցնել TEAM_A վիճակին:

2. Փոխակերպում Բ

1. Նույնացուցիչը ծածկագրում ՝ SIG-B
2. Ամբողջ արժեք ՝ 2
3. Նպատակը. LISTEN_B վիճակում գտնվող ցանկացած սարքի ասեք, երբ նրանք ստանան փոխարկման ազդանշանը, անցնել TEAM_B վիճակի:

Քայլ 3. Մենք ցանկանում ենք վերահսկել սարքի գործողությունները `ելնելով նրա ներկա վիճակից

Վերջապես, մենք կարող ենք սկսել գրել կոդը:

Նախ, բացեք նոր նախագիծ Make Code- ում

• Ստեղծեք նոր գործառույթ: Ես իմ loop- ը կանչեցի, քանի որ սա հավելվածի հիմնական հանգույցն է
• Ավելացրեք հանգույցի բլոկ, որը կկրկնվի անվերջ: Ես օգտագործել եմ մինչ (ճշմարիտ), քանի որ բառացի ճշմարիտը երբեք կեղծ չի լինի, հետևաբար հավելվածի կառավարման հոսքը երբեք դուրս չի գա օղակից
• Ավելացրեք բավականաչափ այլ արգելափակումներ `ստուգելու, արդյոք սարքը գտնվում է իր հնարավոր հինգ վիճակներից որևէ մեկում
• Ստեղծեք փոփոխական ՝ սարքի ընթացիկ վիճակը պահելու համար

• Ստեղծեք փոփոխականներ `հինգ հնարավոր վիճակներից յուրաքանչյուրը ներկայացնելու համար

  Նշում. Լավ է, որ այս փոփոխականները դեռ չունեն որևէ նշանակված արժեք: Մենք դրան կհասնենք: Այս պահին ավելի կարևոր է, որ մենք գրենք մաքուր, հեշտ ընթերցվող ծածկագիր

• Եթե-այլ բլոկներում փոխեք յուրաքանչյուր պայման, որպեսզի համեմատեք ընթացիկ վիճակը հնարավոր վիճակներից որևէ մեկի հետ
• Եթե այլ բաների բլոկների ներքևում ավելացրեք ընդմիջում որոշ քանակությամբ միլիվայրկյանների ընթացքում և ստեղծեք փոփոխական ՝ այդ թիվը պահելու համար: Մենք այն նախաստորագրելու ենք ավելի ուշ: Համոզվեք, որ փոփոխականն ունի նկարագրական անուն, օրինակ ՝ տիզ կամ սրտի բաբախում: Քանի որ սա սարքի հիմնական հանգույցն է, այս դադարը կորոշի այն արագությունը, որով սարքը կատարում է հիմնական օղակը, ուստի դա շատ կարևոր արժեք է և չափազանց կարևոր է առանց անունի կախարդական թիվ լինելու համար:

Նշում. Մի անհանգստացեք երրորդ պատկերի մոխրագույն բլոկների մասին: Դրանց ավելի ուշ կանդրադառնամ:

Քայլ 4: Մենք ցանկանում ենք արձագանքել օգտվողի մուտքին

Այժմ մենք ուզում ենք սարքին ասել, թե ինչպես վարվել կոճակների սեղմումների հետ: Մեկի առաջին միտքը կարող է լինել մուտքագրման կատեգորիայում պարզապես օգտագործել «Երբ կոճակը սեղմված է» բլոկները, բայց մենք կցանկանայինք դրանից ավելի մանրակրկիտ վերահսկողություն: Մենք կօգտագործենք «on event from (X) with value (Y)» բլոկը հսկողության կատեգորիայի առաջադեմ բաժնի ներքո, քանի որ մենք առաջադեմ ենք այս ձեռնարկում:

• Ստեղծեք չորս «իրադարձությունից…» բլոկ:

  • Դրանցից երկուսը պետք է ստուգեն «MICROBIT_ID_BUTTON_A» իրադարձության աղբյուրը
  • Դրանցից երկուսը պետք է ստուգեն «MICROBIT_ID_BUTTON_B» միջոցառման աղբյուրը

  • Երկու իրադարձություններից, որոնք ուղղված են յուրաքանչյուր կոճակին.

    • Պետք է ստուգել «MICROBIT_BUTTON_EVT_UP» տիպի իրադարձությունը
    • Պետք է ստուգել «MICROBIT_BUTTON_EVT_DOWN» տիպի իրադարձությունը
  • Նշում. Բոլոր մեծատառերով այս ընտրանքները պիտակներ են, որոնք օգտագործվում են ստորին մակարդակի միկրո: բիտ կոդի մեջ: Նրանք պարզապես տեղաբաշխիչներ են, որոնք հետագայում փոխարինվում են ամբողջ թվերով, երբ ծածկագիրը կազմվում է գործարկվող երկուականի: Մարդկանց համար ավելի հեշտ է օգտագործել այդ պիտակները, քան փնտրել, թե որ ամբողջ թիվն է դնելու, չնայած երկուսն էլ նույն կերպ կաշխատեն:

• Որպես ոճ, ես ընտրեցի, որ յուրաքանչյուր «իրադարձությունից…» բլոկը կանչի գործառույթ, որը նկարագրում է բարձրացված իրադարձությունը: Չնայած խիստ անհրաժեշտ չէ, բայց իմ կարծիքով սա բարելավում է ընթերցանությունը: Եթե մեկը ցանկանում է դա անել, նրանք կարող են իրադարձությունների մշակման ծածկագիրը տեղադրել ինքնին «on event from…» բլոկի ներսում:

  Նշում. Կոդի բլոկը, որը կարգավորում է սարքի պատասխանը իրադարձությանը, ինտուիտիվ կերպով կոչվում է «իրադարձությունների կառավարիչ»

• Յուրաքանչյուր իրադարձության կառավարիչում ավելացրեք նույն եթե-այլ կառուցվածքը, որն օգտագործվում է սարքի վիճակի հիման վրա կառավարման հոսքը պառակտելու համար, ինչպես հիմնական պետական հանգույցի կառուցվածքը:

• Ավելացրեք հանձնարարական բլոկներ, որոնք փոփոխում են սարքի այդ վիճակը, ինչպես նշված է մեր պետական դիագրամում

  • Մենք գիտենք, որ երբ սարքը գտնվում է ԱՆՀՐԱԵՇՏ վիճակում, սարքը պետք է արձագանքի A կոճակին, որը սեղմված է LISTEN_A վիճակի անցումով, և B կոճակին `սեղմված LISTEN_B վիճակի անցումով:
  • Մենք նաև գիտենք, որ երբ սարքը գտնվում է LISTEN_A կամ LISTEN_B վիճակում, սարքը պետք է արձագանքի համապատասխանաբար բաց թողնված A կոճակին և արձակված B կոճակին `վերադառնալով ԱՆՇԱՀԱԳՈՅՆ վիճակին:

  • Վերջապես, մենք գիտենք, որ երբ սարքը գտնվում է TEAM_A կամ TEAM_B վիճակում, սարքը պետք է արձագանքի A սեղմված կոճակին և B կոճակին սեղմված `համապատասխանաբար SIG_A և SIG_B հեռարձակումներով:

    Այս պահին անհրաժեշտ չէ լրացնել հեռարձակման ազդանշանների մանրամասները: Մենք դրան ավելի ուշ կհասնենք: Կարևորն այն է, որ մենք հանձնարարենք այս գործառույթներին օգտագործել այն ծածկագիրը, որը մենք կգրենք ՝ գործողությունների այդ բլոկին տալով անուն, օրինակ ՝ broadcastSignalSIG_A, որը նկարագրում է, թե ինչ պետք է արվի այդ պահին:

Քայլ 5. Մենք ցանկանում ենք սկզբնականացնել տվյալների արժեքները սարքերի հիշողության մեջ, երբ սարքը գործարկվի

Այս պահին մենք օգտագործել ենք բազմաթիվ փոփոխականներ (տվյալների անուններ), բայց իրականում այդ անուններին արժեքներ չենք վերագրել: Մենք ցանկանում ենք, որ սարքը բեռնման ժամանակ բեռնի այս բոլոր փոփոխականների արժեքները, ուստի մենք այդ փոփոխականների սկզբնավորումը տեղադրում ենք «մեկնարկի» բլոկում:

Սրանք այն արժեքներն են, որոնք մենք պետք է նախաստորագրենք.

• Ազդանշանի հաստատունները, ըստ ազդանշանային արձանագրության: Արժեքները պետք է լինեն.

  • SIG_R = 0
  • SIG_A = 1
  • SIG_B = 2
  • Նշում. Ես այս հաստատունները նախածանցել եմ «EnumSignals» նշումով, որպեսզի նշեմ, որ այդ փոփոխականները պետք է իրենց պահեն այնպես, կարծես թվանշան կոչվող թվարկված տիպի մաս լինեն: Այս փոփոխականները կարող են կիրառվել ծրագրավորման այլ լեզուներում: Թվարկված տեսակների սահմանումը և բացատրությունը դուրս են իմ ձեռնարկի շրջանակներից: Oneանկության դեպքում կարելի է 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)» բլոկը
• Ptionանկության դեպքում, սերիական թողարկման վրա գրեք «Նախնականացումը ավարտված է» հաղորդագրությունը, որպեսզի օգտագործողին ասեք, որ ամեն ինչ լոգանքով է ընթանում:
• Այժմ, երբ մենք ավարտեցինք սարքի կարգավորումը, մենք կարող ենք զանգահարել մեր պետական հանգույց գործառույթը:

Քայլ 6. Մենք ցանկանում ենք ցուցադրել անիմացիա և գրաֆիկա ՝ օգտագործելով 5 X 5 LED էկրան

Իսկ հիմա բոլորովին այլ բանի մասին:

Մենք ցանկանում ենք ցուցադրել մի քանի անիմացիա և մի քանի նիշ, բայց չենք ուզում ընդհատել հիմնական վիճակի օղակը: Unfortunatelyավոք, պատկերները և տեքստային տողերը ցուցադրող բլոկները լռելյայն ունեն 400 ms ուշացում: Սա ոչ մի կերպ փոխելու հնարավորություն չկա ՝ առանց ծածկագրի javascript- ի ներկայացուցչության խմբագրման: Այսպիսով, սա այն է, ինչ մենք կանենք:

• Ստեղծեք գործառույթ յուրաքանչյուր պատկերի համար: Սա թույլ կտա մեկ անգամ օգտագործել մեկ բլոկ ՝ պատկերը ցուցադրելու համար ՝ ամեն անգամ javascript խմբագրելու փոխարեն: Այս հատուկ ծրագրում ոչ մի պատկեր չի օգտագործվում մեկից ավելի անգամ, բայց ես, այնուամենայնիվ, կարծում եմ, որ այս ոճը հեշտացնում է ծածկագրի ընթերցումը:
• Յուրաքանչյուր նոր գործառույթում ավելացրեք «ցուցադրել պատկերը (X) օֆսեթ 0 -ում» բլոկը ՝ համապատասխան պատկերի փոփոխականի անունը փոխարինելով (X)

• Ավելացնել, հիմնական պետական հանգույցում: «Stringույց տալ տողը (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

Ստեղծեք այս գործառույթները, եթե դրանք արդեն գոյություն չունեն:

Յուրաքանչյուր գործառույթում.

• Callանգահարեք հեռարձակման անիմացիայի գործառույթը: Սա արգելափակելու է որևէ այլ բան մինչև դրա ավարտը, որը կլինի MS_PER_FRAME_BROADCAST_ANIMATION * 3 = 1.5 վայրկյանում: Հաստատուն բազմապատկվում է երեքով, քանի որ անիմացիայի մեջ կա երեք շրջանակ: Սա կամայական է և ավելին կարող է ավելացվել, եթե գեղագիտական / u200b / u200b բարելավումը բավականաչափ մեծ է: Այս անիմացիայի երկրորդ նպատակն է կանխել օգտվողին հեռարձակել գործառույթի սպամը:
• Ավելացրեք «ռադիոյի ուղարկման համար (X)» բլոկ, որտեղ գործառույթի անվան մեջ նշված ազդանշանի հաստատունն է

Դա այն ամենն է, ինչ անհրաժեշտ է ռադիոյով հեռարձակվել:

Քայլ 8. Մենք ցանկանում ենք լսել և ստանալ տվյալներ սարքի ռադիոյով և համապատասխանաբար մշակել դրանք

Սա հիմնական ծրագիր ստեղծելու վերջին քայլն է:

Մենք սարքին կասենք, թե ինչպես մշակել մուտքային ռադիոազդանշանները: Նախ, մեր սարքը պատրաստվում է անվանել ստացված ազդանշանը: Այնուհետեւ, ելնելով այդ ազդանշանի արժեքից, կորոշի, թե ինչ գործողություններ ձեռնարկել, եթե այդպիսիք կան:

Առաջին:

1. Ստեղծեք կոդի բլոկ ՝ սկսած «ստացված ռադիոյով (X)» բլոկից:
2. Ըստ ցանկության, ստացված արժեքը վերագրեք մեկ այլ փոփոխականի ՝ ավելի նկարագրական անունով:
3. Callանգահարեք մի գործառույթ, որը կմշակի ազդանշանը

Երկրորդ, ազդանշանի մշակման գործառույթում.

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: Մենք ավարտեցինք:

Վերևում պատկերված է հավելվածը աշխատող սարքերի նկարը: Երկու աջ կողմում աշխատում է հիմնական «օգտվող» ծրագիրը, իսկ ձախում ՝ «արմատ» ծրագիրը:

Ես ցուցադրեցի այս խաղը CS Connections 2018-ում, մեկշաբաթյա ամառային համաժողով ՝ միջին և ավագ դպրոցների ուսուցիչների համար ՝ համակարգչային գիտության կրթության վերաբերյալ: Ես ուսուցիչներին տվեցի մոտ 40 սարք և բացատրեցի կանոնները: Շատերի կարծիքով խաղը զվարճալի էր, իսկ շատերի մոտ այն շփոթեցնող էր, քանի դեռ չէին պարզել, թե ինչպես խաղալ: Theույցը կարճ տևեց, բայց մենք գտանք, որ խաղը հաճելի էր բավականին բազմազան ամբոխի մեջ:

CS Connections 2018 -ի մասին լրացուցիչ տեղեկություններ կարող եք գտնել այստեղ: