Wallace - DIY ինքնավար ռոբոտ - Մաս 5 - Ավելացնել IMU ՝ 9 քայլ

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

Մենք շարունակում ենք Ուոլասի հետ միասին: Ուոլլաս անունը ծագել է «Wall-E»-ի և նախորդ նախագծից (ձայնի ճանաչում), և օգտագործելով «espeak» կոմունալը, այն հնչում էր մի փոքր բրիտանական: Եվ ինչպես սպասարկու կամ մատուցող: Եվ դա վերջնական նպատակն է. Որպեսզի այս նախագիծը վերածվի օգտակար բանի: Այսպիսով «Ուոլասը»:

Ուոլեսը կարող է շրջել, կարող է խուսափել խոչընդոտներից ՝ օգտագործելով IR հեռավորության սենսորներ (վերջերս, ինչ -որ կերպ նրանք տապակվեցին (?) ժամանակը, MCP23017 ընդլայնիչի հետ միասին) և, ի վերջո, կարող է հայտնաբերել շարժիչի հոսանքի փոփոխությունները `իմանալու, թե երբ է այն բախվել ինչ-որ բանի:

Բացի սենսորներից, Ուոլասը «հիշում է» 100 քայլերը և որոշակի տարրական վերլուծություն ունի շարժումների պատմության միջոցով:

Մինչ այժմ Ուոլեսի նպատակը պարզապես փորձել շարունակել առաջ շարժվելը և իմանալ, թե երբ է այն խրված ինչ -որ կրկնվող ձևի մեջ (օրինակ ՝ անկյունում) և իրականում առաջ չի շարժվում:

Ես անցել եմ շարժման և նավարկության մի քանի կրկնություններ, և հետևողական գլխացավը պտտման ժամանակ է եղել:

Քանի որ Ուոլասը հետագծված ռոբոտ է, և ես ուզում էի ծրագրաշարում ամեն ինչ ավելի պարզ պահել (հետագայում), որպեսզի շրջվի, ես պարզապես պետք է առանցքը/պտտեցնեմ տեղում: Այսպիսով, շարժիչներին կիրառեք հավասար, բայց հակառակ հզորություն / աշխատանքային ցիկլ:

Առաջացած խնդիրը կապված է Agent 390 ռոբոտային հարթակի նախագծման հետ: Հետագծի գոտիները հակված են շփվել կողքերին: Եվ ավելի վատ, մի կողմը դա անում է ավելին, քան մյուսը:

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

Իրական խնդիրը հատակին պտտվելիս է:

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

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

Եվ այսպես, վերը նշված բացատրությունը դրդեց այս Հրահանգին:

Սկզբում ես ուզում էի հրաժարվել կամ հետաձգել շարժման զգացողության (IMU) ներդրումը, քանի որ դրանք Ա) բարդ են, Բ) աղմկոտ, Գ) ժամանակի ընթացքում սխալները կարող են ներդրվել և այլն, և այլն: այն, որ մենք կարող էինք շատ լավ անել ՝ առաջ անցնելով թռիչքի ժամանակի IR լազերային տվիչներից: Եվ մենք կարող էինք ՝ օգտագործելով լազերներ, որոնք կարող էինք իմանալ ՝ ռոբոտը պտտվե՞լ է, թե՞ ոչ ՝ հետևելով հեռավորության փոփոխություններին:

Իրականում, մենք նույնպես կարող էինք (մի տեսակ) դա անել հիմա ՝ ձայնային տվիչներով:

Այնուամենայնիվ, այդ ամենը շատ անուղղակի, բարդ միջոց է ՝ պատասխանելու մեկ պարզ հարցի ՝ «մենք պտտվե՞լ ենք, թե՞ ոչ»:

Ինձ թվում էր, որ ToF լազերային սենսորներից օգտվելն ինձ կտանի ծրագրակազմի հաջորդ մակարդակին. մասնավորապես, SLAM (միաժամանակ տեղայնացում և քարտեզագրում): Ես դեռ պատրաստ չէի այնտեղ գնալ:

Լավ է, որ ռոբոտների նախագիծն իրականացվի շերտերով, առաջին (ստորին) շերտերն ավելի պարզ լինեն, իսկ վերջին (վերին) շերտերը `ավելի վերացական և լուծեն ավելի բարդ խնդիրներ:

Շերտերի մասին կարելի է մտածել այսպես.

1. ռոբոտի ֆիզիկական շրջանակ / մեխանիկական կառուցվածքային հիմք
2. տարրական շարժիչային համակարգ (ազնվամորի, Roboclaw, շարժիչներ, մալուխներ և այլն, հիմնական ծրագրակազմ, ստեղնաշարի վրա հիմնված)
3. էական միացում ՝ սենսորներին աջակցելու համար (երկկողմանի լարման փոխարկիչ, նավահանգստի ընդլայնիչ, E-Stop, էներգիայի բաշխում և այլն)
4. խոչընդոտներից խուսափելու տվիչներ (ակուստիկ, IR)
5. հիմնական, հիմնական դիրքի և շարժման հայտնաբերում (արագացուցիչ, գիրո, մագնիսաչափ, շարժիչային կոդավորիչներ, անիվների կոդավորիչներ)

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

Վերոնշյալ ցանկը կարող է քիչ թե շատ քարտեզագրվել ծրագրային ապահովման այս հայեցակարգային շերտերին:

• SLAM (միաժամանակ տեղայնացում և քարտեզագրում)
• Շարժման վերահսկում և իրազեկում, պտույտ
• Հիմնական խոչընդոտներից խուսափելը
• Սենսորային տվյալների վերահսկում և հայտնաբերում
• Հիմնական շարժում առաջ, հետ, ձախ և աջ, արագացնել, դանդաղեցնել, կանգ առնել

Ինչպես տեսնում եք, այս ցուցակի համար առաջին կետերը կլինեն վերին, ավելի բարդ շերտերը, որոնք լուծում են ավելի վերացական հարցեր և հարցեր, ինչպիսիք են «որտեղ եմ ես» և «ուր եմ գնում», մինչդեռ վերջին կետերը կլինեն ցածր ծրագրային շերտեր, որոնք կարգավորում են «ինչպես խոսել/լսել սենսոր A- ին» կամ «ինչպես շարժել այս անիվը»:

Հիմա, ես չեմ ասում, որ երբ սկսում ես շերտից, դու այն կավարտես, և այն հաջորդ շերտի վրա է ՝ երբեք չվերադառնալով նախորդին: Ռոբոտային նախագիծը կարող է շատ նման լինել ծրագրակազմի մշակման արդիական, կրկնվող մեթոդներին (արագաշարժ, SCRUM և այլն):

Ես պարզապես ասում եմ ՝ ժամանակ հատկացնել յուրաքանչյուրին: Դուք պետք է հավասարակշռեք, թե որքանով պետք է անեք յուրաքանչյուրը, և որոշեք, թե ինչ եք փորձում որոշակի շերտով, որը արժի ժամանակ և դժվարություն:

Կա որոշակի «հակամարտություն» կամ «լարվածություն» երկու մրցակից գաղափարների կամ ուղղությունների միջև:

Մեկն այն է, ինչ ես կանվանեի «plug-n-play» ՝ խնդիրը A լուծելու համար:

Մյուսը DIY է (ինքներդ դա արեք): Եվ դա կարող է նույնիսկ լավագույն պիտակը չլինել այս մյուս գաղափարի համար:

Ահա յուրաքանչյուրի օրինակ, հուսով եմ, որ կտեսնեք լարվածությունը կամ հակամարտությունը երկու ընտրությունների միջև:

Այս օրինակի համար եկեք համախմբենք SLAM- ը, խոչընդոտներից խուսափելը և հիմնական հիմնական շարժումը `որպես մեկ խնդիր, որը պետք է լուծել միևնույն ժամանակ:

1. Եթե որոշենք գնալ plug-n-play երթուղով, մենք անմիջապես (կախված բյուջեից) ցատկում ենք այնպիսի բաների վրա, ինչպիսիք են վերևում տեղադրված պտտվող լազերները, կամ դաշտի խորության տեսախցիկը, կամ ToF լազերները և IMU- ն (սրա թեման Հրահանգելի):
2. Եթե մենք, ընդհակառակը, ցանկանում ենք գնալ երկրորդ ճանապարհով, կարող ենք փորձել հնարավոր բոլոր տեղեկությունները քաղել որոշ ակուստիկ սենսորներից կամ IR սենսորներից, կամ ընդհանրապես ոչ մի տվիչ, մենք պարզապես օգտագործում ենք շարժիչի հոսանքի մոնիտորինգ (հարված)

Ի՞նչ կարելի է ասել թիվ 1 -ի և #2 -ի մասին: Մի բան կլիներ, որ մենք շատ ավելին կսովորեինք ՝ կատարելով թիվ 2 -ը: Աշխատելու համար միայն ակուստիկ տվիչներ ունենալու սահմանափակումները մեզ ստիպում են մտածել ավելի շատ հարցերի մասին:

Մյուս կողմից, եթե մենք շատ կենտրոնացած ենք թիվ 2 -ի միջոցով բաներ անելու վրա, մենք կարող ենք ժամանակ կորցնել, քանի որ ակուստիկ տվիչներից պահանջում ենք ավելին, քան պետք է:

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

Ինչևէ, վերը նշված բոլորը պարզապես մտածելու տեղիք էին տալիս:

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

Այսպիսով, այս Instructable - IMU- ն:

Նպատակն այն է, որ եթե IMU- ն ասում է, որ ռոբոտը չի պտտվում, մենք կբարձրացնենք աշխատանքային ցիկլը: Եթե մենք շատ արագ ենք պտտվում, մենք նվազեցնում ենք աշխատանքային ցիկլը:

Քայլ 1: IMU սենսոր

Եվ այսպես, Ուոլասին ավելացնելու մեր հաջորդ սենսորը IMU- ն է: Որոշ հետազոտություններից հետո ես լուծում էի MPU6050- ը: Բայց հետո, այս պահին, MPU9050- ը (և նույնիսկ վերջերս ՝ MPU9250- ը) նույնիսկ ավելի լավ գաղափար էր թվում:

Իմ աղբյուրը եղել է Amazon- ը (ԱՄՆ-ում): Այսպիսով, ես պատվիրեցի նրանցից երկուսը:

Այն, ինչ ես իրականում ստացա (կարծես թե դրա վրա վերահսկողություն չկա. Ահա այն, ինչ ինձ դուր չի գալիս Amazon- ում) երկու MPU92/65 էին: Մի փոքր զարմանում եմ նշանակման մասին: Նայեք պատկերներին; կարծես «ընտանեկան» նշանակում է: Ամեն դեպքում, դա այն է, ինչ ես խրված եմ:

Ավելացնելը շատ պարզ է. Վերցրեք միացնող հետքերով նախատախտակ, սենսորը կպցրեք տախտակին, ավելացրեք 10 -պտուտակավոր պտուտակային տերմինալային բլոկ (ես իմը ստացել եմ Pololu- ից):

Որպեսզի նվազագույնի հասցվի ցանկացած միջամտություն, ես փորձեցի այդ սենսորները հեռու պահել ամեն ինչից:

Դա նշանակում էր նաև օգտագործել որոշ նեյլոնե պտուտակներ/ընկույզներ:

Ես պատրաստվում եմ օգտագործել I2C արձանագրությունը: Հուսանք, որ մետաղալարերի ընդհանուր երկարությունը շատ վատ չի լինի:

Այլուր շատ տեղեկություններ կան հիմնական միացումների և լարման մակարդակների մասին և այլն, ուստի ես դա չեմ կրկնի այստեղ:

Քայլ 2: Իրերը միշտ չէ, որ մաքուր են, հեշտ

Այս գրառման ընթացքում, կարծես, շատ բան չկա այս կոնկրետ MPU-92/65- ի համար: Այն, ինչ առկա է, ինչպես սենսորների մեծամասնության դեպքում, կարծես Arduino- ի օրինակներ են:

Ես փորձում եմ այս Հրահանգները մի փոքր այլ կերպ դարձնել ՝ ներկայացնելով ոչ այնքան մաքուր գործընթաց, քանի որ միշտ չէ, որ ամեն ինչ անմիջապես աշխատում է:

Ենթադրում եմ, որ այս հրահանգները ավելի շատ նման են բլոգի, քան ուղիղ A-B-C, 1-2-3 «այսպես ես անում»:

Քայլ 3: Նախնական փորձարկում

Նախորդ քայլի պատկերներից կարմիր և սև լարերը դեպի սենսորներ, իհարկե, VCC (5V) և GND են: Կանաչ և դեղին լարերը I2C միացումներն են:

Եթե դուք կատարել եք այլ I2C նախագծեր կամ հետևել եք այս շարքերին, ապա դուք արդեն գիտեք «i2cdetect» - ի մասին, և դա առաջին քայլն է իմանալու, թե արդյոք ազնվամորին կարող է տեսնել նոր սենսորը:

Ինչպես տեսնում եք այս քայլի պատկերներից, մեր առաջին փորձը անհաջող էր: IMU- ն չի հայտնվում (պետք է լինի սարքի id 0x68):

Այնուամենայնիվ, լավ նորությունն այն է, որ I2C ավտոբուսը գործում է: Մենք տեսնում ենք մեկ սարք 0x20, և դա MCP23017 նավահանգստի ընդլայնիչն է (ներկայումս պատասխանատու է HCSR04 ձայնային տվիչների համար):

Պատկերում հեշտ չէ տեսնել, բայց ես միացրեցի նույն գույնի կանաչ և դեղին լարերը IMU- ից MCP23017- ին (տես նկարի ներքևի ձախ կողմը)

Մենք ստիպված կլինենք որոշ անսարքություններ լուծել:

Քայլ 4: Խնդիրների վերացում

Օգտագործելով վոլտմետրի վրա անընդմեջ կարգավորումը (այն բարձր հնչերանգով), ես փորձարկեցի VCC (5V), GND, SDA և SCL միացումները: Դրանք լավն էին:

Հաջորդ փորձը MCP23017- ի անջատումն էր I2C ավտոբուսից `ավտոբուսում թողնելով միայն MPU-92/65-ը: Դա ապարդյուն դարձավ - «i2cdetect» - ն այնուհետև սարքեր ցույց չտվեց:

Այսպիսով, հաջորդը, ես անջատեցի սենսորը տոտեմ բևեռից և այն նորից միացրեցի ուղիղ 5V-3V երկկողմանի ավտոբուսին. այսինքն ՝ ուղիղ ազնվամորի: (ավելի կարճ լարեր):

Եվ վոյլա: Այս անգամ կա հաջողություն: Մենք տեսնում ենք, որ 0x68- ը հայտնվում է «i2cdetect» - ի միջոցով:

Բայց մենք դեռ չգիտենք, թե ինչու է այս անգամ աշխատել: Կարո՞ղ է դա լարերի երկարությունը լինել: Նախորդ տեղը?

Նշում. Որևէ տարբերություն չուներ ՝ ADO- ն հիմնավորված էր, թե ոչ: Կարող է լինել ինքնաթիռի քաշման և ներքևի դիմադրողներ: Նույնը կարող է լինել FSYNC- ի դեպքում:

Հաջորդը, ես նորից միացրեցի MCP23017- ը: Այսպիսով, այժմ մենք ունենք երկու սարք I2C ավտոբուսում: (տես նկարը): Հաջողություն, մենք այժմ տեսնում ենք ինչպես 0x20, այնպես էլ 0x68 i2cdetect- ով:

Տեսանյութերը մի փոքր ավելի շատ են ներկայացնում այն, ինչ տեղի ունեցավ անսարքությունների վերացման ընթացքում:

Քայլ 5: Կարդացեք սենսորի տվյալները

Տարբեր մոտեցումներ

Ես որոշեցի մի քանի մոտեցում ցուցաբերել սենսորից օգտակար տեղեկություններ ստանալու համար: Ահա դրանք ՝ ոչ մի հերթականությամբ.

1. փորձեք մի քանի հիմնական ծրագրավորում
2. դիտեք գրանցամատյանների վերաբերյալ որոշ առցանց փաստաթղթեր
3. նայեք ուրիշների օրինակներին և / կամ կոդին

Ինչու՞ այս մոտեցումները: Ինչու՞ պարզապես չփնտրել գոյություն ունեցող գրադարան կամ ծածկագիր:

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

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

Օրինակ, github- ում MPU9250- ի համար C ++ ծածկագիրը դիտելուց հետո հասկացա, որ դա ինձ ստիպում է օգտագործել ընդհատումներ, ինչը դեռ չեմ ցանկանում անել:

Բացի այդ, այն գալիս է լրացուցիչ իրերի հետ, ինչպիսիք են տրամաչափումը. կրկին, մի բան, որն ինձ դեռ չի հետաքրքրում:

Կարող է պատահել, որ այն, ինչ ես պետք է անեմ պարզ հարցին պատասխանելու համար `« ռոբոտը պտտվում է այո կամ ոչ », կարող էր շատ պարզ պատասխանվել` պարզապես գրանցամատյաններ կարդալիս:

Գրանցամատյաններ

Այս գրության ժամանակ, կարծես, այս սենսորի վրա շատ բան չկա: Իրականում, եթե դուք նայեք այս Instructable- ի հետ եկած պատկերներին և մանրակրկիտ նայեք իրական չիպերի մակագրություններին, ապա ինձ հետաքրքրում է, թե արդյոք սա նոկ-օֆ չէ: Ես տեսածս ոչինչ չեմ կապում Invense- ի հետ: Անկախ ամեն ինչից, ես ընտրեցի գրանցամատյանում եղած մոդելների տվյալները ՝ MPU-6050 և MPU-9250:

Երկու դեպքում էլ երկուսի դեպքում էլ հետևյալը նույնն է: Եվ սկսնակների համար, մենք ենթադրում ենք, որ դա նույնը կլինի նաև այս MPU-92/65-ի համար:

59 -ից 64 - արագացուցիչի չափումներ

65, 66 - ջերմաստիճանի չափումներ 67 - 72 - գիրոսկոպ չափումներ 73 - 96 - արտաքին տվիչների տվյալներ

Նշում. MPU-6050- ը, կարծես, Մագնիսաչափ չունի, մինչդեռ MPU-9250- ը (և մենք ենթադրում ենք, որ սա նույնպես) ունի մեկը:

Որոշ ավելի հետաքրքիր, հուսանք օգտակար տեղեկություններ, որոնք հավաքվել են գրանցամատյանից:

Magnetometer Info:

magnetometer id: 0x48 գրանցում է 00 -ից մինչև 09: 00H WIA 0 1 0 0 1 0 0 0 01H INFO INFO7 INFO6 INFO5 INFO4 INFO3 INFO2 INFO1 INFO0 02H ST1 0 0 0 0 0 0 0 DOR DRDY 03H HXL HX7 HX6 HXHXHXHXHXHX HX5 HX4 HX4 HXH HX15 HX14 HX13 HX12 HX11 HX10 HX9 HX8 05H HYL HY7 HY6 HY5 HY4 HY3 HY2 HY1 HY0 06H HYH HY15 HY14 HY13 HY12 HY11 HY10 HY9 HY8 07Z HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ HZ ST2 0 0 0 BITM HOFL 0 0 0 յուրաքանչյուր ռեգիստր նշանակում է, թե ինչ է նշանակում. HXL [7: 0]. X առանցքի չափման տվյալները ցածր 8 բիթ HXH [15: 8]: X առանցքի չափման տվյալներ ավելի բարձր 8 բիթ HYL [7: 0]: Y առանցքի չափման տվյալներ ավելի ցածր 8 բիթ HYH [15: 8]: Y առանցքի չափման տվյալներ ավելի բարձր 8 բիթ HZL [7: 0]: Z առանցքի չափման տվյալներ ցածր 8 բիթ HZH [15: 8] ՝ Z առանցքի չափման տվյալներ ավելի բարձր 8 բիթ

Ծրագրավորում

Գրանցամատյանների փաստաթղթերից մեկ այլ տեղեկություն այն է, որ թվում էր, թե ընդամենը մոտ 100 գրանցամատյան կա: Այսպիսով, մեկ մարտավարություն կարող է լինել գրել մի պարզ ծրագիր, որը մուտք է գործում սարքին (0x68) և փորձում է կարդալ մի շարք գրանցամատյաններ հաջորդաբար ՝ առանց դրանց նշանակության հաշվի առնելու, պարզապես տեսնել, թե ինչ տվյալներ կարելի է տեսնել:

Եվ հետո, կատարեք հաջորդական փոխանցումներ ՝ օգտագործելով նույն ծածկագիրը և համեմատեք տվյալները մեկ անցումից ընդդեմ հաջորդի:

Գաղափարն այն է, որ մենք, հավանաբար, կարող ենք վերացնել ցանկացած գրանցամատյան, որը կարծես տվյալներ չունի (զրո կամ FF) կամ որոնք բացարձակապես երբեք չեն փոխվում, և մենք կարող ենք կենտրոնանալ նաև փոփոխվողների վրա:

Այնուհետև, մեկը, որը մենք դիտարկում ենք միայն այն փոփոխվողները, ավելացնում ենք միջինացված ֆունկցիան, որը միջինում գրանցում է այդ գրանցամատյանի վերջին N ընթերցումները ՝ տեսնելու համար, թե իրականում կա՞ արդյոք այդ գրանցիչի որոշակի կայուն արժեք: Սա ենթադրում է, որ մենք սենսորը պահում ենք շատ անշարժ և նույն տեղում:

Ի վերջո, մենք կարող ենք նրբորեն փորձել սենսորով այնպիսի բաներ, ինչպիսիք են այն սեղմելը (արագացուցիչ, գիրո), կամ դրա վրա փչելը (ջերմաստիճան), կամ պտտելը (նախորդ երկու գումարած մագնիսաչափ) և տեսնել, թե դա ինչ ազդեցություն է ունենում արժեքների վրա:

Ես սիրում եմ հնարավորինս օգտագործել wiringPi գրադարանը: Այն ունի աջակցություն I2C- ի համար:

Առաջին վազք.

/********************************************************************************

* կառուցել. gcc first.test.mpu9265.c -o first.test.mpu9265 -lwiringPi * * գործարկել ՝ sudo./first.test.mpu9265 * * այս ծրագիրը պարզապես մի շարք (հնարավոր) գրանցամատյաններ է թողարկում MCP23017- ից, * և այնուհետև MPU9265- ից (կամ որևէ այլ պրոցեսորից այդ 0x68 հասցեով) * * ես այն օգտագործեցի վավերացնելու համար, եթե նույնիսկ կարող էի կարդալ սենսորից, քանի որ ես արդեն * վստահություն ունեի MCP23017- ի նկատմամբ: *********************************************** ***************************/ #include #include #include #include #include int main (int argc, char ** argv) {դնում («Եկեք տեսնենք, թե ինչ է ասում MCP23017 @ 0x20- ը.»); errno = 0; int deviceId1 = 0x20; int fd1 = wiringPiI2CSetup (deviceId1); եթե (-1 == fd1) {fprintf (stderr, "Չհաջողվի բացել էլեկտրագծերի Pi I2C սարքը. %s / n", strerror (ernno)); վերադարձ 1; } համար (int reg = 0; reg <300; reg ++) {fprintf (stderr, "%d", wiringPiI2CReadReg8 (fd1, reg)); fflush (stderr); ուշացում (10); } դնում (""); դնում («Եկեք տեսնենք, թե ինչ է ասում MPU9265 @ 0x20- ը.»); errno = 0; int deviceId2 = 0x68; int fd2 = էլեկտրագծերի տեղադրումPiI2CSetup (deviceId2); եթե (-1 == fd2) {fprintf (stderr, "Չհաջողվի բացել էլեկտրագծերի Pi I2C սարքը. %s / n", strerror (ernno)); վերադարձ 1; } (int reg = 0; reg <300; reg ++) {fprintf (stderr, "%d", wiringPiI2CReadReg8 (fd2, reg)); fflush (stderr); ուշացում (10); } դնում (""); վերադարձ 0; }

Երկրորդ վազքը.

/********************************************************************************

* կառուցելու համար. gcc second.test.mpu9265.c -o second.test.mpu9265 -lwiringPi * * գործարկելու համար ՝ sudo./second.test.mpu9265 * * Այս ծրագիրը կարդացված արժեքի կողքին թողարկում է գրանցման համարը: * * Սա օգտակար է դարձնում արդյունքի ֆայլը խողովակավորելը (վերահղելը), այնուհետև * համեմատելու համար կարելի է մի քանի գործարկել: Այն կարող է որոշակի պատկերացում կազմել * թե որ գրանցամատյանը կարևոր է, և թե ինչպես կարող են տվյալները վարվել: ********************************************** *************************** # #ներառել #ներառել #ներառել #ներառել #ներառել #ներառել հիմնականը (int argc, char ** argv) {int deviceId = -1; եթե (0) {} այլ դեպքում (!! strncmp (argv [1], "0x20", strlen ("0x20"))) {deviceId = 0x20; } else if (! strncmp (argv [1], "0x68", strlen ("0x68"))) {deviceId = 0x68; } else if (! strncmp (argv [1], "0x69", strlen ("0x69"))) {deviceId = 0x69; } դնում («Եկեք տեսնենք, թե ինչ է ուզում ասել MPU9265 @ 0x20:"); errno = 0; int fd = wiringPiI2CSetup (deviceId); եթե (-1 == fd) {fprintf (stderr, "Չհաջողվի բացել էլեկտրագծերի Pi I2C սարքը. %s / n", strerror (ernno)); վերադարձ 1; } (int reg = 0; reg <300; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); ուշացում (10); } վերադարձ 0; }

Երրորդ վազք.

/********************************************************************************

* կառուցել. gcc third.test.mpu9265.c -o third.test.mpu9265 -lwiringPi * * գործարկել ՝ sudo./third.test.mpu9265 * * Այս ծրագիրը երկրորդի արդյունքն է: Այն կարդում է միայն * գրանցամատյաններից, որոնք ցույց էին տալիս տարբերություն մեկ վազքի և հաջորդի միջև:********************************************** *************************** # #ներառել #ներառել #ներառել #ներառել #ներառել #ներառել հիմնականը (int argc, char ** argv) {int deviceId = -1; եթե (0) {} այլ դեպքում (!! strncmp (argv [1], "0x68", strlen ("0x68"))) {deviceId = 0x68; } else if (! strncmp (argv [1], "0x69", strlen ("0x69"))) {deviceId = 0x69; } դնում («Եկեք տեսնենք, թե ինչ է ուզում ասել MPU9265 @ 0x20:"); errno = 0; int fd = wiringPiI2CSetup (deviceId); եթե (-1 == fd) {fprintf (stderr, "Չհաջողվի բացել էլեկտրագծերի Pi I2C սարքը. %s / n", strerror (ernno)); վերադարձ 1; } համար (int reg = 61; reg <= 73; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); ուշացում (10); } (int reg = 111; reg <= 112; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); ուշացում (10); } համար (int reg = 189; reg <= 201; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); ուշացում (10); } (int reg = 239; reg <= 240; reg ++) {fprintf (stderr, "%d:%d / n", reg, wiringPiI2CReadReg8 (fd, reg)); fflush (stderr); ուշացում (10); } վերադարձ 0; }

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

Մինչ այժմ գրանցված արդյունքները կարող են նոր հարցեր առաջացնել:

Հարց. Ինչու՞ «արտաքին» խմբի համար գրանցման միայն մեկ արդյունք կա:

Հարց. Որո՞նք են այդ բոլոր անհայտ գրանցամատյանները «??????»:

Հարց. Քանի որ ծրագիրը չի ընդհատվում, արդյո՞ք այն շատ դանդաղ տվյալներ էր պահանջում: շատ արագ?

Հարց. Կարո՞ղ ենք ազդել արդյունքների վրա ՝ փորձելով ինչ -որ բան սենսորով, երբ այն աշխատում է:

Քայլ 6: Եկեք ավելի շատ քանդենք ընթերցումների / տվյալների մեջ

Կարծում եմ, որ ամեն ինչից առաջ հաջորդ քայլը ծրագիրը կատարելագործելն է.

• լինել ճկուն, որքան օղակի հետաձգում (ms)
• եղեք ճկուն, թե քանի ընթերցում պետք է տրվի մեկ գրանցամատյանում միջին հաշվով

(Ես պետք է ծրագիրը կցեի որպես ֆայլ: Թվում էր, թե այստեղ տեղադրելու խնդիր կա: "4th.test.mpu9265.c")

Ահա միջին հաշվով վերջին 10 ընթերցումների օգտագործումը ՝ 10 մգ հանգույցով.

sudo./fourth.test.mpu9265 0x68 10 10

61:255 0 255 0 255 0 255 0 0 0: 102 62:204 112 140 164 148 156 188 248 88 228: 167 63:189 188 189 187 189 188 188 188 188 189: 188 64: 60 40 16 96 208 132 116 252 172 36: 112 65: 7 7 7 7 7 7 7 7 7 7: 7 66:224 224 224 240 160 208 224 208 144 96: 195 67: 0 0 0 0 0 0 0 0 0 0: 0 68:215 228 226 228 203 221 239 208 214 187: 216 69: 0 255 0 255 255 0 255 0 0 0: 102 70:242 43 253 239 239 45 206 28 247 207: 174 71: 0 255 255 0 255 255 255 255 255 255: 204 72: 51 199 19 214 11 223 21 236 193 8: 117 73: 0 0 0 0 0 0 0 0 0 0: 0 111: 46 149 91 199 215 46 142 2 233 199: 132 112: 0 0 0 0 0 0 0 0 0 0: 0 189:255 0 255 0 255 0 0 255 0 255: 127 190: 76 36 240 36 100 0 164 164 152 244: 121 191:188 188 188 188 187 188 187 189 187 189: 187 192: 8 48 48 196 96 220 144 0 76 40: 87 193: 7 7 7 7 7 8 7 7 7 7: 7 194:208 224 144 240 176 240 224 208 240 224: 212 195: 0 0 0 0 0 0 0 0 0 0: 0 196:243 184 233 200 225 192 189 242 188 203: 209 197:255 0 0 0 255 0 255 0 0 255: 102 198:223 39 247 43 245 22 255 221 0 6: 130 199: 0 255 255 255 0 255 255 255 255 0: 178 200:231 225 251 1 252 20 211 216 218 16: 164 201: 0 0 0 0 0 0 0 0 0 0: 0 239: 21 138 196 87 26 89 16 245 187 144: 114 240: 0 0 0 0 0 0 0 0 0 0: 0

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

Կարծես 61, 69, 71, 189, 197 և 199 գրանցամատյանները կամ միայն երկուական են, կամ պատրաստ են / պատրաստ չեն, կամ դրանք 16 բիթանոց մեծ բայթ են (բացասական):

Այլ հետաքրքիր դիտարկումներ.

• գրանցամատյաններ 65, 193 - շատ կայուն և նույն արժեքով
• գրանցամատյան 63, 191 - շատ կայուն և նույն արժեքով
• գրանցամատյաններ 73, 112, 195, 201, 240 - բոլորը զրոյական

Եկեք այս դիտարկումները հետ կապենք նախկինի բազմագույն, ընդգծված սեղանի պատկերին:

Գրանցել 65 - ջերմաստիճան

Գրանցվել 193 - ??????

Գրանցեք 63 - արագացուցիչ

Գրանցվել 191 - ??????

Գրանցամատյան 73 - արտաքին

Գրանցվել 112 և միացված - ??????

Դե, մենք դեռ անհայտներ ունենք, այնուամենայնիվ, օգտակար բան ենք սովորել:

Գրանցամատյանը 65 (ջերմաստիճան) և գրանցամատյանը 63 (արագացուցիչ) երկուսն էլ շատ կայուն էին: Սա մի բան է, որը մենք կսպասեինք: Ես դիպչել եմ սենսորին; այն չի շարժվում, բացի պատահական թրթռումներից, քանի որ ռոբոտը հանգստանում է իմ սեղանի վրա, ինչպես իմ համակարգիչը:

Կա մեկ հետաքրքիր փորձություն, որը կարող ենք անել ջերմաստիճանի/արագացուցիչի գրանցամատյաններից յուրաքանչյուրի համար: Այդ թեստի համար մեզ անհրաժեշտ է ծրագրի մեկ այլ տարբերակ:

Քայլ 7: Մենք ի վիճակի ենք ազդել ջերմաստիճանի և արագացման վրա

Նախորդ քայլերում մենք նվազեցրինք ջերմաստիճանի առնվազն մեկ գրանցամատյան, իսկ արագացման համար:

Nextրագրի այս հաջորդ տարբերակով («5th.test.mpu9265.c») մենք իրականում կարող ենք տեսնել, որ փոփոխություն է կատարվում երկու գրանցամատյանների համար: Խնդրում ենք դիտել տեսանյութերը:

Ավելի փորվածք

Եթե վերադառնանք և նայենք գրանցամատյանի տեղեկատվությանը, կտեսնենք, որ կան.

• երեք 16 բիթանոց ելք գիրոսկոպի համար
• երեք 16 բիթանոց ելք արագացուցիչի համար
• երեք 16 բիթանոց ելք մագնիսաչափի համար
• մեկ 16 բիթանոց ջերմաստիճան

Այնուամենայնիվ, մեր պարզ թեստային ծրագրերով ստացված արդյունքները բոլորը մեկ բիթանոց 8 ելք էին: (միայնակ գրանցամատյաններ):

Եկեք ավելի շատ փորձենք նույն մոտեցումը, բայց այս անգամ 16 բիթ կարդալով 8 -ի փոխարեն:

Մենք հավանաբար ստիպված կլինենք անել ստորև նշվածի նման մի բան: Եկեք օգտագործենք ջերմաստիճանը որպես օրինակ, քանի որ դա ընդամենը մեկ 16 բիթանոց ելք է:

// ստանալ ֆայլի նկարագրիչ fd…

int tempRegHi = 65; int tempRegLo = 66; int hiByte = wiringPiI2CReadReg8 (fd, tempRegHi); int loByte = wiringPiI2CReadReg8 (fd, tempRegLo); int արդյունք = hiByte << 8; // դրեք hi կարգը 8 բիթ 16 բիթանոց արդյունքի վերին մասում | = loByte; // այժմ ավելացրեք lo կարգով 8 բիթ ՝ տալով 16 բիթանոց ամբողջական թիվ // տպեք այդ թիվը կամ օգտագործեք ցուցադրման հորիզոնական գծապատկերման գործառույթը նախկինից

Մեր նախորդ քայլերից մենք տեսանք, որ 65 գրանցամատյանը բավականին կայուն է, մինչդեռ 66 գրանցամատյանը շատ աղմկոտ է: Քանի որ 65 -ը բարձր կարգի բայթ է, իսկ 66 -ը `ցածր կարգի բայթ, դա իմաստ ունի:

Ընթերցանության համար մենք կարող ենք 65-ի տվյալները վերցնել այնպես, ինչպես կան, բայց մենք կարող ենք միջինը գրանցել 66-ի արժեքները:

Կամ մենք կարող ենք պարզապես միջինացնել ամբողջ արդյունքը:

Դիտեք այս հատվածի վերջին տեսանյութը; այն ցույց է տալիս ամբողջ 16 բիթ ջերմաստիճանի արժեքը կարդալը: Կոդ ՝ «sixth.test.mpu9265.c»

Քայլ 8: Արագացուցիչ և գիրոսկոպ

Այս բաժնի տեսանյութերը ցույց են տալիս արագացուցիչից և գիրոսկոպից ելք ՝ օգտագործելով «յոթերորդ.թեստ.mpu9265.c» թեստային ծրագիրը: Այդ կոդը կարող է կարդալ 1, 2 կամ 3 հաջորդական բայթ-զույգ (hi և lo բայթ) և արժեքները վերածել մեկ 16 բիթ արժեքի: Այսպիսով, մենք կարող ենք կարդալ ցանկացած առանձին առանցք, կամ կարող ենք կարդալ դրանցից երկուսը միասին (և դա գումարում է փոփոխությունները), կամ մենք կարող ենք կարդալ բոլոր երեքը (և այն գումարում է փոփոխությունները):

Կրկին կրկնելու համար, այս փուլի, այս Instructable- ի համար ես պարզապես փնտրում եմ պատասխանել մի պարզ հարցի. Ես չեմ փնտրում որևէ ճշգրիտ արժեք, օրինակ ՝ այն պտտվե՞լ է 90 աստիճանով: Դա կգա ավելի ուշ, երբ մենք սկսենք SLAM անել, բայց դա չի պահանջվում խոչընդոտներից խուսափելու և պատահական շարժման համար:

Քայլ 9: (աշխատանքն ընթացքի մեջ է) մագնիսաչափը

i2cdetect գործիքը օգտագործելիս MPU9265- ը աղյուսակում ցուցադրվում է որպես 0x68:

0 1 2 3 4 5 6 7 8 9 a b c d e f

00: -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- -- 70: -- -- -- -- -- -- -- --

IMU- ի մագնիսաչափի հատվածից կարդալու համար անհրաժեշտ են լրացուցիչ քայլեր:

Invesense գրանցամատյաններից PDF փաստաթուղթ.

ԳՐԱՆՈՄՆԵՐ 37 -ից 39 -ը - I2C SLAVE 0 CONTROL

• ԳՐԱՆՎԵԼ 37 - I2C_SLV0_ADDR
• ԳՐԱՆՎԵԼ 38 - I2C_SLV0_REG
• ԳՐԱՆՎԵԼ 39 - I2C_SLV0_CTRL