Միկրո ծրագրավորում. Bit Robot & Joystick: Bit Controller With MicroPython: 11 Steps

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

Robocamp 2019-ի ՝ մեր ամառային ռոբոտաշինության ճամբարի համար, 10-13 տարեկան երիտասարդները զոդում, ծրագրավորում և կառուցում են BBC- ի միկրո ՝ բիտերի վրա հիմնված «հակակշիռ ռոբոտ», ինչպես նաև ծրագրավորում են միկրո.

Եթե այժմ գտնվում եք Robocamp- ում, անցեք Քայլ 3 -ին, քանի որ մենք առաջին երկու քայլերն արել ենք որպես խումբ:

Սա միկրո: բիթ ռոբոտ ձեռք բերելու քայլ առ քայլ ուղեցույց է, որը հաղորդակցվում է joystick: bit վերահսկիչով:

Ամեն ինչ աշխատեցնելու համար դա չի պահանջում ամենաարագ ճանապարհը, այլ փորձում է փոքր կտորներով, որպեսզի կարողանաք ստուգել ընթացքի կոդը, տեղադրել ձեր սեփական կնիքը և հասկանալ, թե ինչու ենք մենք անում այն, ինչ անում ենք: !

Այս գործունեության համար մենք օգտագործում ենք մեր անհատականացված ռոբոտը, բայց այն կաշխատի ցանկացած ռոբոտի հետ, օգտագործելով նմանատիպ շարժիչ վարորդ, օրինակ ՝ L9110s:

Մեր ռոբոտի նախագծման ֆայլերը կարելի է գտնել այստեղ ՝

Այս ուղեցույցը գրված է սկսնակների համար, բայց եթե նախկինում երբեք micro: bit չեք օգտագործել MicroPython- ի հետ, խորհուրդ ենք տալիս նախ փորձել ավելի պարզ ծրագիր, ինչպիսին է մեր անվան կրծքանշանը Instructable: https://www.instructables.com/id/Felt -Միկրոբիտ-Նամ…

Պարագաներ

2x BBC միկրո ՝ բիթ

Ռոբոտ, որն աշխատում է BBC- ի միկրո. Bit (տե՛ս վերևի բացատրությունը)

joystick: բիթ հսկիչ (մենք ստացել ենք մերը Cool Components- ից)

Քայլ 1: Ռոբոտի կարգավորում

Դուք ունեք մի քանի տարբերակ ՝ ձեր միկրո համակարգի համար MicroPython կոդ գրելու համար: bit:

• Mu, որը կարող եք ներբեռնել և տեղադրել այստեղից ՝
• Առցանց խմբագիր, որը կարող եք գտնել այստեղ ՝

Այս հրահանգները ենթադրում են, որ դուք օգտագործում եք Mu:

Բացեք Mu- ն և միացրեք ձեր micro: bit- ը համակարգչին: Mu- ն պետք է ընդունի, որ դուք օգտագործում եք micro: bit և ընտրեք micro: bit 'Mode', բայց եթե դա այդպես չէ, ապա այն ձեռքով փոխեք:

Ստացեք ռոբոտի շարժիչի փորձարկման կոդի պատճենը այստեղից ՝

Եթե դուք սովոր չեք Github- ին, ապա այն կարող է ոչ ինտուիտիվ լինել: Այս կոդը ստանալու երկու հեշտ եղանակ են.

1. Պահպանեք Raw ֆայլը ձեր համակարգչում, այնուհետև տեղադրեք այն Mu- ում.
2. Պատճենեք և տեղադրեք բոլոր ծածկագիրը Mu- ի նոր ֆայլում:

Այժմ կտտացրեք «Flash» կոճակին Mu- ի գործիքագոտուց ՝ ձեր նոր ծածկագիրը միկրո: բիթ ուղարկելու համար:

Սա չի աշխատի, եթե միկրո: բիթը միացված չէ:

Միկրոյի հետևի դեղին լույսը. Բիթը կսկսի բռնկվել: Երբ այն ավարտվի, ձեր կոդը փոխանցվել է:

Շարժիչային ուղեցույցների կարգավորում

Այս ծրագիրը միացնում է շարժիչները տարբեր ուղղություններով, երբ սեղմում եք «A» կոճակը միկրո: բիտի վրա:

Այն, ինչ ցանկանում եք տեղի ունենալ, հետևյալն է.

• Երբ «A» - ն ցուցադրվում է, ձախ շարժիչը շարժվում է առաջ
• Երբ «B» - ն ցուցադրվում է, ձախ շարժիչը հետ է մնում
• Երբ «C» - ն ցուցադրվում է, աջ շարժիչն առաջ է շարժվում
• Երբ «D» - ն ցուցադրվում է, աջ շարժիչը հետընթաց

Հավանաբար, դա այդպես չի լինի, քանի որ դա կախված է նրանից, թե ինչպես եք լարել ձեր ռոբոտը:

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

Եթե դուք օգտագործում եք մեր ռոբոտներից մեկը (ֆայլեր), փոխեք փոփոխականների անունները, որպեսզի ռոբոտը շարժվի ճիշտ ուղղություններով.

Եթե դուք օգտագործում եք ձեր սեփական ռոբոտը, նախքան ծածկագիրը խմբագրելը, ստուգեք, թե որ կապում է կապված շարժիչի վարորդը:

ՍՏԵՈՄ ՍԱՐՔԸ

Այժմ ստուգեք, թե ինչպես է ձեր ռոբոտը քշում ՝ հիմնական հանգույցի թեստի կոդը փոխարինելով ձեր սեփական ինչ -որ կոդով:

Դուք ռոբոտին ասում եք, որ քշի ՝ կանչելով drive () գործառույթը: Սա տևում է երկու փաստարկ `ձախ շարժիչի համար արժեք և աջ շարժիչների համար` 0 (անջատված) և 1023 (առավելագույն արագություն) միջև:

Օրինակ, սկավառակակիր (500, 500) կանչելով, դուք երկու շարժիչին ասում եք, որ միացնեն, առջևի ուղղությամբ, մոտ կես արագությամբ:

Փորձեք մի քանի տարբերակ ՝ զգալու համար, թե որքան ուղիղ է քշում և որքան լավ է պտտվում:

Հուշում. Շարժիչային փորձարկումները եղել են միառժամանակ True loop- ի և if- ի հայտարարության մեջ. Շարժիչները չեն պտտվի, մինչև չսեղմեք A կոճակը միկրո: բիթին, և այն ընդմիշտ ստուգվում է `սեղմե՞լ եք A կոճակը:

Հուշում. Շարժիչները չեն անջատվի, մինչև չասեք նրանց: Նրանք միշտ կշարունակեն կատարել իրենց վերջին հրահանգը:

ԸՆՏՐՈԹՅՈՆ. Ո DRԻ DR ԳԻՏՈ DRՄ ՄԵԿՆԵԼՈ ԲԱՐՁՐԱՈՄԸ

Եթե ձեր ռոբոտը չի շարժվի ուղիղ գծով, ձեր շարժիչներից մեկը կարող է մյուսից արագ պտտվել:

Ստուգելուց հետո, որ ֆիզիկապես ոչինչ չի խանգարում անիվն ազատ պտտվելուն, կարող եք խմբագրել սկավառակի գործառույթի ծածկագիրը `ավելի արագ շարժիչի արագությունը նվազեցնելու համար:

Ոլորեք դեպի վեր ՝ սկավառակի գործառույթի սահմանումը գտնելու համար և նայեք վերևի երկու հրահանգներին.

def drive (L, R):

# Ստորև բերված է շարժիչի արագության անհամապատասխանությունը շտկելու ճշգրտում L = int (L*1) R = int (R*1)

Այս երկու տողերը ներկայումս վերցնում են L և R արժեքը, բազմապատկում դրանք 1 -ով, ապա համոզվում, որ դրանք դեռ ամբողջ թվեր են (int):

Օրինակ, եթե ձեր ձախ շարժիչն ավելի արագ է, փոխեք դրա գծի *1 -ը մինչև *0.9 և տեսեք, թե արդյոք դա բարելավում է իրավիճակը:

Դուք չեք կարողանա այն դարձնել կատարյալ, բայց կարող եք շարունակել հարմարվել մինչև այն ավելի ուղիղ քշի:

ՌԱԴԻՈՅԻ ԿԱՐԳԱՎՈՐՈՄ

Այժմ կարգավորեք ռադիոն ՝ ձեր ծածկագրի վերևում ավելացնելով հետևյալ տողերը.

ռադիո ներմուծել

radio.config (ալիք = 7, խումբ = 0, հերթ = 1) radio.on ()

Սա թույլ կտա ձեր ռոբոտին ստանալ հրահանգներ մեկ այլ միկրո բիթից, բայց այս պահին այն կստանա հրահանգներ ցանկացած այլ միկրո բիթից:

Դա պայմանավորված է նրանով, որ 7 -րդ և 0 -րդ խումբը կանխադրված ալիքներն են:

Փոխեք այս թվերը ՝ ընտրելով 0-82-ի և 0-255-ի միջև եղած ալիք: Այժմ ձեր micro: bit- ը կստանա հրահանգներ միայն մյուսներից `նույն կազմաձևման տեղեկատվությամբ:

հերթ = 1 նշանակում է միկրո.

Այժմ դուք պետք է խմբագրեք ձեր հիմնական հանգույցի կոդը ՝ կոճակը սեղմելիս հրահանգների գործարկման փոխարեն, սպասեք մուտքային ռադիո հաղորդագրության և համապատասխան արձագանքեք:

Փորձեք հետևյալ ծածկագիրը ՝ որպես թեստ (դա ոչինչ չի անի, մինչև 2 -րդ քայլում տեղադրված ջոյսթիկը):

իսկական True:

հաղորդագրություն = radio.receive () եթե հաղորդագրություն == 'առաջ': քշել (500, 500)

Քայլ 2: Joystick- ի կարգավորում

Անջատեք ձեր ռոբոտի միկրո. Բիթը և փոխարենը միացրեք ձեր ջոյսթիկի միկրո

Ձեռք բերեք «joyոյստիկի» ստեղծման կոդի պատճենը այստեղից ՝

Կարգավորեք ռադիոն ՝ օգտագործելով նույն կոնֆիգուրացիան (ալիքի և խմբի համարը), ինչ արեցիք ռոբոտի համար. Դա թույլ կտա երկուսին շփվել միմյանց հետ:

Րագրի վերջում սկսեք ձեր հիմնական հանգույցը.

իսկական True:

եթե button_a.was_pressed (): radio.send ('առաջ')

Այս ծածկագիրը դեռ չի օգտագործում joystick: bit: Այն օգտագործում է A կոճակը միկրո: bit հաղորդագրություն ուղարկելու համար:

Համոզվեք, որ և՛ ձեր ռոբոտը, և՛ ձեր վերահսկիչ միկրո. Բիթերն ունեն հզորություն, այնուհետև սեղմեք կոճակը ՝ ձեր հաղորդագրությունը ուղարկելու համար:

Եթե հաղորդագրությունը հաջողությամբ ստացվի, և ձեր ռոբոտը շարժվի … լավ արված: Դուք ավարտել եք կազմաձևման հրահանգները:

Խնդիրների վերացման խորհուրդներ

Եթե դուք ստանում եք սխալի հաղորդագրություն ձեր վերահսկիչի միկրո: բիտ… կարգաբերեք ձեր վերահսկիչի կոդը

Եթե ձեր ռոբոտի micro: bit- ում սխալի հաղորդագրություն եք ստանում … ձեր ռադիոուղերձը հաջողությամբ ուղարկվել է: Բայց ռոբոտը չի կարող դա հասկանալ, այնպես որ ստուգեք, որ ձեր ուղարկած հաղորդագրությունը և այն հաղորդագրությունը, որը դուք ասել եք ռոբոտին, որ լսի համընկնումը:

Եթե ընդհանրապես ոչինչ տեղի չունենա

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

Քայլ 3: ingոյստիկի արժեքների ստուգում

Հաջորդ մի քանի քայլերն օգտագործում են վերահսկիչի ծածկագիրը:

Մինչև ձեր վերահսկիչի ջոյսթիկը օգտագործելը, դուք պետք է իմանաք, թե ինչպիսի արժեքներ եք ստանում փայտը սեղմելիս:

Ձեր հիմնական հանգույցը փոխարինեք հետևյալ ծածկագրով.

իսկական True:

joystick = joystick_push () տպել (joystick) քուն (500)

Միացրեք այս կոդը ձեր micro: bit- ին, այնուհետև կտտացրեք REPL կոճակին Mu- ի գործիքագոտում: Սա խմբագրիչի ներքևում կբացի տերմինալ, որը ձեզ տալիս է միկրո: բիթ իրական ժամանակի հղում:

Սա չի աշխատի, եթե միկրո: բիթը միացված չէ:

REPL- ը բացված վիճակում սեղմեք ձեր միկրո: բիթի հետևի մասի վերակայման կոճակը:

Դուք պետք է տեսնեք, որ որոշ արժեքներ «տպված» են բերում ձեր էկրանին.

Հրել ջոյսթիկի փայտը և տեսնել, թե ինչ է կատարվում թվերի հետ:

Նշեք այն արժեքները, որոնք տրված են, երբ ջոյսթիկը գտնվում է կենտրոնական դիրքում `իմ դեպքում (518, 523):

Կրկին կտտացրեք Mu- ի գործիքագոտու REPL կոճակը ՝ այն փակելու համար: Դուք բաց չեք կարող միկրո:

Քայլ 4: X և Y փոփոխականների ճշգրտում

Դուք ցանկանում եք փոխել ջոյսթիկի գործառույթով տրված արժեքները, որպեսզի.

• կենտրոնում այն զրո է
• վերևը դրական է
• ներքևը բացասական է:

Սա համապատասխանում է ռոբոտին անհրաժեշտ հրահանգներին ՝ դրական թիվ ՝ առաջ շարժվելու համար, և բացասական ՝ հետընթաց վարելու համար:

Նայեք վերջին քայլին ստացած թվերին: Առաջին թիվը x է, իսկ երկրորդ թիվը ՝ y:

Խմբագրեք joystick_push () սահմանումը, որն արդեն առկա է ծրագրում ՝ հանելով ձեր արժեքները բնօրինակից.

def joystick_push ():

x = pin0.read_analog () - 518 y = pin1.read_analog () - 523 վերադարձ x, y

Օգտագործեք ձեր սեփական թվերը, դրանք կարող են տարբերվել իմից:

Լրացրեք ձեր նոր ծածկագիրը, բացեք REPL- ը, սեղմեք micro: bit- ի վերականգնման կոճակը և ստուգեք ձեր արժեքները:

Ստանում եք (0, 0):

Քայլ 5. Ձախ և աջ շարժիչների համար X և Y արժեքների փոխակերպում

Այս պահին այս ջոյստիկը շատ օգտակար չի լինի ռոբոտ վարելիս: Ամբողջ ճանապարհով առաջ մղված ՝ դուք կստանաք այնպիսի արժեք, ինչպիսին է (0, 500):

Եթե այս թվերը տայիք ռոբոտին, այն կմիացներ աջ շարժիչը, բայց ոչ ձախը, ինչը այն չէ, ինչ ցանկանում եք:

Այս դիագրամը ցույց է տալիս, թե ինչ է տեղի ունենում x և y արժեքների հետ, երբ տեղափոխում եք ջոյսթիկը, և այն, ինչ մենք ցանկանում ենք, որ ռոբոտը անի, երբ դուք տեղափոխում եք ժոշտիկը:

Դուք պետք է որոշ մաթեմատիկա օգտագործեք x և y արժեքները խառնելու համար, ձեզ ավելի օգտակար բան տալու համար:

n

ՄԱԹԵՄԱՆԵՐԸ

Սկսենք ՝ ջոյսթիկը մինչեւ վերջ հրելով:

Արժեքների օրինակ կարող եք ստանալ.

x = 0

y = 500

Ռոբոտին օգտակար լինելու համար ցանկանում եք ստանալ հետևյալ արժեքները.

ձախ = 500

աջ = 500

Փորձենք x և y ավելացնել տարբեր եղանակներով ՝ տեսնելու համար, թե ինչ թվեր ենք ստանում.

x + y = 0 + 500 = 500

x - y = 0 - 500 = -500 y + x = 500 + 0 = 500 y - x = 500 - 0 = 500

Հիմա եկեք տեսնենք, թե ինչ կլինի, եթե ջոյսթիկը ամբողջ ճանապարհով մղենք աջ:

Արժեքների օրինակ կարող եք ստանալ.

x = 500

y = 0

Ռոբոտին աջ թեքելու համար ցանկանում եք, որ ձախ շարժիչը շարժվի առաջ, իսկ աջը ՝ հետ:

ձախ = 500

աջ = -500

Եկեք նորից փորձենք մեր բանաձևը.

x + y = 500 + 0 = 500

x - y = 500 - 0 = 500 y + x = 0 + 500 = 500 y - x = 0 - 500 = -500

Համեմատեք բանաձևի երկու հավաքածու ՝ պարզելու համար, թե որ տարբերակն է ձեզ տալու ճիշտ ձախ արժեքը, և որն է ձեզ ճիշտ ճիշտ արժեքը:

Փորձեք այն որոշ արժեքներով, որոնք ստանում եք ձեր սեփական ջոյսթիքից ՝ համոզվելու համար, որ ձեր ընտրած բանաձևը մշտապես աշխատում է:

n

JՈSTՍՏԻԿ Ֆունկցիայի ընդլայնում

Ընդլայնել և խմբագրել joystick գործառույթը ՝ ձախ և աջ երկու նոր փոփոխականներ կազմելու և x- ի և y- ի փոխարեն այդ արժեքները վերադարձնելու համար.

def joystick_push ():

x = pin0.read_analog () - 518 y = pin1.read_analog () - 523 ձախ = աջ = վերադարձ ձախ, աջ

Լրացրեք ձեր նոր ծածկագիրը, բացեք REPL- ը, սեղմեք micro: bit- ի վերականգնման կոճակը և ստուգեք ձեր արժեքները:

Դուք ստանում եք ձեր ակնկալած արժեքները:

Եթե ձեզ ավելի շատ օգնություն է պետք, ստուգեք մեր օրինակի կոդը այստեղ ՝

Քայլ 6. Արժեքների ուղարկում որպես ռադիո հաղորդագրություններ

Այժմ դուք ունեք որոշ արժեքներ, որոնք պատրաստ են ուղարկելու ձեր ռոբոտին:

Խմբագրեք ձեր հիմնական հանգույցը, որպեսզի այն ստուգի ջոյսթիկի արժեքները, բայց այնուհետև արժեքները տպելու փոխարեն դրանք պատրաստ է ուղարկել որպես ռադիո հաղորդագրություն:

իսկական True:

joystick = joystick_push () հաղորդագրություն = փող (joystick [0]) + "" + փող (joystick [1])

Սա իրականում դեռ հաղորդագրություն չի ուղարկի:

Ի՞նչ է կատարվում կոդի այս նոր տողում:

• joystick [0] նշանակում է տեղեկատվության առաջին բիթը, որը դուրս է գալիս joystick գործառույթից (ձախ)
• joystick [1] -ը տեղեկատվության հաջորդ մասն է (աջ)
• str () այս երկու թվերն էլ փոխակերպում է լարային ձևաչափի (տեքստ ՝ թվերի փոխարեն). սա անհրաժեշտ է, որպեսզի կարողանաք տեղեկատվությունը ռադիոյով ուղարկել:

Դուք սովոր կլինեք տեսնել + իմաստը հավելում. Այն կարող է և՛ թվեր ավելացնել, և՛ տողեր միացնել իրար, ինչը նշանակում է, որ տեղեկատվության երկու բիթերը կպցնի իրար:

Օրինակ:

150 + 100 = 250

փող (150) + փող (100) = 150100

Այսպիսով, համախմբումը կկապի ձեր ձախ և աջ արժեքները:

Տեղեկատվության երկու բիթերի միջև տարանջատում կատարելու համար (որպեսզի ռոբոտը իմանա, որ դրանք տեղեկատվության երկու բիթ են), միմյանց միջև միացրեք լրացուցիչ տող ՝ օգտագործելով «»: Խոսքի նշանները տարածության շուրջ նշանակում են, որ այն արդեն լար է:

Ի վերջո, երկարացրեք ձեր ծածկագիրը ՝ այս նորաստեղծ հաղորդագրությունը ռադիոյով ուղարկելու համար.

radio.send (հաղորդագրություն)

քուն (10)

Քունը դանդաղեցնում է հաղորդագրությունների ուղարկումը, որպեսզի ստացող միկրո: բիթը չծանրաբեռնվի չափազանց շատ տեղեկատվությամբ:

Միացրեք այս կոդը ձեր վերահսկիչ միկրո

Քայլ 7: Ստացեք հաղորդագրություններ ձեր ռոբոտի վրա

Վերադարձեք ձեր ռոբոտի կոդին ի սկզբանե. Հիշեք, որ անջատեք ձեր վերահսկիչ միկրո: բիթը, որպեսզի պատահաբար չլցնեք ռոբոտի կոդը դրան:

Ոլորեք ներքև դեպի ձեր հիմնական հանգույց - հեռացրեք փորձարկման ծածկագիրը և փոխարենը ավելացրեք սա.

իսկական True:

հաղորդագրություն = radio.receive () print (message) sleep (100)

Սա սահմանում է մուտքային հաղորդագրությանը հավասար փոփոխական և տպում հաղորդագրությունը REPL- ին `ստուգելու համար, թե արդյոք հաղորդագրությունները հասնում են ինչպես և սպասվում էր:

Լրացրեք ձեր նոր ծածկագիրը, որը կապված է REPL- ի հետ, այնուհետև սեղմեք ջոյսթիկը:

Դուք պետք է ստանաք այսպիսի բան.

Խնդիրների վերացման խորհուրդներ

Եթե դուք ստանում եք սխալի հաղորդագրություն ձեր վերահսկիչի միկրո: բիտ… կարգաբերեք ձեր վերահսկիչի կոդը

Եթե դուք ստանում եք սխալի հաղորդագրություն ձեր ռոբոտի միկրո: bit … ձեր ռադիո հաղորդագրությունը հաջողությամբ ուղարկվել է: Բայց ռոբոտը չի կարող դա հասկանալ, այնպես որ ստուգեք, որ ձեր ուղարկած հաղորդագրությունը և այն հաղորդագրությունը, որը դուք ասել եք ռոբոտին, որ լսի համընկնումը:

Եթե ընդհանրապես ոչինչ տեղի չունենա

• Համոզվեք, որ յուրաքանչյուր միկրո -բիթին փակցրել եք ճիշտ կոդը: բիթը հեշտ է պատահաբար թարթել սխալը:
• Համոզվեք, որ ձեր ալիքի և խմբի համարները համընկնում են յուրաքանչյուր միկրո: բիտի հետ

Քայլ 8. Ռոբոտի շարժիչները կառավարելու համար մուտքային հաղորդագրությունների օգտագործումը

Դուք այժմ ստանում եք երկու համար, որոնք ուղարկվում են ռադիոյով որպես լար:

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

Նախքան դա անելը, դուք պետք է ստուգեք, որ ձեր ստացած հաղորդագրությունը ճիշտ ձևաչափով է:

Եթե ոչ մի հաղորդագրություն չի ուղարկվում, փոխարենը կստանաք «Ոչ մեկը»: Եթե փորձեք բաժանել սա, սխալ հաղորդագրություն կստանաք:

իսկական True:

հաղորդագրություն = radio.receive (), եթե հաղորդագրությունը չկա: message = message.split () drive (int (message [0]), int (message [1]))

Ի՞նչ է կատարվում այստեղ:

• Նոր կոդը կգործի, եթե հաղորդագրությունը այլ բան լինի, քան «Ոչ»:
• message.split () ստուգում է հաղորդագրության մեջ տարածություն (որը մենք ավելացրել ենք վերջին քայլին), և այն օգտագործում է հաղորդագրությունը երկու մասի բաժանելու համար:
• int (հաղորդագրություն [0]), int (հաղորդագրություն [1]) անում է հակառակ քայլը, ինչ մենք արեցինք նախորդ քայլին. յուրաքանչյուր տեղեկատվություն ստանում է առանձին և փոխակերպում այն ամբողջի (ամբողջ թիվ):
• int (հաղորդագրություն [0]) օգտագործվում է որպես շարժիչի գործառույթում ձախ շարժիչի արժեք, իսկ int (հաղորդագրություն [1]) ՝ որպես աջ շարժիչի արժեք:

Ստուգեք, արդյոք այն աշխատում է. Շարժիչները պտտվու՞մ են, երբ սեղմում եք ջոյսթիկը:

Եթե ոչ - ժամանակն է որոշ վրիպազերծման համար:

Եթե այո, ֆանտաստիկ! Դուք ունեք աշխատող հեռակառավարման ռոբոտ:

Որոշ ժամանակ ծախսեք ձեր ռոբոտի հետ վարժություններ կատարելուց ՝ հաջորդ քայլին անցնելուց առաջ: Արդյո՞ք այն տանում է այնպես, ինչպես սպասում եք:

Հաջորդ քայլերը ցույց կտան ձեզ, թե ինչպես օգտագործել ջոյսթիկի կոճակները ՝ ձեր ռոբոտին լրացուցիչ ֆունկցիոնալություն ավելացնելու համար:

Եթե ցանկանում եք մինչ այժմ տեսնել այս ծածկագրի մեր տարբերակը.

• Ռոբոտ ՝
• Վերահսկիչ ՝

Քայլ 9. Կոճակների օգտագործումը - Լրացուցիչ հաղորդագրությունների ստացում

Այս պահին ձեր ծածկագիրը կփորձի պառակտել ոչ մի հաղորդագրություն: Սա նշանակում է, որ եթե այն ստանում է, օրինակ, «բարև», ապա դուք կստանաք սխալի հաղորդագրություն:

Որպեսզի ձեր micro: bit- ը կարողանա մեկնաբանել այլ հաղորդագրություններ, այն պետք է նախ ստուգի յուրաքանչյուր ակնկալվող հաղորդագրություն, այնուհետև այն բաժանվի միայն այն դեպքում, երբ իրեն այլ բան չի ասվել:

Ընդլայնեք ձեր կոդը այսպես.

եթե հաղորդագրությունը Ոչ մեկը չէ.

եթե հաղորդագրություն == 'բարև'. display.show (Image. HAPPY) elif հաղորդագրություն == 'duck': display.show (Image. DUCK) այլ., int (հաղորդագրություն [1]))

Նախ, այն կստուգի, արդյոք ստացել է «բարև» հաղորդագրությունը: Եթե ունի, ապա այն կցուցադրի ուրախ պատկեր, այնուհետև վերադարձեք օղակի վերև և ստուգեք հաջորդ հաղորդագրությունը:

Եթե հաղորդագրությունը բարև չէ, հաջորդը կստուգի, արդյոք հաղորդագրությունը «բադիկ» է:

Եթե հաղորդագրությունը կամ «բարև», կամ «բադ» չէ, ապա այն կկատարի ցուցակի վերջին բանը, որը կիսում է հաղորդագրությունը և միացնում շարժիչները: Այն չի փորձի պառակտել հաղորդագրությունը, եթե ստացել է «բարև» կամ «բադ», այսինքն ՝ այս երկու հաղորդագրություններից որևէ մեկից սխալի հաղորդագրություն չեք ստանա:

Կրկնակի հավասարության նշանը կարևոր է. Դա նշանակում է «հավասար է», համեմատած մեկ հավասար նշանի հետ, որը ինչ -որ բան է սահմանում (այսինքն ՝ հաղորդագրություն = «բարև» նշանակում է, որ մենք փոփոխականը դնում ենք «բարև», հաղորդագրություն == «բարև» նշանակում է, որ մենք հարցնում ենք, արդյոք հաղորդագրությունը հավասար է «բարևի»):

Փորձեք այն առայժմ ընդամենը երկու տարբերակով ՝ այն փորձարկելու համար. Հետագայում կարող եք ավելացնել այնքան այլ հաղորդագրություններ, որքան ցանկանում եք:

Աշխատանքային կոդի հղում ՝

Քայլ 10. Լրացուցիչ հաղորդագրություններ ուղարկելը ՝ վերահսկիչի կոճակների միջոցով

Անջատեք ձեր ռոբոտի միկրո. Բիթը և փոխարենը միացրեք ձեր ջոյսթիկի միկրո

Վերադառնալ ձեր վերահսկիչի կոդին ՝ խմբագրելու համար:

Ռոբոտի կոդի նման, մենք ցանկանում ենք, որ վերահսկիչը ստուգի, թե արդյոք փորձում եք որևէ այլ հաղորդագրություն ուղարկել, նախքան ջոյսթիկի արժեքներն ուղարկելը:

Օղակի վերևում մենք դեռ ցանկանում ենք, որ այն ստուգի ջոյսթիկի ընթացիկ արժեքները, բայց մենք նաև ցանկանում ենք, որ այն ստուգվի ՝ արդյո՞ք այժմ կոճակ է սեղմվում.

իսկական True:

joystick = joystick_push () կոճակ = button_press ()

button_press () վերադարձնում է A, B, C, D, E կամ F արժեքը `կախված նրանից, թե որ կոճակն է այժմ սեղմվում (եթե ոչինչ չի սեղմվում, այն վերադարձնում է Ոչ մեկը):

Այժմ մենք կարող ենք if-elif-else հայտարարություն անել, ինչպես արեցինք ռոբոտի կոդի դեպքում `օգտագործելով երկու կոճակ և ուղարկել ջոյսթիկի արժեքը, եթե ոչ մի կոճակ չի սեղմվում:

եթե կոճակը == 'A':

radio.send ('բարև') քուն (500) էլիֆ կոճակ == 'B': radio.send ('բադ') քուն (500) այլ ՝ հաղորդագրություն = str (joystick [0]) + "" + փող (joystick [1]) radio.send (հաղորդագրություն) քուն (10)

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

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

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

Աշխատու՞մ է:

Եթե դուք ստանում եք սխալի հաղորդագրություններ, ուշադիր մտածեք այն մասին, թե ինչ եք նոր փոխել և ինչ է կատարվում:

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

Աշխատանքային կոդի հղում ՝

Քայլ 11: Հաջորդ քայլերը

Այժմ դուք ունեք այն գիտելիքները, որոնք անհրաժեշտ են ձեր ռոբոտի շարժիչներով և ձեր ջոյսթիկով `բիթ հսկիչով աշխատելու համար:

Օգտագործեք այս գիտելիքները `երկու ծրագրերը բարելավելու և դրանք ձեր սեփականը դարձնելու համար: Որոշ գաղափարներ ստորև:

Ձեր վերահսկիչի վեց կոճակ ունեք: Ի՞նչ եք ուզում, որ նրանք անեն:

• Ի՞նչ կասեք ձեր ռոբոտի համար պարային ռեժիմի մասին ծրագրելու մասին, որը նա կարող է անել հրամանով: Գրեք drive () հրամանների ալգորիթմ, որոնք առանձնացված են sleep () հրամաններով:
• Doանկանու՞մ եք փոխել այն ուղղությունը, որով շարժվում է ռոբոտը, որպեսզի հեշտությամբ գլխիվայր վարվի: Մտածեք ձեր ջիստիկի x և y արժեքների մասին: Ի՞նչ են դրանք ներկայացնում և ինչպե՞ս կարող եք դրանք շահարկել:
• Ձեր ռոբոտն ունի՞ (կամ կարող եք ավելացնել) լրացուցիչ հնարավորություններ, ինչպիսիք են LED- ները, բարձրախոսը կամ տվիչները:

Կոդի կատարելագործման գաղափարներ

• Կարո՞ղ եք օգնել ձեր ռոբոտին հաղթահարել անհայտ հաղորդագրությունները ՝ փորձելով/բացառությամբ ծածկագրի:
• Theոյսթիկից ձախ և աջ արժեքները հաշվարկելու համար օգտագործվող մաթեմատիկան մեզ չի տալիս արժեքների ամբողջ տեսականին (ռոբոտի շարժիչը կարող է ընդունել մինչև 1023 համարը): Կարո՞ղ եք խմբագրել այս ծածկագիրը ՝ ավելի լավ տիրույթ ստանալու համար:
• Գոյսթիկի արժեքները խառնելու այլ մեթոդներ կան. Կարո՞ղ եք դա անել ավելի լավ եղանակով: