Ծրագիր Assembly լեզվով Algorithm Builder ծրագրային միջավայրում: Այնուհետեւ նախագծված սարքի աշխատանքը փորձարկվել է proteus ծրագրային միջավայրում։ Ալգորիթմ Builder avr-ի համար, սկսելու համար Գրաֆիկական assembler Ծրագրավորում avr timers n

Կարծում եմ, որ մեր ժամանակներում չկա ռադիոսիրող, որը երբեք չի հանդիպել միկրոկոնտրոլերների: Վաղ թե ուշ, բայց դա տեղի է ունենում. Երբ ես առաջին անգամ տեսա միկրոկառավարիչով մի շղթա, ես անմիջապես փակեցի բրաուզերի էջը ՝ մտածելով. «Օ, ես դեռ չեմ կարող այն հավաքել»: Բայց ժամանակն անցավ, միկրոկոնտրոլերներով ավելի ու ավելի շատ սխեմաներ կային, և ես վերջապես որոշեցի սկսել: Իրականում ամեն ինչ պարզվեց, որ ամենևին էլ այնքան դժվար չէր, որքան կարծում էի։

Նախ, եկեք պարզենք, թե ինչ է միկրոկոնտրոլերը (MK) այնուամենայնիվ: Ըստ էության, դա մանրանկարչական համակարգիչ է, որը նախատեսված է պարզ առաջադրանքներ կատարելու համար: Միկրոկարգավորիչի աշխատանքի համար անհրաժեշտ ամեն ինչ պարունակվում է մեկ բնակարանում: Միկրոկառավարիչն ունի տարբեր ծայրամասային սարքեր՝ մուտքային/ելքային պորտեր, ժամանակաչափեր, կապի միջերեսներ և այլն։ Միկրոկառավարիչն ունի երեք տեսակի հիշողություն՝ RAM (պատահական մուտքի հիշողություն), FlashROM (ծրագրային հիշողություն), EEPROM (ոչ անկայուն հիշողություն):

Միկրոկարգավորիչի և սովորական միկրոսխեմայի հիմնական տարբերությունն այն է, որ միկրոկառավարիչը չի գործում գործարանում տեղադրված կոշտ տրամաբանության համաձայն, այլ ծրագրավորված է: Ծրագիրը դասականորեն գրվում է հատուկ միջավայրում՝ համակարգչի վրա՝ ծրագրավորման լեզուներից մեկով, որից հետո այն թարգմանվում է մեքենայական լեզվով (կազմվում) և գրվում վերահսկիչի հիշողության մեջ։ Այս դասընթացում ամեն ինչ մի փոքր այլ կլինի՝ ծրագիրը ոչ թե գրվելու է, այլ բառացիորեն գծագրվելու է սխեմայի տեսքով: Այս մոտեցման շնորհիվ ծրագիրն ավելի պարզ է թվում, և ծրագրի մշակման ժամանակը դասական ծրագրավորման տեխնիկայի համեմատ կրճատվում է 3-5 անգամ:

Algorithm Builder - ծրագրավորման միջավայր

Algorithm Builder-ն իրականացնում է զարգացման ամբողջական ցիկլ՝ սկսած ալգորիթմ մուտքագրելուց, ներառյալ վրիպազերծման գործընթացը և վերջացրած ծրագիրը հիշողության մեջ գրելով:

Սկսենք ծրագրի ինտերֆեյսի համառոտ ակնարկից

Հիմնական մենյու

• Ֆայլ.Ծառայում է նախագծերի և առանձին ալգորիթմների բացման, պահպանման, փակման, ինչպես նաև ծրագրից դուրս գալու համար:
• Խմբագրել.Ալգորիթմի խմբագրման հետ կապված գործողություններ՝ կտրել, պատճենել, ընդգծել և այլն:
• Ցուցադրել.Ալգորիթմի/աղյուսակի փոփոխում փոփոխականներով (դրա մասին ավելին ստորև) + գործողությունների և պայմանների ձևանմուշներ:
• Որոնում.Այստեղ բացատրելու կարիք չկա։
• Տարրեր.Ալգորիթմը կազմված է հատուկ տարրերից. Text, Vertex, Field, Label, Condition, Օգտագործված (անվերապահ) անցումային վեկտոր, Customizer:Նրանց բոլորին կծանոթանանք մարզումների ընթացքում։ Մենյուում կան ևս մի քանի կարևոր կետեր. Ապաակտիվացնել, մակրո, ընդհատումներ: Ապաակտիվացնել- այս բաղադրիչը չի կազմվի: Մակրո- ստեղծել մակրոներ: Ընդհատում է- պարունակում է միկրոկառավարիչների բոլոր ընդհատումների անունների ցանկը: Այս ֆունկցիայի մասին կիմանաք հաջորդ դասերում, բայց հիմա միայն կասեմ, որ սա չափազանց կարևոր և անհրաժեշտ բան է աշխատանքի համար։
• Ծրագիր.Ծրագրի հետ կապված գործողություններ՝ կոմպիլյացիա (թարգմանություն մեքենայական լեզվով), ծրագրի մոդելավորում, կարգավորիչի հիշողության ընթերցում (Flash և EEPROM) և այլն:
• Ընտրանքներ.Ծրագրի և շրջակա միջավայրի կարգավորումներ:
• ?. Algoritm Builder-ի տեղեկատվություն և օգնություն:

Գործիքադարակ

Բացատրության կարիք չկա: Երբ սավառնում եք վահանակի տարրերի վրա, գործիքի հուշումներ են հայտնվում:

Բաց նախագիծ

Այստեղ մի յուրահատկություն կա. Դուք չեք կարող միաժամանակ բացել երկու նախագիծ: Նոր նախագիծ բացելու/ստեղծելու համար հարկավոր է փակել հինը: Նախագիծը բացելուց հետո կարող եք բացել/ստեղծել միայն առանձին ալգորիթմի ֆայլ: Ծրագրի ֆայլն ունի .alp ընդլայնում, իսկ առանձին ալգորիթմի ֆայլը՝ .alg ընդլայնում

Աշխատեք փոփոխականների և հաստատունների հետ

Այն կազմակերպված է հատուկ աղյուսակի տեսքով (կարող եք այն փոխարկել F12 ստեղնով կամ ցանկի միջոցով, կամ գործիքագոտու ստեղնի միջոցով): Այսպիսով, ալգորիթմն ինքնին ազատվում է ավելորդ մուտքերից:

Հսկայական թվով պիտակներ, որոնց շնորհիվ հնարավոր են անցումներ ծրագրի մի մասից մյուսը, մեծապես խառնում են կոդը, և ծրագրի հստակությունը կորչում է: Algorithm Builder-ում անցումները շատ ավելի հեշտ են կատարվում՝ սլաքով (վեկտոր). Բայց հնարավոր են նաև անցումներ անվանված պիտակների երկայնքով:

Ծրագրի շահագործման մոդելավորում

Սիմուլյատորը ցույց է տալիս վիրտուալ միկրոկոնտրոլերի ներսում տեղի ունեցող բոլոր փոփոխությունները: Ծրագրի աշխատանքը ստուգելու համար դուք նույնիսկ կարիք չունեք միկրոկառավարիչ գնել: Մոդելավորումը կարող է իրականացվել քայլ առ քայլ (գործառույթների մուտքագրմամբ կամ առանց), մինչև սահմանված ընդմիջման կետը կամ ընտրված տարածքը:

Վրիպազերծում

Algorithm Builder-ն ունի չիպային կարգաբերման համակարգ (On Chip debug), որը թույլ է տալիս դիտարկել իրական միկրոկարգավորիչի հիշողության պարունակությունը նշված կետերում: Այս դեպքում միկրոկառավարիչի միայն մեկ ոտքը օգտագործվում է համակարգչի հետ շփվելու համար և այն էլ՝ օգտագործողի ընտրությամբ: Մոնիտորների վրիպազերծումը կարող է կիրառվել գրեթե ցանկացած միկրովերահսկիչի վրա: Սա debugWIRE արձանագրության ծրագրային տարբերակն է:

Այսպիսով, ինչու է Ալգորիթմ Builder-ը քիչ հայտնի ռադիոսիրողների շրջանում:Նախ՝ մինչև 2010թ. ծրագիրը վճարովի էր։ Այսօր ծրագրային ապահովումը տարածվում է բացարձակապես ազատ։ Երկրորդ՝ ծրագրին պաշտոնական աջակցության բացակայությունը։ Դուք չեք գտնի մեկ արտադրողի apnot, որն օգտագործում է Builder-ը: Այս ծրագրին նվիրված ինտերնետային ռեսուրսները կարելի է հաշվել մի կողմից:

Արժե դրա մասին մի փոքր խոսել անհրաժեշտ նյութեր և գործիքներ

Առաջին բանը, որ դուք պետք է զոդման երկաթ. Ռադիոսիրողի հիմնական գործիքը. Զոդման երկաթի հզորությունը պետք է լինի 30-60 Վտ միջակայքում: Ինչու չի կարող ավելին լինել: Հզոր զոդման երկաթն ավելի է տաքանում և վնասում տախտակի հետքերը և օգտագործված մասերը։ Եվ դա այնքան էլ հարմար չէ զոդման համար. նման զոդման երկաթը շատ ավելի մեծ է և ծանր:

Ծրագիրը միկրոկառավարիչում բեռնելու համար ձեզ հարկավոր է ծրագրավորող- ամենապարզ տարբերակում այն ​​բաղկացած է ընդամենը մի քանի ռեզիստորներից և դիոդներից (մեկ LPT և COM պորտից): Եթե ​​ձեր համակարգչի վրա չունեք COM կամ LPT միացք, ապա USB ծրագրավորող կարող եք պատվիրել DealExtreame կամ (Որոնման հարցում «avr ծրագրավորող»;արժե մոտ 4-6 դոլար): Ծրագրավորող ընտրելու և հավաքելու մասին կգրեմ հաջորդ դասին։

Տարբերակիչ հատկանիշներ.

• Աջակցվող օպերացիոն համակարգեր՝ Windows 95/98/2000/NT/ME/XP
• Լիցենզիա՝ անվճար ծրագիր
• Ինտերֆեյսի լեզուն՝ անգլերեն, ռուսերեն
• Ծրագրավորման լեզուներ՝ գրաֆիկական ասամբլեր
• Հիմնական գործառույթները.
  • գրաֆիկական ծրագրի կոդի խմբագիր
  • կազմող
  • ներդրված ալգորիթմի վրիպազերծման սիմուլյատոր
  • ծրագրավորում COM պորտի միջոցով՝ օգտագործելով պարզ ադապտեր (7 ռեզիստոր, 3 դիոդ, տես գծապատկերի փաստաթղթերը)
  • ալգորիթմի վրիպազերծում չիպի վրա՝ օգտագործելով նույնիսկ ավելի պարզ ադապտեր (1 կամ 2 դիոդ, 2 կամ 4 ռեզիստոր, տես գծապատկերի փաստաթղթերը)
• Ինտերնետային աջակցության հասցե՝ http://algrom.net/russian.html

Նկարագրություն:

Algorithm Builder-ը անվճար միջավայր է (անվճար բաշխման պայմաններ) AVR MK-ի համար, որն ապահովում է որոնվածի մշակման ամբողջական ցիկլ, ներառյալ: փուլեր, ինչպիսիք են ալգորիթմի մուտքագրումը, վրիպազերծումը և ներկառուցված ծրագրավորումը: Ծրագրի մշակումը կարող է իրականացվել ինչպես ասեմբլերի, այնպես էլ մակրո մակարդակով, որտեղ հնարավոր է աշխատել կամայական երկարության փոփոխվող քանակներով։ Սա ծրագրավորման հնարավորություններն ավելի է մոտեցնում բարձր մակարդակի լեզվին:

Algorithm Builder-ի տարբերակիչ առանձնահատկությունը ծրագիր մուտքագրելու հնարավորությունն է գրաֆիկորեն՝ ծառի կառուցվածքով ալգորիթմի տեսքով: Արդյունքում լիովին պարզ է դառնում ծրագրի ողջ տրամաբանական կառուցվածքը։ Ծրագրավորման այս մեթոդը հնարավորինս մոտ է մարդու ընկալման բնույթին և, հետևաբար, շատ ավելի հեշտ է սովորել, երբ համեմատվում է դասական ասամբլերի հետ: Որոնվածը ստեղծելու ժամանակի ակնկալվող կրճատումը դասական assembler-ի համեմատ 3-5 անգամ է:

Շրջակա միջավայրը նախատեսված է Windows 95/98/2000/NT/ME/XP-ով աշխատելու համար: Խմբագրի բնականոն աշխատանքի համար անհրաժեշտ է «Courier» տառատեսակը:

Ֆայլեր ներբեռնման համար.

• AT90 շարք
  • AT90CAN128, AT90PWM3, AT90S1200, AT90S2313, AT90S2323, AT90S2333, AT90S2343, AT90S4414, AT90S4433, AT90S2313, AT90S2323, AT90S2333, AT90S2343, AT90S4414, AT90S4433, AT90S2313, AT90S500S B64, AT90USB82, AT 90USB128, AT90USB162
• ATmega շարք
  • ATmega8, ATmega16, ATmega32, ATmega48, ATmega64, ATmega88, ATmega103, ATmega128, ATmega161, ATmega162, ATmega163, ATmega164P, ATmega2P, ATmega2P, ATmega2P,16 ATmega325, ATmega328P, ATme ga603, ATmega640, ATmega644, ATmega644P, ATmega645, ATmega1280, ATmega1281 , ATmega1284P, ATmega2560, ATmega2561, ATmega3250, ATmega6450, ATmega8515, ATmega8535
• ATtiny
  • ATtiny10, ATtiny11, ATtiny12, ATtiny13, ATtiny15, ATtiny22, ATtiny24, ATtiny25, ATtiny26, ATtiny28, ATtiny44, ATtiny45, ATtiny84, ATtiny15, ATtiny22, ATtiny24, ATtiny28, ATtiny44, ATtiny45, ATtiny84, AT18, ATtiny2 փոքրիկ2313

4.Տեխնիկական պահանջներ.

Այս միկրոէլեկտրոնային ռելեն ունի որոշակի տեխնիկական տվյալներ։

Այս միկրոէլեկտրոնային ռելեն ունի մեկ սովորաբար փակ (հետևի) և մեկ սովորաբար բաց (առջևի) կոնտակտ՝ երկու իմպուլսային հոսանքի բեռների միացման համար:

25, 50 և 75 Հց հաճախականությամբ արտաքին փոփոխական լարման կիրառման ժամանակ շահագործումն ապահովվում է 0,8 Վ-ից մինչև 10 Վ տիրույթում:

25, 50 և 75 Հց հաճախականությամբ փոփոխական հոսանքի վրա աշխատանքային լարումը (2,9-3,2) Վ է, իսկ անկումը (2,1-2,3) Վ։

Նշում. Տիգերինգ - հետևի կոնտակտի բացում և առջևի կոնտակտի փակում: Dropout – առջևի կոնտակտի բացում և հետևի կոնտակտի փակում:

Մուտքային լարման մասին տեղեկատվություն ցուցադրելու համար օգտագործվում է ընդհանուր անոդով ցուցիչ:

Կոնտակտները միացնում են մինչև 30 Վ լարման:

Ցուցանիշի վրա տեղեկատվության թարմացման արագությունը տեղի է ունենում յուրաքանչյուր 12,8 ms-ում:

Մուտքային լարումը շտկելու համար օգտագործվում է միջին կետի ուղղիչ:

5.Էլեկտրոնային ռելեի ֆունկցիոնալ դիագրամ:

Իմպուլսային միկրոէլեկտրոնային ռելեը կարելի է բաժանել մի քանի ֆունկցիոնալ միավորների: Այս ռելեի ֆունկցիոնալ դիագրամը ներկայացված է Նկար 5-ում: Ըստ դիագրամի ֆունկցիոնալ նպատակի՝ մենք կարող ենք տարբերակել.

• 
  Ուղղիչը կառուցված է ընդհանուր կետով շղթայի համաձայն:
• 
  Միկրոպրոցեսոր (MP):
• 
  Ցուցանիշը նախատեսված է տեղեկատվություն ցուցադրելու համար:
• 
  Optocoupler զույգ.

Ուղղիչը նախատեսված է ուղղելու անալոգային ազդանշանը, որը հասնում է իր մուտքին: Իր հերթին, անալոգային ազդանշանը գալիս է պաշտպանիչ ֆիլտրի բլոկից կամ այլ անալոգային տարրից և հանդիսանում է 25, 50 կամ 75 Հց հաճախականությամբ փոփոխական լարում: Ուղղիչի ելքից մենք ստանում ենք շտկված լարում, որը մատակարարվում է միկրոպրոցեսորին:

Միկրոպրոցեսորը կատարում է ծրագրում նշված գործառույթները: Ուղղիչի ելքից հասնելով միկրոպրոցեսորի մուտքին, շտկված լարումը սկսում է վերլուծվել միկրոպրոցեսորի մեջ ներկառուցված ADC-ի միջոցով: Այնուհետև միկրոպրոցեսորը հաշվարկում է չափված լարման միջին արժեքը և ցուցադրում այն ​​ցուցիչի վրա: Optocoupler զույգերը նույնպես միացված են ելքերից մեկին: Դրանք անալոգային են

Նկ. 5. Միկրոէլեկտրոնային ավտոմատ արգելափակման ռելեի ֆունկցիոնալ դիագրամ

Ռելե կոնտակտներ. Կախված արձագանքման շեմից, ազդանշանը հայտնվում է օպտոկապլերների զույգերից մեկի վրա:

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

Տրանզիստորային օպտոկապլերներ, որոնք բաղկացած են արտանետվող դիոդից, որը հիմնված է մկնդեղի-գալիում-ալյումինի միացության և կոմպոզիտային սիլիցիումի ֆոտոտրանզիստորի վրա։ Նախատեսված է ռադիոէլեկտրոնային սարքավորումների գալվանական մեկուսացված էլեկտրական սխեմաներում որպես անջատիչ օգտագործելու համար: Առկա է մետաղյա պատյանով։ Սարքի քաշը 1,5 գ-ից ոչ ավելի է:

6.Աշխատանքային ալգորիթմ.

Միկրոէլեկտրոնային ռելե ստեղծելու համար անհրաժեշտ է որոշել հիմնական խնդիրը. Նախ անհրաժեշտ է կարգավորել միկրոպրոցեսորը, կարգավորել բոլոր մուտքային-ելքային պորտերը, սահմանել ժամանակաչափը և ADC-ն: Սրանից հետո սկսում է ավարտվել հիմնական խնդիրը, որն է՝ ADC-ի միջոցով տեղեկատվություն հավաքել, որից հետո վերլուծել ենք ստացված տվյալները և ցուցադրել դրանք։ Ցուցասարքը, իր հերթին, պետք է ցույց տա մուտքային լարման տասնորդական արժեքը: Գործառնական ավելի մանրամասն ալգորիթմը ներկայացված է Նկար 6-ում:

Ծրագրի ալգորիթմը բաղկացած է հինգ ենթածրագրերից.

• 
  Միկրոպրոցեսորի կարգավորում
• 
  ADC ենթածրագր
• 
  Ժամաչափի ռեժիմ
• 
  Ցուցադրել ենթածրագրերը
• 
  Բաժանման ենթածրագր

Եկեք նայենք, թե ինչպես են աշխատում միկրոպրոցեսորի կարգավորումները: Նախ, մենք սահմանում ենք կույտի նախնական արժեքը: Դրանից հետո մենք կարգավորում ենք ADC-ն: Այստեղ մենք տեղադրում ենք SK/128 prescaler-ը և սահմանում շարունակական փոխակերպման ռեժիմը, երբ փոխարկումները գործարկվում են անընդհատ որոշակի ժամանակային ընդմիջումներով: Այնուհետև մենք կարգավորեցինք ժմչփը: Մենք սահմանել ենք STS-ի գործառնական ռեժիմը (վերակայել պատահականության դեպքում): Այս ռեժիմում համեմատության ռեգիստրում գրված արժեքին հասնելուց հետո հաշվումը շարունակվում է «$00» արժեքից։ Նույն ցիկլում, երբ արժեքները վերակայվում են, ժամանակաչափի ընդհատում է տեղի ունենում: Այնուհետև մենք ստեղծեցինք ընդհատում, որն առաջանում է արտահոսքի պատճառով: Դրանից հետո մուտքային/ելքային նավահանգիստները կազմաձևվում են: Այնուհետև մենք սահմանում ենք դրոշակի բոլոր արժեքները, ցուցումների գտնվելու վայրը, գումարի արժեքը, բաժանարարը և զրոյական գործակիցը: Եվ մենք միացնում ենք գլոբալ ընդհատումը, որի համար i դրոշը դրեցինք մեկ: Մեր միկրոպրոցեսորը կարգավորելուց հետո մեր ծրագիրը սկսվում է: Դա անելու համար սահմանում ենք t=1 պայմանը։ Մինչ t-ի արժեքը հավասար չէ մեկին, տեղի է ունենում ցիկլ, հենց որ այն դառնում է մեկ արժեք, ծրագիրը գնում է դեպի աջ, որտեղ այն գնում է ցուցումների ենթածրագրին և դրա կատարումից հետո t դրոշակը սահմանում է զրոյի և նորից: կրկին փակվում է ցիկլում: Բոլոր հետագա ենթածրագրերը դուրս կգան ընդհատման ժամանակ և կվերադառնան այս հանգույց՝ ստուգելով t դրոշակը:

Հիմա եկեք նայենք ADC ենթածրագրին: Քանի որ մենք կազմաձևեցինք ADC-ն վերևում և ասացինք, որ անցումը ADC ենթածրագրին իրականացվում է ընդհատմամբ՝ ժամացույցի իմպուլսների որոշակի արժեքի միջոցով: Քանի որ միկրոպրոցեսորը տեղադրելուց հետո մեր ծրագիրը պտտվել է մի օղակում, որտեղ ստուգվել է t դրոշի արժեքը, և դրա հետ մեկտեղ հաշվվել են միկրոպրոցեսորի գեներատորի ժամացույցի ցիկլերի արժեքները: Ժամացույցի իմպուլսների որոշակի արժեքի հասնելուց հետո տեղի է ունենում ընդհատում, և ծրագիրը տեղափոխվում է ADC ենթածրագր: Հենց որ անցանք դրան, չափեցինք մուտքային լարման արժեքը։ Այս արժեքը պահելու համար մենք օգտագործում ենք երկու ռեգիստր՝ Yl (ցածր)՝ ցածր բայթերը և Yh (բարձր)՝ բարձր բայթերը պահելու համար։ Դրանից հետո մենք ստուգում ենք t դրոշի արժեքը, եթե այն հավասար է զրոյի, ապա անհրաժեշտ է ցուցադրել արժեքը, իսկ եթե t դրոշակը մեկն է, ապա դա նշանակում է, որ հնարավոր է ADC արժեքը վերածել տասնորդականի։ ձեւը։ Դրանից հետո մենք համեմատում ենք չափված լարման շեմային արժեքը, եթե այդ արժեքը գերազանցում է 0,8 Վ-ի շեմը, ապա մենք գրում ենք այս արժեքը գրանցամատյանում և ավելացնում այն ​​հետագա չափումներով: Ամեն անգամ, երբ մենք ավելացնում ենք ADC արժեքները, մենք ավելացնում ենք բաժանարարի արժեքը մեկով: Այնուհետև մենք ստուգում ենք բաժանարարի արժեքը և եթե դրա արժեքը 255 է, ապա անհրաժեշտ է վերականգնել գումարի բաժանարարի արժեքը, բայց եթե բաժանարարը չի հասել 255 արժեքին, ապա ADC ենթածրագրը դուրս է գալիս:

Բայց եթե համեմատելուց հետո ADC-ի արժեքը ցածր է 0,8 Վ-ի շեմից, ապա ծրագիրը գնում է աջ և այնուհետև մենք անջատում ենք ADC-ն: Դա անհրաժեշտ է, որպեսզի լարման արժեքը ցուցադրվի ցուցիչի վրա: Այնուհետև մենք վերլուծում ենք բաժանարարի արժեքը և եթե այն հավասար չէ զրոյի, ապա ավելացնում ենք ADC արժեքները և մեծացնում ենք բաժանարարը մեկով: Հետո անցնում ենք բաժանման ենթածրագրին։ Սա անհրաժեշտ է միջին լարման արժեքը հաշվարկելու համար: Բայց եթե բաժանարարի արժեքը զրո է, ապա ծրագիրը ցատկում է բաժանման ենթածրագրից անմիջապես հետո: Դրանից հետո մենք համեմատում ենք ADC արձագանքման շեմի արժեքը, և եթե այն ավելի բարձր է, քան շեմը, ապա մուտքագրում-ելքային միացք ենք տալիս մեկի արժեքը, որը համապատասխանում է առջևի կոնտակտի աշխատանքին և փակմանը, և եթե արժեքը փոքր է արձագանքման շեմից, այնուհետև զրոյի արժեքը դուրս է գալիս պորտին, որը համապատասխանում է հետևի կոնտակտի փակմանը: Այնուհետև մենք բաժանարարի արժեքը և t դրոշակը սահմանեցինք զրո: Մենք նաև վերականգնում ենք ADC արժեքը և միացնում այն ​​և դուրս ենք գալիս ADC ենթածրագրից:

Հաջորդը, հաշվի առեք բաժանման ենթածրագրը, որին անցումը գտնվում է ADC ենթածրագրում: Չափված լարման միջին արժեքը հաշվարկելու համար անհրաժեշտ է բաժանման ռեժիմ: Բաժանման ծրագիրը ADC-ի բոլոր արժեքների գումարից բաժանարարի արժեքի հաջորդական հանումն է: Այս հանումը կատարվողների թիվը կլինի միջինի արժեքը, այսինքն՝ քանորդը: Դիտարկենք հենց այս գործողության ալգորիթմը։ Ենթածրագրին անցնելուց հետո գործակիցի արժեքը զրոյացնում ենք, այնուհետև ստուգում ենք C դրոշը: Եթե դրա արժեքը հավասար չէ մեկին, ապա մեկով մեծացնում ենք գործակցի արժեքը և գումարից հանում բաժանարարի արժեքը: բոլոր ADC արժեքներից: 1 արժեքը գրվում է C դրոշի վրա միայն այն բանից հետո, երբ գումարի արժեքը փոքր է բաժանարարի արժեքից: Հենց որ միավորը գրվի C դրոշի վրա, ծրագիրը դուրս է գալիս հանգույցից: Ստացված գործակիցի արժեքը մուտքագրում ենք X ռեգիստր և զրոյացնում գումարի արժեքը։ Սա ավարտում է բաժանման ծրագիրը և դուրս գալիս դրանից:

Ինչպես ADC ենթածրագրին, այնպես էլ ժամանակաչափի ենթածրագրին անցումը տեղի է ունենում ժամացույցի իմպուլսների որոշակի արժեքի միջոցով: Բնականաբար, ժմչփի ենթածրագրին ընդհատումով անցումը տեղի է ունենում ADC ենթածրագրի ընդհատման հետ տարբեր ժամանակներում: Ըստ այդմ՝ նրանք միմյանց չեն խանգարում։ Ժամաչափի ենթածրագրում մենք աստիճանաբար ցուցադրում ենք ցուցիչի մասին տեղեկատվություն: Քանի որ մենք ունենք չորս նիշ, մենք պետք է հաջորդաբար ցուցադրենք թվանշանների արժեքները մեկը մյուսի հետևից: Դա անելու համար կա n, որտեղ մենք գրում ենք 0-ից 3 արժեք, որը համապատասխանում է յուրաքանչյուր թվանշանին: Ընդհատման անցումից հետո ծրագիրը սկսվում է: Նախ ստուգում ենք n-ի արժեքը և եթե այս արժեքը զրո է, ապա անցնում ենք առաջ, որտեղ կիրառում ենք զրո՝ չորրորդ ծանոթությունն անջատելու համար։ Մենք թողարկում ենք թիվ B նավահանգստում: Դրանից հետո մենք մատակարարում ենք միավորը, որպեսզի լուսավորվի առաջին ծանոթությունը: Արդյունքում առաջին նիշը լուսավորվում է ցուցիչի վրա: Այնուհետև անցումը տեղի է ունենում պիտակի երկայնքով: Հաջորդը մեկով ավելացնում ենք n-ի արժեքը և դուրս ենք գալիս ենթածրագրից։ Որոշ ժամանակ անց ժամանակաչափի մեկ այլ ընդհատում է տեղի ունենում, և ծրագիրը գնում է ժմչփի ենթակարգ, որտեղ մենք կրկին համեմատում ենք n-ի արժեքը: Քանի որ մենք ավելացրել ենք այն մեկով, համապատասխանաբար անցումը տեղի է ունենում, երբ n-ը հավասար է մեկին: Այնուհետև առաջին ծանոթությունն անջատված է, երկրորդ համարի արժեքը դուրս է բերվում B պորտին, իսկ երկրորդ ծանոթությունը միացված է: Այնուհետև նորից անցումը տեղի է ունենում պիտակի երկայնքով, և n-ի արժեքը մեծանում է մեկով: Երրորդ և չորրորդ թվանշանների արժեքը ցուցադրվում է նույն կերպ, բայց չորրորդ նիշը դուրս բերելիս n-ի արժեքը սահմանում ենք զրո, սա այն բանի համար է, որ ապագայում առաջին թվանշանի ելքը նորից սկսվի։ Նաև այստեղ մենք գրում ենք մեկի արժեքը t դրոշի վրա: Ցուցանիշի վրա չորրորդ նիշը ցուցադրվելուց հետո ծրագիրը դուրս է գալիս և մտնում t դրոշի արժեքը ստուգելու ցիկլ:

Քանի որ դրոշը դրված է մեկին, ապա դրոշի ստուգման ցիկլից անցում է տեղի ունենում, որից հետո անցում է տեղի ունենում ցուցումների ենթածրագրին: Այս ենթածրագրում մենք որոշում ենք հազարների, հարյուրավորների, տասնյակների և միավորների արժեքը, ինչպես նաև որոշում ենք ստացված թվի արժեքը՝ այն B նավահանգիստ դուրս բերելու համար: Ցուցադրման ենթածրագրին անցնելուց հետո մենք արգելում ենք գլոբալ ընդհատումը: Այնուհետև մենք վերականգնում ենք temp ռեգիստրի արժեքը: Այնուհետև համեմատում ենք Z ռեգիստրում գտնվող միջին ADC արժեքը, եթե այն հազարից ավելի է, ապա Z ռեգիստրից հանում ենք 1000, հանելուց հետո մեկ մուտքագրում ենք temp ռեգիստր: Ամեն անգամ, երբ Z-ից 1000-ը հանվում է, միավոր է ավելացվում: Temp ռեգիստրի պարունակությունը համապատասխանում է հազարների արժեքին: Հենց ռեգիստր Z-ը դառնում է 1000-ից պակաս, ծրագիրը շարունակվում է: Անցումից հետո մենք վերագրում ենք temp ռեգիստրի արժեքը r0 ռեգիստրում և այն զրոյացնում: Այնուհետև մենք կրկին համեմատում ենք Z ռեգիստրի արժեքը և եթե այն մեծ է 100-ից, ապա նրանից նորից հանում ենք 100-ը, և յուրաքանչյուր հանումով մենք մուտքագրում ենք մեկը ժամանակային ռեգիստր: Հենց որ Z ռեգիստրի արժեքը դառնում է 100-ից պակաս, ծրագիրը շարունակվում է։ Դրանից հետո մենք հարյուրավորների արժեքը վերագրում ենք ռեգիստրում r1: Այնուհետև մենք վերականգնում ենք temp ռեգիստրի արժեքը: Այնուհետև համեմատում ենք Z ռեգիստրի արժեքը և եթե այն մեծ է 10-ից, ապա Z ռեգիստրից հանում ենք 10, իսկ յուրաքանչյուր հանումով մուտքագրում ենք մեկը temp ռեգիստրում։ Հենց Z ռեգիստրի արժեքը դառնում է 10-ից պակաս, ծրագիրը շարունակվում է: Հաջորդը, հիշեք տասնյակների արժեքը ռեգիստրում r2: Z ռեգիստրում մնացած արժեքն այն արժեքն է, որը սահմանում է մեկների արժեքը: Այս արժեքը գրված է r3 գրանցելու համար: Այժմ հազարների, հարյուրավորների, տասնյակների և միավորների արժեքները համապատասխանաբար գտնվում են r0, r1, r2 և r3 գրանցամատյաններում: Սրանից հետո Z ռեգիստրում մուտքագրում ենք ծածկագրերի աղյուսակի հասցեն, որը պարունակում է ցուցադրվող թվերի նշանակությունը։ Եթե ​​չափման ժամանակ հազարների արժեքը զրո է, ապա անհրաժեշտ է զսպել զրոյի արժեքը ամենակարևոր թվանշանում։ Սրանից հետո գրանցամատյանում առաջին թվի արժեքը մուտքագրում ենք r0, այնուհետև r1-ում երկրորդ նիշի արժեքը, r2-ում երրորդ նիշի արժեքը և r3 գրանցամատյանում՝ վերջին թվի արժեքը: Դրանից հետո մենք միացնում ենք գլոբալ ընդհատումը: Սա ավարտում է ծրագիրը և դուրս է գալիս ցուցադրման ենթածրագրից: Դրանից հետո մենք t դրոշակը դնում ենք 0-ի, և ամեն ինչ սկսում է կրկնվել: Այստեղ ավարտվում է միկրոպրոցեսորի ծրագրային ալգորիթմը:

7.Ծրագրային ապահովում.

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

• 
  Բարձրորակ ցածր էներգիայի 8-բիթանոց AVR միկրոկոնտրոլեր
• 
  Ընդլայնված RISC ճարտարապետություն

- 130 հրահանգներ, որոնց մեծ մասը կատարվում է մեկ ժամացույցի ցիկլով

32 8-բիթանոց ընդհանուր նշանակության աշխատանքային ռեգիստրներ

Լիովին ստատիկ ճարտարապետություն

Գործողություն մինչև 16 MIPS 16 ՄՀց հաճախականությամբ

Ներկառուցված երկու ցիկլի բազմապատկիչ

• 
  Ոչ անկայուն ծրագիր և տվյալների հիշողություն

- 4KB ներհամակարգային ծրագրավորվող ֆլեշ ծրագրի հիշողություն, որը կարող է դիմակայել 10000 գրելու/ջնջելու ցիկլերին

Օժանդակ բեռնման ծրագրի բաժին անկախ պաշտպանության բիթով

• 
  Ներհամակարգային ծրագրավորում ներկառուցված bootloader ծրագրով
• 
  ծրագրավորման ժամանակ իրական ընթերցման գործառույթ

- 256 բայթ EEPROM, որը կարող է դիմակայել 100,000 գրելու/ջնջելու ցիկլերին

512 բայթ ներկառուցված SRAM հիշողություն (ստատիկ RAM)

Ծրագրավորվող ընթերցանության պաշտպանություն

• 
  Ծայրամասային բնութագրերը

- Երկու 8-բիթանոց ժմչփեր/հաշվիչներ՝ առանձին նախնական մասշտաբով և համեմատական ​​ռեժիմով

Մեկ 16-բիթանոց ժմչփ/հաշվիչ՝ առանձին նախնական մասշտաբով և համեմատելու և նկարահանելու ռեժիմներով

Իրական ժամանակի հաշվիչ առանձին գեներատորով

Հինգ PWM ալիք

6 10-բիթանոց ալիք

2 8-բիթանոց ալիք

6-ալիք ADC PDIP փաթեթի սարքերի համար

4 10-բիթանոց ալիք

2 8-բիթանոց ալիք

Ծրագրավորվող Serial USART

Master/slave SPI ինտերֆեյս

Բայթ-կողմնորոշված ​​սերիական 2-լարային ինտերֆեյս

Ծրագրավորվող պահակային ժմչփ՝ ներկառուցված տատանիչով

Ներկառուցված անալոգային համեմատիչ

Ընդհատեք և արթնացեք, երբ փին վիճակը փոխվում է

• 
  Միկրոկարգավորիչի հատուկ առանձնահատկություններ

- Էլեկտրաէներգիայի միացման վերականգնում և ակնթարթային էներգիայի կորստի դետեկտոր

Ներկառուցված տրամաչափված օսլիլատոր - Արտաքին և ներքին ընդհատման աղբյուրներ

Հինգ ցածր սպառման ռեժիմներ՝ անգործուն ռեժիմ, ADC աղմուկի նվազեցում, էներգիայի խնայողություն, անջատում և սպասման ռեժիմ:

• 
  I/O նավահանգիստներ և բնակարանների ձևավորում

- 23 ծրագրավորվող I/O միացքի գծեր

32 փին TQFP և MFL փաթեթներ

• 
  Մատակարարման լարման միջակայք

- 1,8-ից մինչև 5,5 Վ ATMega48V-ի համար

2,7-ից մինչև 5,5 Վ ATMega48L-ի համար

4,5-ից մինչև 5,5 Վ ATMega48-ի համար

• 
  Տարբեր աշխատանքային ժամացույցի արագության միջակայքեր

- 0-ից մինչև 1 ՄՀց ATMega48V-ի համար

0-ից մինչև 8 ՄՀց ATMega48L-ի համար

0-ից մինչև 16 ՄՀց ATMega48-ի համար

• 
  Ուլտրա ցածր սպառում

- Ակտիվ ռեժիմ.

300 µA 1 ՄՀց և 1,8 Վ սնուցման լարման դեպքում

20 µA 32 կՀց և 1,8 Վ սնուցման լարման դեպքում

Ցածր սպառման ռեժիմ

0,5 մԱ 1,8 Վ սնուցման լարման դեպքում

ATMega48-ը ցածր էներգիայի 8-բիթանոց CMOS միկրոկառավարիչ է՝ AVR RISC ճարտարապետությամբ: Մեկ ցիկլով հրահանգներ կատարելով, ATMega48-ը ձեռք է բերում 1 MIPS-ի կատարում 1 ՄՀց ժամացույցի արագությամբ, ինչը դիզայներին թույլ է տալիս օպտիմալացնել հզորության և արդյունավետության հարաբերակցությունը:

AVR միջուկը ներառում է հարուստ հրահանգների հավաքածու և 32 ընդհանուր նշանակության աշխատանքային ռեգիստրներ: Բոլոր 32 ռեգիստրները ուղղակիորեն կապված են թվաբանական տրամաբանական միավորին (ALU)՝ թույլ տալով մուտք գործել երկու անկախ ռեգիստրներ՝ մեկ հրահանգ կատարելիս: Արդյունքում, այս ճարտարապետությունը թույլ է տալիս տասնյակ անգամ ավելի մեծ կատարողականություն, քան ստանդարտ CISC ճարտարապետությունը:

ATMega48-ն ունի հետևյալ բնութագրերը՝ 4 ԿԲ ներհամակարգային ծրագրավորվող Flash ծրագրի հիշողություն, 256 բայթ EEPROM տվյալների հիշողություն, 512 բայթ SRAM (ստատիկ RAM), 23 ընդհանուր նշանակության I/O գիծ, ​​32 ընդհանուր նշանակության աշխատանքային ռեգիստր, երեք ճկուն ժամանակաչափ։ /համեմատիչ սխեմայով, ներքին և արտաքին ընդհատման աղբյուրներով, սերիական ծրագրավորվող USART, բայթ-կողմնորոշված ​​սերիական 2-լարային ինտերֆեյս, 6 ալիք ADC, որոնցից 4-ը ունեն 10-բիթանոց թույլտվություն, և 2 - 8-բիթանոց թույլատրելիություն, ծրագրավորվող հսկիչ ժամանակաչափ ներկառուցված oscillator-ով, SPI պորտով և հինգ ծրագրային ապահովմամբ, որոնք նախաստորագրված են ցածր սպառման ռեժիմներով: Անգործուն ռեժիմում միջուկը դադարում է, մինչդեռ SRAM-ը, ժամանակաչափերը/հաշվիչները, SPI միացքը և ընդհատման համակարգը շարունակում են գործել: Power-down ռեժիմում ռեգիստրների բովանդակությունը պահպանվում է, բայց հիմնական տատանվողը դադարեցված է, և միկրոպրոցեսորի բոլոր ներքին գործառույթներն անջատված են մինչև ընդհատում կամ սարքաշարի վերակայում: Էներգախնայողության ռեժիմում ասինխրոն ժմչփերը շարունակում են գործել, ինչը թույլ է տալիս հաշվել ժամանակային ընդմիջումները, մինչ միկրոպրոցեսորը քնի ռեժիմում է: ADC Noise Reduction ռեժիմը դադարեցնում է հաշվողական միջուկը և բոլոր I/O մոդուլները, բացառությամբ ասինխրոն ժմչփի և ADC-ի, որը նվազագույնի է հասցնում աղմուկը անալոգային թվային փոխակերպման ժամանակ: Սպասման ռեժիմում հիմնական օքսիլյատորն աշխատում է, մինչ սարքի մնացած մասը պարապ վիճակում է: Սա թույլ է տալիս արագորեն պահպանել սարքերը արագ գործարկելու հնարավորությունը՝ միաժամանակ նվազեցնելով սպառումը:

Սարքը արտադրվել է Atmel-ի բարձր խտության ոչ անկայուն հիշողության տեխնոլոգիայի միջոցով: Ներկառուցված ISP Flash-ը թույլ է տալիս վերածրագրավորել ծրագրի հիշողությունը համակարգում սերիական SPI ինտերֆեյսի միջոցով՝ օգտագործելով bootloader ծրագիր, որն աշխատում է AVR միջուկում կամ սովորական ոչ անկայուն հիշողության ծրագրավորող: Bootloader ծրագիրը ի վիճակի է բեռնել տվյալները միկրոկառավարիչի վրա հասանելի ցանկացած ինտերֆեյսի միջոցով: Ծրագիրը բեռնման հատվածում շարունակում է գործել նույնիսկ այն ժամանակ, երբ հավելվածի հիշողության տարածքը բեռնված է, ապահովելով իրական կարդալու վրա գրելու վարքագիծ: Համատեղելով 8-բիթանոց RISK միջուկը ներքին ծրագրավորվող Flash հիշողության հետ՝ Atmel-ը ATMega48 սարքերը դարձրել է հզոր միկրոկոնտրոլերներ, որոնք ապահովում են ավելի մեծ ճկունություն և ծախսերի արդյունավետություն կառավարման սարքերի լայն շրջանակի համար:

ATMega48-ն աջակցվում է մի շարք ծրագրային ապահովման և ինտեգրված զարգացման գործիքների միջոցով, ինչպիսիք են C կոմպիլյատորները, մակրո հավաքողները, ծրագրային ապահովման վրիպազերծիչները/սիմուլյատորները, ներշղթայական էմուլյատորները և գնահատման փաթեթները:

7.1 ATMega48 փին դասավորություն.

Նկ.7.1. ATmega48 միկրոպրոցեսորային պայմանագրերի գտնվելու վայրը

Նկար 7.1-ում: Միկրոպրոցեսորային կապիչների նպատակը տրված է, բայց մենք կօգտագործենք դրանց միայն մի մասը: Այսպիսով, մենք կազմաձևում ենք ամբողջ B նավահանգիստը ելքի համար և միացնում ենք ցուցումը՝ թվերի իմաստը ցուցադրելու համար: D0-D3 նավահանգիստը նույնպես կազմաձևված է ելքի համար, և մենք դրան միացնում ենք ցուցիչը՝ ցուցիչի չորս ծանոթներին լուսավորելու համար: D4-D5 նավահանգիստի քորոցները կազմաձևված են որպես ելք, և LED-երը միացված են դրան՝ ցուցադրելու առջևի և հետևի կոնտակտների բացումը և հակառակը՝ առջևի կոնտակտները բացելու և հետևի կոնտակտները փակելու համար: C0 պորտի ելքը օգտագործվում է ADC-ի համար: Արտաքին հղման լարման աղբյուրը միացված է AREF փինին, իսկ ֆիլտրի կոնդենսատորը միացված է AVCC փին աղմուկի անձեռնմխելիությունը բարելավելու համար:

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

Ծրագիրը գրելու համար ես կօգտագործեմ ծրագրաշար, որը կոչվում է Algorithm Builder: Բայց նախքան ծրագիրը գրելը, եկեք նայենք այս ծրագրաշարին:

7.2 Ալգորիթմ Builder մշակման միջավայր

Algorithm Builder ծրագիրը գրել է ռուս ծրագրավորող Գենադի Գրոմովը։ Այս միջավայրը ապահովում է զարգացման ամբողջական ցիկլ՝ սկսած ալգորիթմի մուտքագրումից, ներառյալ վրիպազերծումը, և ավարտվում է բյուրեղի ներկառուցված ծրագրավորմամբ: Դուք հնարավորություն կունենաք մշակել ծրագրեր ինչպես ասեմբլերի, այնպես էլ մակրոմակարդակում, որոնցում հնարավոր է աշխատել կամայական երկարության փոփոխվող քանակներով։ Սա ծրագրավորման հնարավորություններն ավելի է մոտեցնում բարձր մակարդակի լեզվին: Դուք կարող եք ներբեռնել Algorithm Builder-ը՝ վերջին տարբերակը, հեղինակի կայքից http://algrom.net/russian.html.

Ի տարբերություն դասական assembler-ի, ծրագիրը մուտքագրվում է ալգորիթմի տեսքով՝ ծառի նման ճյուղավորմամբ և ցուցադրվում հարթության վրա՝ երկու չափսերով։ Պայմանական և անվերապահ անցումների ցանցը գրաֆիկորեն ցուցադրվում է հարմար վեկտորային ձևով: Սա նաև ազատում է ծրագիրը անթիվ պիտակների անուններից, որոնք դասական assembler-ում անխուսափելի բալաստ են: Պարզ է դառնում ծրագրի ողջ տրամաբանական կառուցվածքը.

Ծրագրեր ստեղծելու գրաֆիկական տեխնոլոգիաները նոր հնարավորություններ են բացում ծրագրավորողների համար։ Դրանք թույլ են տալիս հարթության վրա ծրագրեր մուտքագրել ծառի կառուցվածքով ալգորիթմի տեսքով։ Արդյունքում լիովին պարզ է դառնում ծրագրի ողջ տրամաբանական կառուցվածքը։ Նման տեխնոլոգիաների հիմնական նպատակը զարգացման միջերեսը հնարավորինս մոտեցնելն է մարդկային ընկալման բնույթին: Նման միջավայրին տիրապետելը շատ ավելի հեշտ է, քան դասական ասամբլերին տիրապետելը: Ավելի հարմարավետ ինտերֆեյսը բացում է զարգացման նոր հնարավորություններ: Ըստ օգտատերերի՝ ծրագրային ապահովման ստեղծման ժամանակը դասականի համեմատ կրճատվել է 3-ից 5 անգամ

Բրինձ. 7.2.1. Algorithm Builder ծրագրային պատուհան:

Հավաքող.

Շրջակա միջավայրը նախատեսված է Windows 95/98/2000/NT/ME/XP-ով աշխատելու համար:

Խմբագրի բնականոն աշխատանքի համար անհրաժեշտ է «Courier» տառատեսակը:

Նկար 7.2.1-ում: ցույց է տալիս, թե ինչ տեսք ունի «Algorithm Builder» ծրագրի հիմնական վահանակը։

Ալգորիթմի ձևավորում

Ցանկացած ծրագրակազմ կարելի է բաժանել առանձին, տրամաբանորեն ամբողջական մասերի: Որպես կանոն, այս հատվածների վերջնական հայտարարությունն այնպիսի հայտարարություններ են, ինչպիսիք են անվերապահ թռիչքը կամ ենթածրագրից վերադարձը, այսինքն. հայտարարություններ, որոնցից հետո ծրագրի գծային կատարումը հաստատ դադարում է։ Ծրագրային ապահովման մշակումը Algorithm Builder միջավայրում հանգում է նման բլոկների ձևավորմանը՝ դրանք հարթության վրա դնելով և պայմանական և անվերապահ անցումներից նրանց միջև վեկտորային կապեր հաստատելով։

Ալգորիթմի տարրեր

Ալգորիթմ կառուցելու համար Algorithm Builder-ը տրամադրում է յոթ տարր.

ԴԱՇՏ – Դաշտ;

LABEL – Պիտակ;

VERTEX - բլոկի վերին մասը;

ՊԱՅՄԱՆ – Պայմանական անցում;

JMP վեկտոր – Հարաբերական անվերապահ թռիչք;

SETTER – Ծայրամասային սարքի կարգավորում;

TEXT – Տեղական տեքստային խմբագրիչի տող:

Տարր «ԴԱՇՏ» - դաշտ

Ներկայացնում է բլոկ-կենտրոն գիծ: Օբյեկտը նախատեսված է միկրոկառավարիչների մեծամասնությունը գրանցելու համար: Դաշտ ավելացնելու համար ընտրեք կամ «Elements\Field» ցանկի տարրը, կամ սեղմեք գործիքագոտու կոճակը, կամ «Alt+F» ստեղնը կամ «Enter» ստեղնը (եթե կուրսորը գտնվում է տեղական տեքստային խմբագրիչից դուրս) .

Ստորև ներկայացված ալգորիթմի օրինակում «Դաշտ» տարրերը պտտվում են օվալներով:

«LABEL» տարր - պիտակ

Այն ուղղահայաց հարված է, որը գտնվում է հայտարարությունների բլոկի ներսում և կամընտիր անուն, որը գտնվում է հարվածի ձախ կամ աջ կողմում: Պիտակը նախատեսված է ալգորիթմի այն վայրերը նշելու համար, որտեղ հնարավոր են պայմանական և անվերապահ անցումներ: Բլոկին պիտակ ավելացնելու համար ընտրեք «Elements\Label» ցանկի տարրը, սեղմեք «Alt+L» ստեղները կամ գործիքագոտու կոճակը: Անհրաժեշտության դեպքում կարող եք նշանակել ծրագրի կոնկրետ հասցե: Դա անելու համար անունից առաջ (եթե այն գոյություն ունի), պետք է գրել հաստատուն կամ հանրահաշվական արտահայտություն, որը սահմանում է այս հասցեն:

Պիտակի անվան գտնվելու վայրը փոխելու համար սեղմեք «Tab» ստեղնը:

Ստորև բերված օրինակում «Պիտակ» տարրը ուրվագծված է օվալով:

Որպես կանոն, անցումային վեկտորներից մեկը (վերջում սլաքով) պետք է կից լինի պիտակին։ Դրանում

Պետք չէ գործին պիտակին անուն տալ։ Բայց Algorithm Builder-ը թույլ է տալիս դասական անցումային հասցեավորում՝ օգտագործելով պիտակների անունները: Այս դեպքում անհրաժեշտ է պիտակին անուն տալ: Օրինակ:

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

Տարր «VERTEX» - բլոկի վերին մասը

Իր ցուցադրմամբ և նպատակներով այն լիովին նույնական է պիտակի հետ, բայց, ի տարբերություն դրա, այն նշում է

Աշխատանքային հարթության վրա բլոկի գտնվելու վայրը միշտ դրա սկիզբն է: Նոր գագաթ ավելացնելու համար կամ ընտրեք «Elements\Vertex» ցանկի տարրը, կամ սեղմեք «Alt+V» ստեղները, կամ սեղմեք գործիքագոտու վրա գտնվող կոճակը կամ մկնիկի ձախ կոճակը՝ սեղմելով այն պահանջվող վայրի վրա։ աշխատանքային դաշտը «ստեղների» հետ միասին՝ Alt+Ctl+Shift»:

Ստորև բերված օրինակում «Վերտեքս» տարրերը ուրվագծված են օվալներով.

Որպես կանոն, գագաթն անվանվում է միայն այն դեպքում, եթե դա ենթածրագրի կամ մակրոյի սկիզբն է:

«ՊԱՅՄԱՆ» տարր - պայմանական անցում

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

Վեկտորի վերջը կամ պետք է ավարտվի ինչ-որ պիտակի կամ գագաթի վրա, կամ մեկ այլ վեկտորի հատվածի վրա, կամ ունենա հասցեագրված պիտակի անունը:

Վեկտորը ցանկալի վայր տեղափոխելու համար սեղմեք մկնիկի ձախ կոճակը՝ սեղմած պահելով «Alt» ստեղնը: Վեկտորը խմբագրելու համար օգտագործեք ուղղորդող ստեղները «Alt» ստեղնի հետ համատեղ: Պայմանների խմբագրումից վեկտորի անվան խմբագրման անցնելու համար սեղմեք «Tab» ստեղնը: «Tab» ստեղնի հետագա սեղմումները կփոխեն վեկտորի անվան դիրքը: Նոր օբյեկտ մուտքագրելու համար կամ ընտրեք «Elements\Condition» ցանկի տարրը, կամ սեղմեք «Alt+C» ստեղները կամ գործիքագոտու կոճակը:

Ստորև բերված օրինակում «Պայման» տարրերը ուրվագծված են օվալներով.

Տարր «JMP Vector» - անվերապահ ցատկ

Այս տարրը նախատեսված է կարճ անվերապահ ցատկեր իրականացնելու համար (հիմնական assembler-ում սա «RJMP» օպերատորն է): Այն բլոկի կեսից բխող պոլիգիծ է՝ վերջում սլաքով, որը նման է «Պայման» օբյեկտի վեկտորին։ Նոր անվերապահ թռիչք ավելացնելու համար կամ ընտրեք «Elements\JMP Vector» ցանկի տարրը, կամ սեղմեք «Alt+J» ստեղները կամ գործիքագոտու կոճակը:

Ստորև բերված օրինակում «JMP Vector» տարրը ուրվագծվում է տողով:

Տարր «SETTER» - հարմարեցնող

Այս օբյեկտը մոխրագույն ուղղանկյուն է, որի ներսում գրված է միկրոկոնտրոլերի հարմարեցվող ծայրամասային բաղադրիչի անվանումը, ինչպիսին է ժմչփը, ADC, ընդհատման դիմակ ռեգիստրը և այլն: Հարմարեցնողը նախատեսված է միկրոկարգավորիչի գործողությունների հաջորդականություն ձևավորելու համար, որոնք ապահովում են բեռնումը: անհրաժեշտ հաստատունները համապատասխան I/O կառավարման ռեգիստրներում՝ ընտրված հատկություններին համապատասխան:

Այս տարրն օգտագործելուց առաջ պետք է որոշվի միկրոկառավարիչի տեսակը (մենյուի տարր «Ընտրանքներ\Նախագծի ընտրանքներ», ներդիր «Չիպ»)

Ալգորիթմին հարմարեցնող ավելացնելու համար կամ ընտրեք «Elements\Setter» ցանկի տարրը, կամ սեղմեք «Alt+S» ստեղները կամ գործիքագոտու կոճակը: Արդեն մուտքագրված հարմարեցիչը խմբագրելու համար ակտիվացրեք խմբագրիչը՝ կրկնակի սեղմելով կամ օգտագործելով «Shift+Enter» ստեղները:

«Setter» օբյեկտը մակրոօպերատոր է: Կազմելուց հետո այն վերածվում է միկրոկարգավորիչի հրամանների հաջորդականության, որը կապահովի անհրաժեշտ հաստատունների բեռնումը համապատասխան կառավարման ռեգիստրներում: Հարկ է նկատի ունենալ, որ այս գործողություններում կօգտագործվի միջնորդ ռեգիստրը r16:

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

Ստորև բերված օրինակում «Սեթեր» տարրերը ուրվագծված են օվալաձև գծով:

«TEXT» տարրը տեղական տեքստային խմբագրիչի տող է

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

Տողերը նախատեսված են մի շարք կոմպիլյատորների դիրեկտիվների ձայնագրման, ինչպես նաև մեկնաբանությունների համար։ Տեղական տեքստային նոր խմբագրիչ ավելացնելու համար կամ ընտրեք «Elements\Text» ցանկի տարրը, կամ սեղմեք «Alt+T» ստեղները կամ գործիքագոտու կոճակը:

Մեկնաբանությունները պետք է սկսվեն երկու առաջ շեղերով՝ «//»:

Ստորև բերված օրինակում «Տեքստ» տարրերը ուրվագծված են օվալաձև գծով:

Algorithm Builder ծրագրաշարի հիմնական տարրերին ծանոթանալուց հետո մենք կսկսենք ստեղծել ծրագիրը: Նոր նախագիծ ստեղծելու համար ընտրեք «Ֆայլ\Նոր» ցանկի տարրը: Այս դեպքում կհայտնվի առաջին ներդիրը, իսկ աշխատանքային դաշտում դատարկ օպերատորով դրան կցված «TEXT», «VERTEX» տարրը և մեկ տարր «FIELD» (նկ. 7.2.2.) «NOP»:

Բրինձ. 7.2.2. Նոր նախագծի պատուհան.

Հետո սահմանում ենք միկրոպրոցեսորի տեսակը, մեր դեպքում դա ATmega48 է։ Միկրոպրոցեսորի տեսակը սահմանելու համար ընտրեք ցանկի տարրը «Options\Project options...» (Նկար 7.2.3):

Բրինձ. 7.2.3. Ծրագրի ընտրանքների պատուհան:

Այստեղ մենք ընտրում ենք մեր միկրոպրոցեսորը և սեղմում ենք կիրառել կոճակը:

Դրանից հետո գործառնական ալգորիթմի հիման վրա կազմում ենք ծրագիր։ Շնորհիվ այն բանի, որ ծրագիրն այստեղ ներկայացված է ալգորիթմի տեսքով, այն շատ չի տարբերվի արդեն իսկ կազմված և վերը նկարագրված ալգորիթմից։

Դիտարկենք ծրագրի կառուցումը։ Սկզբում դուք պետք է կարգավորեք stack address counter-ը վերջին SRAM բջիջին: Դա հեշտ է անել, դա անելու համար ընտրեք SETTER տարրը, որտեղից հետո ընտրում ենք Stack Point

Ինչ է հայտնվում Control Register Setting պատուհանը (նկ. 7.2.4), որտեղ մենք սահմանել ենք

Բրինձ. 7.2.4 Կույտի կարգավորումների պատուհան:

Ստուգեք վանդակը և սեղմեք Ok կոճակը: Աշխատանքային դաշտում հայտնվում է մոխրագույն ուղղանկյուն SP: Այնուհետև կարգավորում ենք ADC արժեքները, որի համար ընտրում ենք SETTER տարրը, որտեղ ընտրում ենք Analog to Digits Converter (ADC), որից հետո հայտնվում է Control Register Setting պատուհանը (նկ. 7.2.4.), որում կազմաձևված է ADC-ն։ Այստեղ մենք նախադրել ենք CK/128 նախնական սանդղակը: Մենք ընտրում ենք միկրոպրոցեսորային փին, որին կմատակարարենք ADC արժեքը: Այստեղ մենք ընտրում ենք միկրոպրոցեսորի աշխատանքային ռեժիմը ինչի համար

Բրինձ. 7.2.4. ADC տեղադրման պատուհան:

Տեղադրեք AVCC արտաքին կոնդենսատորով AREF փին: Սա ավարտում է ADC-ի կարգավորումը:

Այժմ մենք կարգավորում ենք ժմչփը/հաշվիչը: Կազմաձևելու համար նորից գնում ենք SETTER տարր, որտեղ ընտրում ենք Timer/Counter 0, որից հետո հայտնվում է ժամանակաչափ/հաշվիչի կարգավորումներով պատուհան (նկ. 7.2.5): Այստեղ մենք որոշում ենք CK/1024 prescaler-ի արժեքը և ընտրում դրա գործող ռեժիմներից մեկը: Այս դեպքում մենք ընտրում ենք CTC ռեժիմը, այսինքն՝ զրոյացնել, եթե համընկնում է: Այս ռեժիմում հաշվիչ ռեգիստրը գործում է նաև որպես կանոնավոր ավելացման հաշվիչ, որն ավելանում է clk T 0 ժամացույցի ազդանշանի յուրաքանչյուր զարկերակով: Այնուամենայնիվ, հաշվիչի ռեգիստրի առավելագույն հնարավոր արժեքը և, հետևաբար, հաշվիչի լուծումը որոշվում է OCRO համեմատական ​​ռեգիստրով: Համեմատության ռեգիստրում գրված արժեքին հասնելուց հետո հաշվումը շարունակվում է «00$» արժեքից։ Նույն ազդանշանային ժամացույցի վրա

Բրինձ. 7.2.5. Պատուհան ժմչփի/հաշվիչի կարգավորումներով:

Clk T 0, որտեղ հաշվառման ռեգիստրը զրոյացված է, TIFR ռեգիստրի ընդհատման դրոշը TOV0 է դրված: Մենք գրում ենք 100 արժեքը OCRO ռեգիստրում, որին հասնելուց հետո տեղի կունենա ընդհատում, և ծրագիրը կտեղափոխվի Timer_0_Compare_Match_A պիտակը:

.

Նկար 7.2.6. Ընդհատման կարգավորումների պատուհանը:

Այնուհետև մենք կարգավորում ենք ընդհատումը և ընտրում ենք արտահոսքի ընդհատումը: Դա անելու համար կրկին ընտրեք SETTING տարրը, որտեղ ընտրում ենք Timer/Counter interrupt Mask (TIMSK): Բացվող պատուհանում Timer/Counter դաշտում նշեք Output compare A համընկնման վանդակը (նկ. 7.2.6): Սա ավարտում է ընդհատման կոնֆիգուրացիան: Այժմ մենք կարգավորում ենք մուտքային-ելքային նավահանգիստները, քանի որ մենք պետք է կարգավորենք ամբողջ B պորտը ելքի համար, գրենք 255 արժեքը և սահմանենք այն մեկին: Մենք նաև կարգավորում ենք D պորտը, բայց այստեղ մենք օգտագործում ենք միայն առաջին 6 կապերը D0 - D5, դրա համար մենք դրա մեջ գրում ենք 127 արժեքը: Այնուհետև այս փին սահմանում ենք տրամաբանական 0 արժեքը: Մենք կարգավորում ենք C պորտը որպես մուտքագրում, որի համար մենք դրա մեջ գրում ենք 0: Այստեղ ավարտվում է պորտի կարգավորումների մուտք-ելքը: Այժմ t դրոշակը դնում ենք 0-ի: Այնուհետև դնում ենք ցուցիչի առաջին նշանը, գրում ենք 0-ը n-ով, այնուհետև վերականգնում ենք գումարի արժեքը այս գումարում և գրում 0: Գրելով նաև բաժանարարի արժեքը: 0 in m: Մենք զրոյացնում ենք անձնական chast-ի արժեքը՝ դրա մեջ գրելով 0: Դա անելու համար մենք հնարավորություն ենք տալիս գլոբալ ընդհատումը՝ դնելով i-ի դրոշակը 1-ի վրա: Սա թույլ է տալիս ծրագրին ընդհատել ժամացույցի իմպուլսների որոշակի արժեքից հետո և անցեք ADC կամ ժմչփ/հաշվիչ ենթածրագրին:

Այնուհետև, օգտագործելով LABEL տարրը, մենք սահմանում ենք պիտակը և վերագրում դրա սկիզբը: Այնուհետև, սեղմելով CONDITION տարրը (պայմանական ցատկ) և մուտքագրելով անցման պայմանը ներսում, այս պայմանով t դրոշը կսահմանվի 1: Եթե t դրոշակը հավասար չէ 1-ի, ապա ծրագիրը իջնում ​​է ներքև, այնուհետև անցնում է: JMP Vector տարրը (անվերապահ թռիչք) մենք գնում ենք մեկնարկային պիտակ: Այսպիսով, մենք ստեղծում ենք մի ցիկլ, որի ընթացքում ծրագիրը պտտվում է այնքան ժամանակ, մինչև t դրոշակը սահմանվի 1-ի: Հենց որ t դրոշակը հավասարվի 1-ի, ծրագիրը հեռանում է սլաքի ուղղությամբ: Ստորև բերված է ենթածրագրի մուտքը՝ երկուական թիվը տասնորդական թվի վերածելու համար, որը համապատասխանում է Z_to_Digits մակագրությանը։ Երկուական թիվը տասնորդական թվի վերածելու ենթածրագրի կատարումից հետո, որը մենք կդիտարկենք ստորև, ծրագիրը վերադառնում է Z_to_Digits մակագրությունից հետո, որտեղ t դրոշակում կրկին մուտքագրվում է 0: Այնուհետև նորից ընտրում ենք JMP Vector տարրը և անցնում դեպի մեկնարկային պիտակ.

Այժմ եկեք նայենք ADC-ի ընդհատման ռեժիմին: Անցումը ADC ենթածրագրին իրականացվում է որոշակի ժամանակ անց: Հենց որ ADC-ն չափումներ կատարեց, տվյալները գրեց adcl-ին և adch-ին: Այս երկու գրանցամատյանների տվյալները պետք է գրվեն մեկ այլ ռեգիստրում՝ հետագա փոխակերպման համար: Այս ռեգիստրները կլինեն zl և zh: Մարդահամարի համար կօգտագործենք adcl → zl տողը, համապատասխանաբար, հաջորդ տողը կլինի adch→ zh։ Հետո օգտագործում ենք CONDITION տարրը (պայմանական անցում) t=1 պայմանով։ Այս պայմանը անհրաժեշտ է համարը փոխելն արգելելու համար, մինչև թիվը վերածվի տասնորդական ձևի: Եթե ​​t=0, ապա ծրագիրը գնում է ներքև, որտեղ գրված է x → z տողը, դա նշանակում է, որ z գրանցամատյանում պահվող թիվը կփոխվի միայն թվի ցուցադրումից հետո: Այնուհետեւ օգտագործելով CONDITION տարրը (պայմանական անցում) ստեղծում ենք y պայմանը
Այնուհետև հաշվի առեք y adc_max պայմանը, և եթե պայմանը ճիշտ է, ապա ծրագիրը հետևում է սլաքին: Այնուհետև մենք տեղեկատվություն ենք ուղարկում D.5 և D.4 նավահանգիստներին: Սա գրված է որպես 1 → D.5: Այս մակագրությունը ցույց է տալիս, որ տրամաբանականի արժեքը ցուցադրվում է D.5 պորտի փինում: Հաջորդ տողում 0 → D.4 մենք դուրս ենք բերում տրամաբանական զրոյի արժեքը D.4 պորտին: Այնուհետև ծրագիրը գնում է սլաքի շուրջ: x adc_max պայմանի ստուգում: Այնուհետև երեք տող գրվում է 0 → m, 0 → t, 0 → y իրար հաջորդող։ Դրանցում մենք վերականգնում ենք շահաբաժնի արժեքները (m), t դրոշը և y ռեգիստրի բովանդակությունը, որում պահվում է չափված ADC-ի արժեքը: Այնուհետև մենք նորից գործարկում ենք ADC-ն, որից հետո դուրս ենք գալիս ADC ենթածրագրից: Սա եզրափակում է մուտքային լարման չափման ենթակարգը:

Բաժանման ենթածրագրի մուտքագրումը գտնվում է ADC ենթածրագրում: Ծրագիրը div32_8-ով բաժանման ենթածրագրին անցնելուց հետո հաշվարկվում է բոլոր չափված ADC արժեքների միջին արժեքը: Առաջին հերթին մենք վերականգնում ենք անձնական բովանդակության արժեքը: Դա անելու համար գրեք 0 → chast: Այնուհետև մենք ներկայացնում ենք պայմանը, որտեղ դրոշը C = 1 է: Միավորը կմտցվի C դրոշի մեջ միայն այն բանից հետո, երբ գումարի պարունակությունը փոքր լինի բաժանարարից: Բայց քանի որ C դրոշը դեռ պարունակում է 0, ծրագիրը գնում է ստորև: Ստորև ներկայացված է chast++ տողը, որում մենք մեծացնում ենք գործակիցի արժեքը մեկով: Այնուհետև ADC արժեքների գումարը պարունակող ռեգիստրից հանում ենք բաժանարարի արժեքը։ Այնուհետև, օգտագործելով JMP Vector տարրը (անվերապահ ցատկ), մենք ստեղծում ենք մի օղակ, որը գալիս է նախքան դրոշը C-ն ստուգելու պայմանը: Եվ հենց որ գումարի արժեքը փոքր լինի C դրոշի բաժանարարից, կգրվի մեկը և ծրագիրը կհետևի սլաքին: Այնուհետև մենք վերագրում ենք քանորդի արժեքը x ռեգիստրում: Սա համապատասխանում է → x տողին: Ստորև բերված է մի տող, որում մենք վերականգնում ենք գումարի արժեքը 0 → գումար: Այստեղ ավարտվում է բաժանման ենթածրագրը, և ծրագիրը դուրս է գալիս դրանից՝ հայտնվելով ADC ենթածրագրում div32_8 տողից հետո:

Դիտարկենք ժմչփի ընդհատման ենթածրագր, որում որոշվում է ցուցիչի չորս կետերի լուսավորությունը: Այն բանից հետո, երբ ժամանակաչափից ընդհատում է տեղի ունեցել, և ծրագիրը տեղափոխվել է Timer_0_Compare_Match_A պիտակը, այն սկսում է ստուգել ցուցիչի ծանոթության արժեքի պայմանները: Դա անելու համար օգտագործելով CONDITION տարրը (պայմանական թռիչք) ստուգում ենք n=0 պայմանը և եթե այն ճիշտ է, ապա ծրագիրը շարժվում է սլաքի երկայնքով։ Սրանից հետո D.3 պորտում գրում ենք 0 արժեքը 0 → portd.3 հրամանով։ Այնուհետև ամբողջ գրառման մեջ ցուցադրում ենք digit_0-ում պարունակվող թիվը։Դրա համար գրեք digit_0→ portb։ Եվ մենք գրում ենք մեկ պորտին D.0, որպեսզի վառվի նշման առաջին նշանը, ծրագրում այն ​​նման կլինի 1 → portd.0: Այնուհետև, օգտագործելով JMP Vector տարրը (անվերապահ թռիչք), մենք ցատկում ենք m0 պիտակավորման վրա: m0 պիտակը գալիս է բովանդակության բոլոր պայմաններից հետո՝ n: Այնուհետև մենք մեծացնում ենք n-ի արժեքը, որպեսզի հաջորդ թիվը ցուցադրվի ցուցիչի երկրորդ տեղում: Դրանից հետո մենք դուրս ենք գալիս ժամանակաչափի ենթածրագրից: Հաջորդ անգամ, երբ ժամանակաչափի ընդհատումը տեղի ունենա, ծրագիրը կվերադառնա դրան, բայց կշարունակվի մի փոքր այլ կերպ, քանի որ անհրաժեշտ է տեղեկատվություն ցուցադրել ցուցիչի երկրորդ նշանի վերաբերյալ: Դա տեղի կունենա այն պայմանը ստուգելուց հետո, երբ գրանցամատյանը n-ը պետք է պարունակի միավոր, որը գրվել է առաջին թվանշանից հետո և ավելացնելով n-ի արժեքը մեկով: Քանի որ n-ը պարունակում է մեկ, ծրագիրն ընթանում է ըստ n=1 պայմանի։ Այս պայմանն անցնելուց հետո անհրաժեշտ է անջատել առաջին ծանոթությունը և դրա համար D.0 պորտին գրում ենք զրոյի արժեքը։ Ծրագրում դա համապատասխանում է 0 → portd.0 տողին։ Այնուհետև digit_1-ում պարունակվող թիվը թողարկում ենք ամբողջ պորտին։Դրա համար գրեք digit_1→ portb։ Եվ գրեք մեկը D.1 նավահանգստում, որպեսզի լուսավորվի առաջին ցուցման նշանը, ծրագրում այն ​​նման կլինի 1 → portd.1: Այնուհետև մենք անցնում ենք m0 պիտակի վրա և ավելացնում ենք n-ի արժեքը մեկով, ինչպես նկարագրված է վերևում: Ցուցանիշի երրորդ և չորրորդ թվանշանների ելքը նման է առաջին երկուսի ելքին, սակայն չորրորդ թվանշանի ելքից հետո մենք վերականգնում ենք n ռեգիստրի բովանդակության արժեքը: Դա անելու համար գրեք 0→n: Իսկ t դրոշակի արժեքը սահմանում ենք մեկ, որը ցույց է տալիս թվի ցուցադրման ավարտը։ Դա անելու համար գրեք 1→t. Սա ավարտում է ցուցիչի վրա թվի ցուցադրման ամբողջական ցիկլը:

Մնում է դիտարկել միայն ցուցումների ենթածրագրը, որին անցումը կատարվում է միայն հիմնական ծրագրում t=1 դրոշակի վիճակը ստուգելուց հետո։ Քանի որ t դրոշը պարունակում է մեկը, երբ վերջին թվանշանը ցուցադրվում է ցուցիչի վրա: Պայմանների հարցումների ժամանակ ծրագիրը շարժվում է սլաքի երկայնքով և այնուհետև հասնում է Z_to_Digits-ին, սա պայմանն է ցուցումների ենթածրագրին անցնելու համար: Ծրագիրը հետևում է պիտակին և հայտնվում Z_to_Digits ենթածրագրում: Անցումից հետո առաջին բանը, որ մենք անում ենք, անջատել է գլոբալ ընդհատումը, դրա համար մուտքագրեք 0 արժեքը դրոշի մեջ: Սա գրված է որպես 0→i: Ստորև մենք զրո ենք մուտքագրում ջերմաստիճանի աշխատանքային ռեգիստրում: ծրագրում այն ​​կարծես 0→ջերմ. Այժմ, օգտագործելով CONDITION տարրը, մենք ստեղծում ենք մի պայման, երբ ռեգիստրը Z-ը համեմատվում է 1000-ի հետ և հենց որ Z ռեգիստրի արժեքը փոքր է 1000-ից, ծրագիրը կհետևի սլաքին: Միևնույն ժամանակ, Z ռեգիստրն այլևս չի կատարում պայմանը, և ծրագիրը իջնում ​​է ավելի ցածր: Այստեղ Z ռեգիստրից հանում ենք հազարը և այն գրում որպես Z – 1000: Այնուհետև temp ռեգիստրի արժեքը մեծացնում ենք մեկով: Օգտագործելով JMP Vector տարրը, մենք ստեղծում ենք մի օղակ, որը գալիս է Z ռեգիստրը համեմատելու պայմանից առաջ: Հենց որ պայմանը կատարվում է, և Z ռեգիստրը հազարից պակաս է, ծրագիրը հեռանում է սլաքով: Այժմ մենք վերագրում ենք temp ռեգիստրի բովանդակությունը r0 ռեգիստրում և այժմ այն ​​պահում է հազարավոր թվերի արժեքը: Մուտքը կարծես temp→r0 է: Դրանից հետո մենք զրոյացնում ենք temp ռեգիստրի արժեքը՝ դրա մեջ գրելով 0։Այժմ ծրագիրը կրկնվում է, ինչպես հազարավորները հաշվարկելիս, բայց այժմ անհրաժեշտ է հաշվարկել հարյուրավորների արժեքը։ Կրկին պայման ենք դնում Զ
Ծրագիրը գրելուց հետո այն կարող եք փորձարկել Algorithm Builder ծրագրային միջավայրի տրամադրած սիմուլյատորում։ Սիմուլյատորում ալգորիթմը գործարկելու համար սեղմեք «F9» ստեղնը կամ գործիքագոտու կոճակը:

Այս դեպքում սկզբում տեղի կունենա կոմպիլյացիան, և եթե սխալներ չլինեն, սիմուլյատորը կսկսվի: Միկրոկառավարիչի անհրաժեշտ բաղադրիչի պատուհանների բացումը կատարվում է «Դիտել...» ցանկի տարրի միջոցով: Ներկայացված ալգորիթմի գործընթացները դիտարկելու համար բավական է բացել «Processor», «PortD», «Working registers», «ADC», «Timer/Counter 0» և «Process time #0» պատուհանները (նկ. 7.2): .7).

Նկ.7.2.7.Algorithm Builder simulator-ի Վիո:

Օպերատորի կողքին նշանը ցույց է տալիս ծրագրի հաշվիչի ընթացիկ դիրքը: Պիտակը դրվում է այն հայտարարությունից առաջ, որը պետք է կատարվի հաջորդ քայլում: Գործարկումից անմիջապես հետո այն գտնվում է ծրագրի առաջին քաղվածքում՝ $0000 հասցեում: Երբ սիմուլյատորը սկսվում է, աշխատանքային ռեգիստրների և SRAM-ի բովանդակությունը միշտ լցված է պատահական արժեքներով, քանի որ իրական միկրոկոնտրոլերում դրանց պարունակությունը անկանխատեսելի է հոսանքի կիրառումից հետո: Ալգորիթմի քայլ առ քայլ կատարումը ենթածրագրերի մուտքագրմամբ իրականացվում է «F7» կոճակի կամ գործիքագոտու կոճակի միջոցով: Քայլ առ քայլ կատարում առանց ենթածրագրեր մուտքագրելու՝ օգտագործելով «F8» ստեղնը կամ կոճակը

Նկար 7.2.8 Բյուրեղային ծրագրավորման պատուհան:

Այս ծրագիրը ունի միկրոպրոցեսորը ծրագրավորելու հնարավորություն: Algorithm Builder-ը պարունակում է ներկառուցված ներկառուցված ծրագրավորող, որն ապահովում է միկրոսխեմաների հաջորդական ծրագրավորում: Ընտրելով «Program\Run with Chip» մենյուի տարրը կամ սեղմելով «Ctrl+Shift+F9» ստեղները կամ սեղմելով գործիքագոտու կոճակը, սկսվում է ալգորիթմի կազմումը, և եթե սխալներ չկան, բացվում է ծրագրավորման պատուհանը (Նկար 7.2): .8).

Միկրոպրոցեսորը ծրագրավորվում է COM պորտի միջոցով:

Գրաֆիկական ծրագրավորման միջավայր՝ AVR ճարտարապետությամբ միկրոկառավարիչների համար հավելվածներ մշակելու համար:

Algorithm Builder-ը հզոր գործիք է, որը թույլ է տալիս իրականացնել ծրագրի կոդի ստեղծման և ստուգման ամբողջական ցիկլ: Շրջակա միջավայրը ներառում է՝ գրաֆիկական խմբագիր, միկրոչիպի սիմուլյատոր՝ ալգորիթմը վրիպազերծելու համար, կոմպիլյատոր և ներկառուցված ծրագրավորող՝ չիպի մեջ ծածկագիրը բեռնելու համար: Ծրագիրը Assembler-ի ներքին անալոգն է և հարմար է ինչպես փորձառու մշակողների, այնպես էլ նրանց համար, ովքեր նոր են սկսում տիրապետել սարքի որոնվածը:

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

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

Հիմնական պատուհանը թույլ է տալիս տեղադրել անհրաժեշտ օբյեկտները և փոխել դրանք, տեղադրել, տեղափոխել և այլն, ինչպես ցանկացած գրաֆիկական խմբագրիչում: Էկրանի առանձին հատվածում աղյուսակի տեսքով ձևավորվում է բոլոր հաստատունների և փոփոխականների ցանկով պատուհան՝ դրանով իսկ ազատելով ալգորիթմը լրացուցիչ մուտքերից։ Ծայրամասային սարքերի (UART, SPI, ADC, ժմչփեր) պարամետրերը կարգավորելու համար տրամադրվում է բացվող պատուհանի միջերեսով հատուկ տարր: Կազմողն ինքնուրույն ստեղծում է հրահանգների մի շարք, որոնք ապահովում են ընտրված սարքի գործառնական պարամետրերը: Բացի այդ, աջակցվում է Windows ANSI կոդերի ավտոմատ փոխակերպումը ռուսալեզու ալֆանա-թվային LCD կոդերի: Ծրագիրն աջակցում է միկրոկոնտրոլերների ընտանիքների լայն շրջանակին՝ ATtiny, ATmega, AT90:

Սիմուլյատորը ցույց է տալիս բոլոր փոփոխությունները, որոնք տեղի են ունենում տարբեր ռեգիստրներում, հիշողության բջիջներում և ժամանակաչափերում: Մոդելավորումը կարող է իրականացվել քայլ առ քայլ (գործառույթների մուտքագրմամբ կամ առանց), ընդմիջման կետ կամ ընտրված տարածք:
Ներկառուցված ծրագրավորողը գործարկելու համար անհրաժեշտ է ինքնուրույն հավաքել պարզ ադապտեր, որի միջոցով միկրոկառավարիչը միացված է համակարգչի COM պորտին: Բացի այդ, հնարավոր է միանալ USB միակցիչի միջոցով։ Ծրագրավորողը հաշվում է հիմնական վերածրագրերի քանակը և հաշվիչը պահում է հենց չիպի մեջ:

Մոնիտորինգի վրիպազերծման ռեժիմը միջուկի վրա՝ օգտագործելով մեկ այլ ադապտեր (բոլոր դիագրամները հասանելի են ծրագրային ապահովման փաստաթղթերում) թույլ է տալիս վերահսկել իրական բյուրեղի ներքին վիճակը ցանկացած բեկման կետում: Կարգավորիչի և համակարգչի միջև հաղորդակցության համար օգտագործողի ընտրությամբ հատկացվում է միայն մեկ ելք: Չիպի վրա վրիպազերծումը կիրառվում է ցանկացած տեսակի չիպի վրա, որն ունի SRAM հիշողություն:

Չնայած իր ակնհայտ առավելություններին, Algorithm Builder-ը քիչ հայտնի է սիրողական ռադիո համայնքում: Սա մասամբ պայմանավորված է նրանով, որ մինչև 2010 թվականը տեսողական ծրագրավորման միջավայրը վճարովի էր, անվճար ցուցադրական տարբերակը սահմանափակեց կոդը երկու կիլոբայթով։ Այսօր ծրագրային ապահովումը տարածվում է բացարձակապես ազատ։ Տեղադրված ծրագրով թղթապանակը կարող է պատճենվել այլ մեդիա և աշխատել շարժական: Ծրագրաշարը գալիս է օգտագործողի ձեռնարկով: Հոդվածում քննարկվում են մի շարք պարզ աշխատանքներ և տրամադրվում են ծրագրավորողների դիագրամներ USB և COM պորտերի համար:

«Algorithm Builder» ծրագրի հեղինակները հայրենական ծրագրավորողների խումբ են Նիժնի Նովգորոդից ժողովրդական արհեստավոր Գենադի Լեոնիդովիչ Գրոմովի ղեկավարությամբ: Ծրագիրը շարունակում է զարգանալ մինչ օրս, ավելացվում են նոր գործառույթներ, և գրադարանների փոքր ընտրանին հայտնվել է հեղինակի կայքում:

Algorithm Builder ծրագրի միջերեսը և օգտագործողի ձեռնարկը ներկայացված են ռուսերեն և անգլերեն լեզուներով:

Ծրագիրը համատեղելի է Microsoft Windows 95, 98, 2000, NT, ME, XP, Vista և 7 օպերացիոն համակարգերի հետ:

Ծրագրի բաշխում.անվճար

Հոդվածի նյութերը պատրաստվել են Մոսկվայի պետական ​​արդյունաբերական համալսարանի (GOU MGIU) ավտոմատացման, ինֆորմատիկայի և կառավարման համակարգերի (AIiSU) բաժնում:
(2011 թվականից MGIU-ն կոչվում է Բարձրագույն մասնագիտական ​​կրթության դաշնային պետական ​​բյուջետային ուսումնական հաստատություն «MGIU»):
Հեղինակներ՝ Կրյուկով Ա.Ի., Շուբնիկովա Ի.Ս., Տրոյկով Ս.Մ.

AI&CS վարչությունը ավելի քան 35 տարի է, ինչ վերապատրաստում է մասնագետներ ավտոմոբիլային և օդատիեզերական տեխնոլոգիաների, մեքենաշինության և բիզնեսի էլեկտրոնային, միկրոպրոցեսորային, համակարգչային, ռոբոտային, մեխատրոնիկական և տեղեկատվական կառավարման համակարգերի մշակման և շահագործման ոլորտում: Բաժանմունքի աշխատակիցների գիտահետազոտական ​​աշխատանքն իրականացվում է արհեստական ​​ինտելեկտի տեխնոլոգիաների վրա հիմնված որոշումների աջակցման համակարգերի մշակման, բարդ համակարգերի կառավարման գործընթացների վերլուծության և սինթեզի, սարքավորումների խափանումների մոնիտորինգի և խելացի հայտնաբերման ոլորտներում: Բաժանմունքի գիտական ​​գործունեության կարևոր ուղղությունը տրանսպորտային միջոցների ավտոմատ և էլեկտրոնային համակարգերի ոլորտում հետազոտությունների իրականացումն է։

Atmel MK-ների համար հսկիչ ծրագրեր գրելու համար կան մեծ թվով տարբեր հավելվածներ. դրանք մշակման և կարգաբերման միջավայրեր են ցածր մակարդակի լեզուներով (օրինակ՝ անվճար AVR Studio փաթեթը AVR Assembler լեզվով ծրագրեր մշակելու համար), զարգացման միջավայրեր։ բարձր մակարդակի լեզուներով (օրինակ՝ WinAVR միջավայրը C-ի նման լեզվով ծրագրեր մշակելու համար) և նույնիսկ կա գրաֆիկական ծրագրաշարի մշակման և վրիպազերծման միջավայր, որը կոչվում է «Ալգորիթմ Builder»:

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

Ծրագրային ապահովման մշակումը Algorithm Builder միջավայրում հանգում է նման առաջադրանքների բլոկների ձևավորմանը՝ դրանք հարթության վրա դնելով և պայմանական և անվերապահ անցումներից նրանց միջև կապեր հաստատելով:

Որպեսզի չվերագրեք Algorithm Builder միջավայրի հետ աշխատելու ամբողջ ձեռնարկը, խորհուրդ եմ տալիս ինքներդ կարդալ այն, մանավանդ որ հավելվածը հայրենական արտադրության է և պարունակում է. մանրամասն նկարագրություն ռուսերեն՝ օրինակների հիման վրանրա հետ աշխատելու մասին։ Ելնելով անձնական փորձից՝ մենք կարող ենք վստահորեն ասել, որ այս ձեռնարկը (ի դեպ, հեռու է ծավալուն լինելուց. ընդամենը 20-30 րոպե ուսումնասիրություն) բավական է այս ծրագրային արտադրանքը լիովին հասկանալու և հասկանալու համար:

Դուք կարող եք ներբեռնել Algorithm Builder-ը http://algrom.net/russian.html կայքում: Իսկ վերահսկողական ծրագրի մշակման գործընթացը կարելի է դիտել այստեղ հղում. Այսպիսով, մենք այժմ կներկայացնենք պատրաստի ծրագիրը նկարագրված զարգացման միջավայրում՝ դրա վերաբերյալ մանրամասն մեկնաբանություններով։

Նախ, դուք պետք է ընտրեք բյուրեղի տեսակը (մեր դեպքում՝ Atmega8) Ընտրանքներ/Ծրագրի ընտրանքներ ընտրացանկից և այնտեղ ժամացույցի հաճախականությունը սահմանեք 8,000,000 Հց (8 ՄՀց): Հաջորդը, մենք վերակայում ենք բյուրեղը գործարկման ժամանակ (Elements/Interrupts/Reset): Այնուհետև մենք նախաստորագրում ենք բուրգը՝ ընտրելով Elements/Customer…/Stack Pointer (SP), պատուհանը կբացվի, որի հետ պարզապես անհրաժեշտ է համաձայնվել՝ սեղմելով «OK» (նկ. 2):

Բրինձ. 2. Stack Customizer

Հաջորդ քայլը USART հաղորդիչի սկզբնավորումն է (մի զարմացեք հապավումում «S» տառի հայտնվելով. սա UART-ի ավելի ժամանակակից տարբերակն է, որը նրանից տարբերվում է տվյալների փոխանցման/ստանալու ունակությամբ: միայն ասինխրոն ռեժիմում, բայց նաև համաժամանակյա ռեժիմում)՝ ընտրելով Elements / Customizer ընտրացանկը... /USART: Բացվող պատուհանում (նկ. 3), Receiver բաժնում նշեք Enable (միացնել տվյալների ընդունիչը) և Complete interrupt enable (միացնել ընդհատումները տվյալների ստացման ժամանակ) կողքի վանդակները, ապա նշեք Double Speed-ի կողքի վանդակը: , սահմանեք նիշերի չափը Նիշերի չափը. 8 – բիթ և տվյալների փոխանցման արագությունը սահմանեք Baud Rate = 9615 bps (երբ ընտրեք տվյալների փոխանցման արագությունը ընտրացանկից, դուք պետք է ընտրեք 9600 bps, 9615 bps ստացվում է շնորհիվ: ժամացույցի հաճախականության վերահաշվարկ մինչև 8 ՄՀց):

Բրինձ. 3. USART կոնֆիգուրատոր

Ծրագրի հիմնական մասը բաղկացած կլինի հսկիչ ծածկագրերի ստուգումների հաջորդականությունից (Ցուցակ թիվ 1): Գաղափարն այն է, որ ԱՀ-ն կուղարկի գործողության կոդը UART-ի միջոցով, իսկ MK-ն այն կստանա և կստեղծի համապատասխան հսկիչ գործողություններ օդափոխիչի սայրի և սերվո սկավառակի վրա: Ընդհանուր առմամբ կլինեն երեք այդպիսի կոդ (կարող եք գալ բացարձակապես ցանկացած կոդ).

$31 - միացրեք օդափոխիչի սայրի շարժիչը;

$20 - անջատեք օդափոխիչի սայրը;

$A1 - մուտք դեպի սերվո սկավառակ:

Եթե ​​առաջին երկու կոդերի հետ ամեն ինչ պարզ է, ապա երրորդի դեպքում դա այնքան էլ պարզ չէ. $A1-ը միայն սերվո սկավառակ մուտք գործելու հրաման է, ապա դուք պետք է ստանաք ռոտացիայի անկյան կոդը: Փորձնականորեն պարզվեց, որ այն տատանվում է $05AF-ից մինչև $154F: Ավելին, մենք կուղարկենք համակարգչից և, համապատասխանաբար, կստանանք MK-ից՝ սկսած ցածր բայթից։ Մենք նաև կանջատենք USART-ի միջոցով տվյալների ստացման ընդհատումները հրամանի կատարման ընթացքում, հակառակ դեպքում դա կարող է տվյալների «խառնաշփոթ» լինել:

Ցուցակ թիվ 1

Թիվ 2 ցուցակը ցույց է տալիս հետաձգման ենթածրագրի կոդը (Delay): Ժամանակի ուշացումը անհրաժեշտ է հրամանի ճշգրիտ և ամբողջական մշակման համար և ձևավորվում է N ցիկլերի համար ծրագիրը շրջելով (փորձության և սխալի միջոցով մենք հաշվարկել ենք, որ մեր դեպքում ցիկլերի ամենահաջող թիվը 84FF է տասնվեցական թվային համակարգում):

Ցուցակ թիվ 2

UART-ի միջոցով տվյալների ստացման ավարտը առաջացնում է USART_Receive_Complete ընդհատում (եթե այն ներկայումս անջատված չէ ծրագրի հիմնական մասում), որը կարող է սահմանվել կոդում Elements/Interrupts/USART_Receive_Complete մենյուի միջոցով: Բեռնարկիչի մարմնում դուք պետք է պահպանեք դրա մեջ օգտագործվող բոլոր ռեգիստրները կույտի վրա, իսկ մշակողի վերջում դրանք վերականգնեք կույտից: Նաև այս մշակիչում կարող եք ստանալ կարգավիճակի բայթը (UCSRA գրանցամատյան)՝ տվյալների սխալների համար ստուգելու համար և, իհարկե, ինքնին տվյալները UDR ռեգիստրից (Ցուցակ թիվ 3):

Թիվ 3 ցուցակ

Սերվո-շարժիչի պտտման անկյունը կախված է նրան մատակարարվող իմպուլսի լայնությունից՝ ժամանակաշրջանը հաստատուն պահելով (ժամկետը 20 մվ է, իսկ հսկիչ զարկերակի տևողությունը՝ 0,8-ից 2,2 մվ, չնայած տարբեր սերվոների համար այս արժեքները կարող է փոքր-ինչ տարբերվել) դրա համար մեզ անհրաժեշտ է ենթածրագր. servo drive-ի պտտման անկյուն (Ցուցակ թիվ 4): Կառավարման զարկերակային ժամանակը և դադարի ժամանակը կսահմանվեն հետաձգման ենթածրագրի նման: Ինչպես վերևում գրեցինք, փորձնականորեն 8 ՄՀց բյուրեղային հաճախականության համար մենք որոշեցինք, որ իմպուլսի ժամանակը նշված է ծածկագրով $05AF-ից մինչև $154F միջակայքում: Այսպիսով, իմանալով ամբողջ ժամանակահատվածի ժամանակը` $9E3C (նաև որոշվում է փորձարարական եղանակով), մենք կարող ենք հաշվարկել դադարի ժամանակը որպես ժամանակահատվածի և զարկերակի տեւողության տարբերություն: Մնում է միայն մշակել զարկերակային ժամանակը և դադարի ժամանակը հաջորդականությամբ, ինչպես հետաձգման ենթածրագրին, ապա կրկնել նման ազդանշանը մի քանի անգամ (մեր դեպքում մենք կրկնել ենք ազդանշանը $10 անգամ, այսինքն՝ 16 անգամ տասնորդական նշագրման համակարգում։ )

Թիվ 4 ցուցակ

Կառավարման ծրագրի կոդը գրելուց (ալգորիթմը նկարելուց) հետո անհրաժեշտ է այն կոմպիլացնել և բռնկել միկրոկոնտրոլերի մեջ։ Ծրագիրը կարելի է կազմել՝ սեղմելով Ctrl+F9 կամ Program/Compile մենյուի միջոցով: Եթե ​​կոմպիլյացիան հաջող է, տեղեկատվական պատուհան կհայտնվի, որում նշված կլինի MK-ի զբաղված հիշողության քանակը:

Այնուհետև անհրաժեշտ է կոմպիլյացիայի արդյունքը (*.hex ընդլայնումով ֆայլ առանց «EE_» նախածանցի սկզբում, որը գտնվում է ծրագրի աղբյուրի նույն թղթապանակում) կարգավորիչի մեջ: Դա կարելի է անել՝ օգտագործելով անվճար AvrProg կոմունալ ծրագիրը, որը ներառված է նաև անվճար AVR Studio փաթեթում: Այն կարող եք ներբեռնել mymcu.ru կայքից կամ atmel.com-ից (անգլերեն կայք):

Բացի MK որոնվածը թարթելու կոմունալից, ձեզ անհրաժեշտ կլինի նաև ծրագրավորող: Դուք կարող եք կամ գնել այն (պարզ տարբերակները համեմատաբար էժան են), կամ զոդել ինքներդ:

Բրինձ. 4. LPT ծրագրավորողի միացում

Ամենապարզը, որը ես գիտեմ, LPT ծրագրավորողն է, բայց դրա համար անհրաժեշտ կլինի LPT պորտ համակարգչի վրա, որն այս պահին հազվադեպ է դառնում: Ծրագրավորողի գաղափարը պարզ է և բաղկացած է LPT պորտը ISP ինտերֆեյսին և վերահսկիչի Reset գծին ուղղակիորեն միացնելուց (նկ. 4):

Ինքնակազմակերպման համար ծրագրավորողի մեկ այլ տարբերակ USB ծրագրավորողն է (գծապատկերը ցույց է տրված նկ. 5-ում), այն, իհարկե, ավելի բարդ է, բայց ապագայում կարող է շատ ավելի հարմար լինել: Այնուամենայնիվ, կա մեկ «բայց»՝ այն հավաքելու համար ձեզ դեռ պետք է LPT ծրագրավորող, թեև միայն մեկ անգամ: FUSE-ի բիթերը թարթելու համար անհրաժեշտ կլինի ինքն իրեն թարթել ծրագրավորողի կառավարման կարգավորիչը: Անհրաժեշտ է, որ SPIEN, CKOPT և SUT0 բիթերը ծրագրավորված լինեն (սահմանված է «0»): Սովորաբար գործարանից եկող MK-ները, այսինքն. նորերն արդեն ծրագրավորել են SPIEN բիթը: Ցանկալի է (բայց ոչ անհրաժեշտ) ծրագրավորել (սահմանել «0») BODEN բիթը: Մնացած բիթերը պետք է չծրագրավորված լինեն (սահմանված է «1»): Սա կարող է պահանջել Codevision AVR V2.03.4 հավելվածը: USB ծրագրավորողի հավաքման մանրամասն նկարագրությունը կարող եք կարդալ այստեղ: