Թվային տվյալներ ուղարկեք մեկ Arduino- ից մյուսին ՝ 16 քայլ

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

Ներածություն

Դեյվիդ Պալմերի կողմից, CDIO Tech. Աստոն համալսարանում:

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

Դուք կարող եք հեշտությամբ ստուգել, որ այն աշխատում է ՝ պարզապես մուտքագրելով մի շարք թվեր, որոնք պետք է ուղարկեք Serial Monitor տերմինալում և տեսեք, որ թվերը դուրս են գալիս երկրորդ Arduino- ին միացված երկրորդ Սերիական մոնիտորի վրա: Դուք նույնիսկ կարող եք օգտագործել Bluetooth հղում:

Ինչ է դա անում

Երկու Arduino ծրագիր (էսքիզները խոսում են Arduino- ում) մշակման կարիք ունեն, մեկը `Master ծրագիրը` Arduino Serial Monitor- ով աշխատող ընդունիչ համակարգչին միանալու համար, մեկը `որպես Ստրուկ` Վարպետից սերիական հաղորդագրություն ստանալու, վերծանման և հետ ուղարկելու համար: Ստրուկն ընտրովի կարող է ցուցադրել այն թվերը, որոնցով նա զբաղվում է IDE- ի երկրորդ սերիական մոնիտորի վրա `այն դեպքում, եթե ցանկանում եք դա օգտագործել: Դա կարող է օգնել, որ գործերն ի սկզբանե աշխատեն, և կօգնի ձեզ, եթե որոշեք որևէ փոփոխություն կատարել ձեր պահանջներին համապատասխանող ծրագրերում:

Սարքավորումներ

• 2 Արդուինոյի
• 2 USB կապ
• կարկատել լարերը (ըստ պահանջի)
• 1 համակարգիչ/նոթբուք բեռնված Arduino IDE- ով (հասանելի է որպես անվճար ներբեռնում Arduino.cc կայքից)

Քայլ 1: Կարգավորում - Նախ տեղադրեք ձեր սարքավորումները

Միացրեք 2 Arduinos- ը ձեր համակարգչի 2 USB պորտին:

Հուշում, լավ գաղափար է դրանք նշել M և S (վարպետ և ստրուկ), որպեսզի հետագայում խառնաշփոթի մեջ չընկնեք (ինչպես ցույց է տրված այստեղ ներկայացված 2 լուսանկարներում):

Քայլ 2: Կարգավորում - Կարգավորեք ձեր էկրանը

Ամենալավն այն է, որ ձեր էկրանը կարգավորեք այնպես, որ այն ունենաք

• IDE- ն բեռնված է Master ծրագրով ձախ կողմում և
• որ Ստրուկի հետ աջ կողմում:

Պահեք Maser- ի և Slave- ի սերիական մոնիտորները ձախ և աջ, ինչպես ցույց է տրված այստեղ նկարահանված էկրանին:

Քայլ 3. Կարգավորեք հիմնական ավարտը, այնուհետև միացեք միասին - մաս 1

Երբ դուք ստեղծում եք ձեր Master End Serial Monitor- ը երկու համար ուղարկելու համար, դուք միշտ պետք է օգտագործեք սկզբի և վերջի սահմանազատման նիշերը և ստորակետի բաժանարար նիշը, ինչպես տեսնում եք այստեղ:

Այժմ դուք պետք է միացնեք 2 Arduino- ի սերիան: Դա արվում է երկու կարկատված լարերով:

Ես օգտագործել եմ կանաչը և դեղինը

• Նախ վերցրեք դեղինը, սա պետք է միանա D6- ին մեկ Arduino- ում և D7- ում `երկրորդում
• Այնուհետև կանաչ մետաղալարերի համար հակառակը ՝ D7 առաջինի և D6 երկրորդ Arduino- ի վրա:

Որպես այլընտրանք, եթե ունեք Bluetooth- ի մոդուլների նման մի բան, ինչպես HC -05- ը, դրանք նույնպես կաշխատեն ձեզ տալ նույն ազդեցությունը, ինչ վերևի լարերը:

Քայլ 4. Կարգավորեք հիմնական ավարտը, այնուհետև միացեք միասին - մաս 2

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

Դուք կարող եք տեսնել, որ այն կոչված է ծրագրերից որևէ մեկի 7-րդ տողում: Այն կարգավորում է թվային 7 և 6 կապում որպես TX և RX (փոխանցել և ստանալ): Այսպես են տվյալները Master Arduino- ից դուրս գալիս կանաչ մետաղալարով դեպի Slave, և, երբ երկրորդ Arduino- ի Slave ծրագիրը կավարտի իր աշխատանքը, նորից դեղին մետաղալարով: Նույն պատկերազարդի ներքևում (Սերիական մոնիտորի պատուհանում) կարող եք տեսնել, որ մեր փոխանցած տվյալները այժմ հաջողությամբ անցել են այստեղ նկարագրված օղակի շուրջ և վերադառնալ ԱՀ, քանի որ զույգ ամբողջ թվաքանակը լավ առանձնացվել է:

Քայլ 5. Էսքիզների / ծրագրերի ակնարկ. Ructureրագրի կառուցվածքը

Դասավորություն Ինչպես Arduino- ի էսքիզներում, կա 3 հիմնական մաս.

• Հռչակագրերը
• Կարգավորումը
• Հիմնական հանգույց

Ինչպես հաճախ է պատահում, մենք այստեղ օգտագործել ենք 4 -րդ բաժինը, որը «Գործառույթներ» հավելումն է: Եթե դուք ծանոթ չեք Գործառույթների օգտագործմանը, կարող եք Google- ում գտնել «Arduino գործառույթները», և դուք կգտնեք բացատրական կայքեր, ինչպես օրինակ այս հղումը ՝ www.tutorialspoint.com/arduino/arduino_functions…..

Մենք նաև օգտագործել ենք ներդիրներ ՝ ծրագիրը ավելի կառավարելի բլոկների բաժանելու համար:

Մեր օգտագործած երեք բլոկները կարելի է տեսնել վերևում գտնվող IDE պատուհանների յուրաքանչյուր նկարազարդման վերևում.

• simpleRxTx0330 Վարպետ
• սովորական
• նշումներ

Սրանք իրականում առանձին ֆայլեր են ծրագրի թղթապանակի ներսում, ինչպես կարող եք տեսնել Slave ծրագրի ֆայլերի այս Windows Explorer- ի տեսքում:

Շատ լավ պատճառ կա, թե ինչու ենք մենք դա արել:

• Երբ մենք կառուցում էինք ծրագիրը, մենք հասկացանք, որ Վարպետի ծրագրի մեծ մասը նույնն էր, ինչ Ստրուկի համար:
• Մենք վերջացրեցինք բոլոր ընդհանուր մասերը ներդիրի մեջ, որը, հետևաբար, անվանեցինք «ընդհանուր», և այնուհետև ամեն անգամ, երբ մի մաս կարգաբերում էինք (փորձարկեցինք և բավարարվեցինք, որ այն լավ աշխատեց) մենք պարզապես պատճենեցինք և տեղադրեցինք այդ ամբողջ ներդիրը: Վարպետից մինչև ստրուկ, կամ հակառակը:
• Նշումների ներդիրները նույնպես պատահաբար նույնական են, քանի որ դիզայնը ընդհանուր է:

Գործառույթներից ոչ մեկը չի կոչվում setup- ից, դրանք բոլորը կոչվում են loop- ից, այնպես որ մենք դրանք ստեղծել ենք setup- ից հետո, բայց loop- ից առաջ:

Քայլ 6: Վերևից ներքև ձևավորում:

Լավ գաղափար է ձևավորել ձեր ուրվագիծը ՝ սկսած այն բանից, թե ինչ եք ուզում անել:

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

Սա հետևում է դիզայնի լավ փիլիսոփայությանը, որը ուսուցանվում է բազմաթիվ ԲՈՀ -երում և կոչվում է CDIO (Եթե դուք դեռ չգիտեք այս մեկը, կարող եք Google- ում որոնել այն և գտնել այն բացատրող կայքեր, ինչպիսիք են ՝ https://www.cdio.org/s): Սա հիմնականում ասում է. Մի սկսեք դիզայնը, նախքան հասկացությունը հասկանալը: Մի սկսեք իրականացումը, մինչև հստակ չստանաք Դիզայնը: Մի ակնկալեք, որ այն կգործի մինչև Իրականացման հստակեցումը: C սկզբում, այնուհետև D, I և O: Յուրաքանչյուր հաջորդ փուլում դուք կրկնում եք (վերադառնալ օղակի (երի) շուրջ, այնպես որ, երբ գոհ մնաք ձեր Նախնական Դիզայնի օղակից հետ և ստուգեք, որ այն դեռ համապատասխանում է Հայեցակարգին և թարմացրեք եթե անհրաժեշտ է. և այլն, այնպես որ, նույնիսկ երբ գործի անցնեք, գնացեք ամբողջ ճանապարհը դեպի վերև և կրկին տեսեք, թե ինչպես է այժմ C- ն, ապա D- ն և ես, և պատրաստեք և ստուգեք բոլորը անհրաժեշտության դեպքում փոխվում է: mingրագրավորման էսքիզներով սա նույն կերպ է աշխատում, եթե նախագծում եք վերև-ներքև:

Քայլ 7. Հայեցակարգ և ձևավորում - մաս 1

Հայեցակարգն այստեղ նման է «նշումների» ներդիրում նշված ուրվագծային պահանջներին »:

Դիզայնը կարող է նման լինել օղակի վաղ տարբերակին, որը համընկնում է նշումների ներդիրի հետ և կարող է նման լինել այն, ինչ տեսնում եք այս նկարում

Տեսեք, թե ինչպես եմ սիրում սկսել CTRL-C- ի մեկնաբանությունները, առաջին հերթին, օղակի գլխում պատճենելով, այնուհետև սկսել դատարկ տեղերը լրացնել այն հրամաններով, որոնք կանեն այդ գործողությունները:

Սա իրականում հավաքում է OK, ինչպես կարող եք տեսնել նկարի էկրանի ներքևում: Դա հասնում է CDIO D փուլից մինչև I, և ծածկագիրը մշակելիս լավ գաղափար է շարունակել այս D-I օղակի շուրջը:

Հիմա ժամանակն է անցնել հաջորդ փուլ, այնտեղ կա մեկնաբանություն, որն ասում է, որ մենք // // ինչ -որ բան կստանանք ապարատային USB- ից, այնուհետև մենք դա կփոխանցենք ծրագրային ապահովման սերիալային ալիքին: Մենք գրում ենք այս կոդը, որպեսզի դա տեղի ունենա. 133 -ից 138 -րդ տողերը ներկայացված են այստեղ ՝ դեղին լուսարձակով

Քայլ 8. Հայեցակարգ և ձևավորում - Մաս 2

Երկու առաջին երկու գործառույթները, որոնք մենք ներկայացնում ենք այստեղ ՝

Բացի դրանցից, մենք ավելացրել ենք թեստ ՝ newData կոչվող գլոբալ փոփոխականի վրա: Սա դրոշ է, որը մենք կսահմանենք «void recv ();» գործառույթի ներսում: Երբ հաղորդագրություն է ստացվում, այս փոփոխականը նշվում է կեղծից ճշմարիտ: Մենք դա անում ենք այնպես, որ մենք հաղորդագրություն ենք փոխանցում միայն այն դեպքում, երբ մեկը ստացվել է (դրոշ == ճշմարիտ) 134 տողում: Եվ երբ մենք փոխանցել ենք մեր հաղորդագրությունը, «աշխատանքն ավարտված է», այնպես որ մենք դրոշը կրկին մաքրում ենք կեղծ 137 տողում:

Կրկին մենք կարող ենք ստուգել compile (D- ից I), և այս անգամ մենք ունենք «չհայտարարված» սխալի հաղորդագրություն (ցուցադրված է): Սա մեզ ասում է, որ մենք չենք հայտարարել recv (); գործառույթը: Մենք նախատեսում ենք դա անել ավելի ուշ, ուստի հենց հիմա, որպեսզի թույլ տանք մեզ ստանալ մաքուր կոմպիլյացիա, մենք պետք է ստեղծենք կեղծ կամ տեղապահ գործառույթ, ինչպես ցույց է տրված հաջորդում:

Կրկին մենք կարող ենք ստուգել compile (D- ից I), և այս անգամ մենք ունենք մեկ այլ «չհայտարարված» սխալի հաղորդագրություն tran (); գործառույթը: Սա նմանատիպ խրթին ստեղծման կարիք ունի: Կրկին մենք կարող ենք ստուգել compile (D- ից I), և այս անգամ մենք կգտնենք, որ սա հիանալի է աշխատում. մինչ այժմ այնքան լավ:

Քայլ 9. Ավարտեք հիմնական հանգույցը

Այս հատվածն ավարտելու համար մենք ավելացրել ենք մեկ վերջին կտոր, որը պետք է ավելացնել վրիպազերծման կոդ:

Էսքիզների կարգաբերման վերաբերյալ կա մեկ այլ հրահանգ, որին կարող են վերաբերվել ՝ հասկանալու համար, թե ինչ ենք մենք արել այստեղ և ինչու: Դիտեք «Ինչպես ստեղծել և փորձարկել Arduino էսքիզները մինչև դրանք աշխատելը» հրահանգը:

Այսպիսով, վրիպազերծման այս տողերը [ցուցադրված են 136-139-ը] հաջորդաբար ավելացվում են հիմնական օղակում և, ահա, ահա, դրանք կարող եք ստուգել Գլխավոր վերջում ՝ դարձնելով վրիպազերծման փոփոխականը ճշմարիտ, և Կազմելով (I), ապա եթե դուք միացնում եք Arduino- ն, կարող եք վերբեռնել, բացել Սերիայի մոնիտորը և տեսնել, թե արդյոք այն, ինչ վերադառնում է Սերիական մոնիտորին, ինչպես ցույց է տրված այստեղ (տեսնու՞մ եք «DEBUG MODE» հաղորդագրությունը ավելացված է):

Քայլ 10. Ստրուկ Arduino- ում տվյալների ստացում և վարում

Ստանալով ստրուկ Արդուինոյից

Երկրորդ ալիքի համար անհրաժեշտ ծածկագիրը ավելացրեք հիմնական հանգույցին ՝ ծրագրային ապահովման սերիական ընդունիչին, ինչպես ցույց է տրված ՝ տողեր 149 -ից 155 -ը:

Կարո՞ղ եք տեսնել, որ կառույցը թույլ է հիմնված այն բանի վրա, ինչ մենք վերը գրեցինք Master գործի համար:

Նաև կտեսնեք, որ մենք ստանում ենք կազմողի սխալ, ևս մեկ չհայտարարված գործառույթ `այս անգամ parseData (); - Այսպիսով, մենք պետք է անպայման անենք նաև դրա համար, նախքան մենք կարողանանք գործարկել անթերի փորձնական կոմպիլյացիա:

Տվյալների մշակումը Slave Arduino- ում

Ավելացրեք Arduino- ի համար պահանջվող հիմնական հանգույցի կոդը, եթե այն կազմաձևված է որպես Slave սարք, ինչպես ցույց է տրված ՝ տողեր 163 -ից 174 -ը: Կարո՞ղ եք տեսնել, որ դրա կառուցվածքը շատ նման է առաջին ալիքին:

Եվ դուք պետք է գտնեք, որ այս անգամ այն կազմվում է բացարձակապես լավ:

Քայլ 11: Գրեք ստացման գործառույթը

Ստանալու գործառույթը `void recv (char from) {} - ունի երկու հիմնական աշխատանք:

1 ՝ USB ալիքից մի շարք նիշ ստանալու համար, և

2 Arduino- ից Arduino ալիքից մեկը ստանալու համար:

Առաջինի համար մենք պետք է օգտագործենք, քանի որ այն օգտագործում է Arduino- ի ներկառուցված սարքավորում UART, իսկ երկրորդի համար `ստանդարտ Arduino գրադարան` ծրագրային UART:

Երբ մենք սկսում ենք կոդ ավելացնել գործառույթին. Ստեղծել մի գործառույթ, որն ինչ -որ բան անում է, ոչ թե պարզապես անջրպետի փոխարեն, մենք պետք է հիշենք, որ հեռացնենք կամ մեկնաբանենք այն փոխարինող անիվը: Հակառակ դեպքում մենք ստանում ենք կազմման սխալ ՝ «void lrec (char)» հղում:

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

Սկսեք մի գործառույթից, որը նման է նրան, ինչ մենք ցույց ենք տալիս 75 -ից 88 -րդ տողերում դեղին գույնով:

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

Այժմ եկեք նայենք մեր գրած ծածկագրին ՝ recv () գործառույթի համար:

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

«Sw» մասի և «hw» մասի ծածկագիրը նույն ձևն է, և ես այն նկարագրելու եմ այստեղ:

Caseույգ տողերից առաջինը յուրաքանչյուր դեպքում մի որոշ ժամանակաշրջանի սկիզբն է: Եթե ծանոթ չեք ժամանակի հետ, կարող եք այն փնտրել Arduino.cc/Reference կայքում ՝ բացատրության և օրինակների համար: Այստեղ մենք սպասում ենք 'մինչ' ներկառուցված 'Սերիալ' գործառույթը չի ստացել որևէ կերպար (ներ) և քանի որ newData փոփոխականն անջատված է (այսինքն. NewData == կեղծ պայմանը ճիշտ է): Հենց որ բնավորությունը կամ մեկից ավելի կերպարներ ստանան, միևնույն ժամանակ «կընկնի» այս զույգի երկրորդ տողում: Այնուհետև կկոչվի recAstringChar (char); գործառույթ ՝ ընթացիկ նիշը կարգավորելու համար: Այս զույգ տողերն այնուհետև կփոխվեն, քանի դեռ (կամ այնքան ժամանակ) կան դեռևս պահանջվող նիշեր: Երբ դրանք բոլորը կատարվեն, միևնույն ժամանակ պետությունն ավարտվում է ՝ թույլ տալով, որ հաջորդ մակարդակը ավարտվի, և իր հերթին թույլ տա rec (char); գործառույթը ավարտել: Այսպիսով, ամբողջ հաղորդագրությունն այժմ ստացվել է:

Քայլ 12: Գրեք Ստացման ենթաֆունկցիան `մաս 1

Այժմ մենք պետք է գրենք recAstringChar (char) կոչվող գործառույթը;. Այստեղ դուք տեսնում եք դրա վերևում գտնվող 50 տողի մեկնաբանությունից, որի նպատակն է թարմացնել երկու բուֆեր `մուտքային սերիական հաղորդագրության պատճեններով: [Պարզվեց, երբ փորձում էի այս ամենը գործի դնել, մի բան, որ ես սովորեցի, այն էր, որ ինձ պետք էին երկու տարբեր բուֆերներ, կամ գոնե դա որոշ խնդիրներ լուծելու ամենահեշտ միջոցն էր, հետևաբար այն որոշ չափով վերածվեց 2 բուֆերի կարիք ունենալու, այնպես որ Ես նոր եմ պատրաստել դրանք:

Բուֆերները գլոբալ փոփոխականներ են, ուստի դրանք հայտարարված են մոդուլի մակարդակով, տե՛ս ընդհանուր ներդիրի 9 -րդ և 10 -րդ տողերը: Այս ֆունկցիայի ներսում հայտարարված են այլ փոփոխականներ, որոնք, հետևաբար, ունեն տեղական ընդգրկույթ `այստեղ ներկայացված 51-54 տողերում: Սա այն վայրը չէ, որտեղ կարելի է բացատրել գլոբալների և տեղացիների միջև եղած տարբերությունները, բայց դրա մասին ավելի շատ տեղեկություններ կան https://www.arduino.cc/glossary/hy/ Տեղական և Գլոբալ բաժնում:

Կարող եք նաև ամեն ինչ իմանալ տվյալների տեսակների և տիպի փոփոխիչների մասին ՝ ստատիկ, բուլյան, բայտ, կոնստրուկտոր, նշան ՝ https://www.arduino.cc/reference/en/#variables- ում, որոնք ներկայացված են այստեղ:

Այս գործառույթի հիմնական ծրագրի հոսքը վերահսկվում է այստեղ 56 -րդ տողում, իսկ դրա համապատասխան այլը `74 -րդ տողում: Սա վերաբերում է երկու սցենարի

ա) [74 -րդ տողից], երբ ստացված հաղորդագրությունը սկսվում է: Դա տեղի է ունենում, երբ startMarker- ը նկատվում է. Սա սահմանվում է որպես «<» նիշ, այդ իսկ պատճառով, երբ էսքիզը փորձարկում ենք, մենք միշտ սկսում ենք մեր տողը այդ բնույթով: Եթե դա չանենք, ոչինչ չի մշակվի ստացվածի պես, ամեն ինչ անտեսվելու է այնպես, կարծես մենք անհեթեթություններ ենք մուտքագրում «Սերիական մոնիտոր» ստեղնաշարի հուշման մեջ:

բ) [56 -ից 73 -րդ տողերը], որը ստանում է բոլոր մյուս նիշերը, անկախ նրանից, թե դրանք ինչպիսին են, բայց դրանք վերաբերում են միայն վավեր սկիզբը լրանալուց հետո (a '>' ստացվել է ինչպես վերևում a):)

Այս տողերում (74 -ից 78 -ը) մենք ստացված <-ը դնում ենք բուֆերներից մեկի մեջ (ստացված տվյալները [0]), բայց ոչ մյուսում: Մենք կարգավորում ենք բուֆերային ցուցիչը (փոփոխական ՝ char ndx) ՝ դեպի հաջորդ պահեստային բուֆերային դիրքը (ստացվածՏվյալներ [1]) ՝ օգտագործելով ndx ++ տողում հետբարձրացման հրամանը (++);, և ընթացքի մեջ գտնվող դրոշակը սահմանեցինք ճշմարիտ:

Functionրագրի հոսքը գործառույթի այս հատվածում վերահսկվում է if այստեղ 57 տողում, և դրա համապատասխան այլը `65 տողում: Սա վերաբերում է երկու սցենարի

ա) [65 -րդ տողից], երբ ստացված հաղորդագրությունն ավարտվում է: Դա տեղի է ունենում, երբ endMarker- ը նկատվում է `սահմանվում է որպես>, այդ իսկ պատճառով, երբ մենք փորձում ենք մեր ուրվագիծը, մենք միշտ ավարտում ենք մեր տողը այդ բնույթով: Վերջնական նիշը ստանալիս տեղի ունեցող բաներից մեկն այն է, որ գլոբալ դրոշը (տեխնիկապես փոփոխական) newData- ն ճշմարիտ է այնպես, ինչպես գործառույթը ավարտվում է, այնպես որ այն գործառույթը, որը կոչում էր մեր ենթաֆունկցիան (կանչող գործառույթ. Recv (char);) կարող է «իմանալ», որ վավերական նոր տվյալները ստացվել են ամբողջական:

բ) [տողեր 57 -ից 64 -ը], որը ստանում է մյուս բոլոր նիշերը, ինչպիսին էլ որ դրանք լինեն: Ուղղակի զբաղվածությամբ դրանք կոկիկ կերպով շարում է երկու բուֆերներում:

Քայլ 13. Գրեք Ստացման ենթաֆունկցիան - Մաս 2

Կարող է օգնել օրինակ բերել, թե ինչպիսին են 2 բուֆերները, երբ դրանք բնակեցված են: Եթե մենք մուտքագրենք enter- ը, ապա բուֆերները կունենան դրանցում ցուցադրված նիշերը.

Այսպիսով, այժմ դուք կարող եք տեսնել, որ մենք ունենք մեկ բուֆեր, որը բոլորովին նույն նիշերն են, ինչ մենք առաջին անգամ մուտքագրել էինք, և մեկ բուֆեր, որն ընդամենը երկու արժեք և մեկ բաժանող ստորակետ ունի: Այժմ մենք ունենք ինչ-որ կոդ, որը կարող է ստանալ նիշերը, որոնք մենք մուտքագրում ենք Serial Monitor ստեղնաշարի վրա, կարող ենք CDIO I փուլից տեղափոխվել O, մուտքագրելով որոշ տողեր և տեսնել, թե ինչ է տեղի ունենում: Վերբեռնեք ծածկագիրը Master Arduino- ում, բացեք Սերիայի մոնիտորը և փորձեք մուտքագրել ինչ -որ վավերական բան, օրինակ ՝ enter: Դուք ստանում եք արձագանք Serial Monitor- ի էկրանին, ինչպիսին է այստեղ ցուցադրվածը:

Քայլ 14. Գրեք փոխանցման և վերլուծման գործառույթները

Նախ ՝ Հաղորդման համար

Այսպիսով, այժմ մենք ստացել ենք տող, կարող ենք գրել փոխանցման գործառույթը. Tran (char); փոխարինելու իր կոճղը: Սա թույլ կտա մեզ տող ուղարկել Վարպետից Ստրուկ Արդուինոյին, այնպես որ համոզվեք, որ երկու սարքերն էլ միացված են և միացված են այս նոր գործառույթը ստուգելու համար:

Մուտքագրեք այս գործառույթը, ինչպես ցույց է տրված այստեղ 117 -ից 133 -րդ տողերում: Ինչպես կճանաչեք, այն ունի երկու մաս ՝ մեկը USB ալիքին փոխանցելու համար (ապարատային UART) և մեկը փոխանցելու մյուս Arduino- ին (ծրագրային UART.) Սա պետք է սխալ կազմի: -անվճար, և դուք կարող եք անմիջապես վերբեռնել ուրվագիծը և տեսնել, թե ինչ է տեղի ունենում: Այս անգամ ես կուղարկեմ: Դուք ստանում եք ցուցադրված արդյունքը:

Էկրանի նկարահանումը հետաքրքիր է, քանի որ Ստացված տողը… պետք է ճիշտ տեսք ունենա նախկինի պես, և Փոխանցվող տողը… այժմ պետք է ճիշտ տեսք ունենա: Այնուամենայնիվ, նշեք, որ Ամբողջ թվաքանակի փոխարկումը չի աշխատել: Դեռևս պետք է ավելացնել մի փոքր ավելի շատ ծածկագիր ՝ այդ աշխատանքը կատարելու համար:

Քայլ 15. Գրեք փոխանցման և վերլուծման գործառույթները

Հետո Parse- ի համար

Սա կոդի մի կտոր է, որը վերլուծում է ստացված տողը ՝ թվային մասնակի տողերը դուրս բերելու համար և դրանք վերածում է ամբողջ արժեքների: Դա դատարկ parseData () է; հիմնական հանգույցի գործառույթը

Փոխարինեք վերլուծական կոճակը 98 - 113 տողերում ցուցադրված ծածկագրով: Վերբեռնեք այն և տեսնենք, արդյոք այն խնդիրը, որը մենք ունեինք 2 ամբողջ արժեքների հետ, այժմ շտկված է: Արի փորձենք.

Այո, այն աշխատում է, ինչպես ցույց է տրված, գտնված ամբողջ թվերն են 49 և 98:

Քայլ 16: Եզրափակիչ:

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