Արդյունավետ Java զարգացում Raspberry Pi- ի համար. 11 քայլ (նկարներով)

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

Այս Instructable- ը նկարագրում է շատ արդյունավետ մոտեցում Raspberry Pi- ի համար Java ծրագրեր մշակելու համար: Ես օգտագործել եմ Java- ի հնարավորությունները զարգացնելու մոտեցումը `սկսած սարքերի ցածր մակարդակից մինչև բազմաթել և ցանցային ծրագրեր: Մոտեցումը ոչ միայն արդյունավետ է, այլև անվճար:

Սկզբունքորեն, մոտեցումը հեռավոր զարգացում է `օգտագործելով NetBeans- ը: NetBeans- ն աշխատում է աշխատատեղով (աշխատասեղան կամ նոութբուք համակարգիչ, այլ ոչ թե Raspberry Pi), որը միացված է Wifi- ի միջոցով Raspberry Pi- ին: Երբ ամեն ինչ ճիշտ կարգավորվի, կարող եք գրել Java ծրագիր NetBeans- ում, այնուհետև մեկ կտտոցով կազմվում և կառուցվում է ծրագիրը աշխատակայքում, ծրագիրը ներբեռնվում է Pi- ում, գործարկվում է Pi- ի վրա և ելքը առաքվում է NetBeans- ի մխիթարելին:. Կախարդական! Դուք նույնիսկ կարող եք կարգաբերել վազող ծրագիրը ՝ սահմանելով ընդմիջման կետեր և ուսումնասիրելով փոփոխական արժեքները: Ավելի կախարդական!

Այս ներածության մնացած մասը նկարագրում է Java- ի օգտագործման և NetBeans- ի միջոցով հեռակա զարգացման մոտիվացիան: Եթե ձեզ հետաքրքրում է մոտիվացիան, ապա կարդացեք: Եթե դա ձեզ չի հետաքրքրում, գնացեք 1 -ին քայլ:

Ինչու՞ օգտագործել Java- ն Raspberry Pi- ում:

Կան բազմաթիվ ծրագրավորման լեզուներ, որոնք հասանելի են Raspberry Pi- ի համար, սակայն ես կսահմանափակեմ քննարկումը «մասնագիտական» ծրագրավորման լեզուներով, որոնք ուղղված են առանձին ծրագրերին, աջակցում են բազմաթիվ առաջադրանքներին, թույլ են տալիս սարքավորումների և ցանցի հասանելիություն և այլն: Դա նշանակում է Java, Python կամ C/C ++: Raspbian- ի վերջին թողարկումները ներառում են այս բոլոր լեզուների մշակման և գործարկման ժամանակ աջակցություն:

Իրականում Python- ը «խթանվում է» Pi- ի վրա օգտագործելու համար, գոնե մասամբ ՝ նոր ծրագրավորողների համար սովորելու հեշտության համար: Ես փորձառու ծրագրավորող եմ և Python- ի սիրահար չեմ ՝ նրա մի շարք բնութագրերի նկատմամբ, անկասկած, սուբյեկտիվ հակակրանքի պատճառով, օրինակ ՝ դինամիկ մուտքագրման: Կա Python- ի մեկ բնութագիր, որի նկատմամբ իմ հակակրանքն օբյեկտիվ է `կատարումը: Այս աղբյուրը ցույց է տալիս, որ Java- ն միշտ ավելի արագ է, քան Python 3 -ը և իրականում կարող է հարյուրավոր անգամ ավելի արագ աշխատել ՝ կախված առաջադրանքից:

C- ն, իմ կարծիքով, «բարձրակարգ մեքենայական լեզու» է, այսինքն ՝ ինչ -որ բան, որը շատ մոտ է համակարգի սարքավորումներին կամ գոնե օպերացիոն համակարգին: Դուք կարող եք գրեթե ամեն ինչ անել, և կարող եք դա անել հնարավորինս արագ; Փաստորեն, այս աղբյուրը ենթադրում է, որ C- ն կարող է աշխատել մինչև 7X նույնքան արագ, որքան Java- ն: Ես նույնպես չեմ սիրում C- ն, քանի որ (սուբյեկտիվորեն) չեմ սիրում դրա որոշ բնութագրեր, որոնք ես գտնում եմ հնացած, հնագույն կամ երկուսն էլ. օրինակ ՝ հստակ ցուցիչներ: Օբյեկտիվորեն, այն փաստը, որ դու կարող ես ինչ -որ բան անել, նշանակում է, որ դու ընդամենը մի անհասկանալի սխալ (օրինակ ՝ վատ ցուցիչ թվաբանություն կամ սխալ հիշողություն) հեռու ես հիշողությունը վերագրելուց և ծրագիրը կամ նույնիսկ ամբողջ համակարգը պոտենցիալ խափանելուց: Java- ն կանխում է նման վտանգները, ուստի Java- ն ավելի անվտանգ է: Ես զգում եմ, որ անվտանգությունը նաև բարելավում է ծրագրավորողի արտադրողականությունը: Ես C ++-ը համարում եմ C- ի շուրջ օբյեկտ կողմնորոշված «փաթաթան», որը ոչինչ չի անում C- ի վտանգները վերացնելու համար:

Եզրակացություն. Java- ն ավելի արագ է, քան Python- ը: Java- ն ավելի անվտանգ է, քան C.

Կա՞ն սահմանափակումներ Java- ի օգտագործման ժամանակ:

Մինչ այժմ ինձ հաջողվել է անել Java- ում ամեն ինչ, ինչ կարող եմ անել Python- ում: Կան բաներ, որոնք կարելի է անել C- ում, ինչը չի կարող անել Java- ում, բայց կրկին, մինչ այժմ այն ամենը, ինչ ուզում էի անել, հասցեագրված է եղել Java համայնքի երկրպագուների կողմից: Ես օրինակ կներկայացնեմ ավելի ուշ քայլում: Ասել է թե ՝ ես սենսորներ եմ գնել վաճառողներից, որոնք «վարորդներ» էին մատակարարում սենսորների համար միայն Python- ում (կամ C/C ++ Arduino- ի համար), ուստի ստիպված էի գրել Java- ի համարժեքը. լրացուցիչ ջանքերը պարտադիր չէ, որ արդյունավետ են, բայց կարող են հանգեցնել սենսորի աշխատանքի ավելի խոր պատկերացման:

Ինչու՞ հեռավոր զարգացում ՝ հիմնված NetBeans- ի վրա:

Ես պարզել եմ, որ NetBeans- ի վրա հիմնված հեռավոր զարգացումը մեծապես մեծացնում է արտադրողականությունը Raspberry Pi- ի համար Java օգտագործելիս: Ես վստահ եմ, որ դուք կարող եք օգտագործել մոտեցումը ՝ արագ և անվտանգ ծրագրեր ստեղծելու համար ՝ Java- ի բնածին բնութագրերի պատճառով, մինչդեռ դրանք գրելուց, կառուցել և կարգաբերել շատ ավելի արագ, քան գտածս այլ մոտեցումները ՝ «մասնագիտական» հեռավոր զարգացման շնորհիվ: դասարան «NetBeans Integrated Development Environment (IDE).

Կարող է օգտակար լինել հակիրճ քննարկել այդ «այլ մոտեցումները»: Բոլորը բավարարում են հիմնական չափանիշներին, որ Raspberry Pi- ում միացված չէ ստեղնաշար, մկնիկ կամ էկրան: Այս չափանիշների պատճառները շատ են, բայց իմ հիմնական պատճառն այն է, որ ես զարգացնում եմ շարժական ռոբոտներ, և ես չեմ ցանկանում, որ Pi- ն նույնիսկ զարգացման ընթացքում միացված լինի որևէ ծայրամասային սարքի, բացառությամբ ռոբոտային ենթահամակարգերի:

Raspbian- ում ներառված VNC սերվերը տրամադրում է հեռավոր գրաֆիկական ինտերֆեյս (GUI), որը թույլ է տալիս հեռակա զարգացման մի ձև, որտեղ աշխատատեղում աշխատում է միայն հեռավոր GUI- ն, իսկ մնացած բոլորը ՝ գրելը, կազմելը և կառուցելը, տեղի է ունենում Pi- ում: VNC- ի միջոցով հեշտ է օգտագործել Java- ի հնարավոր զարգացման գործիքները, որոնք առաքվում են Raspbian- ում, ինչպես BlueJ- ը, Geany- ը և Greenfoot- ը: Դրանցից մի քանիսը կարող են համարվել IDE; այնուամենայնիվ, ես դրանք գտնում եմ մասնագիտական աստիճանից հեռու:

Տեխնիկապես հնարավոր է Raspberry Pi- ի վրա տեղադրել մասնագիտական դասարանի Java IDE- ն, ինչպիսին է Eclipse- ը կամ NetBeans- ը, և այն օգտագործել հեռակա կարգով VNC- ի միջոցով: Հաշվետվությունները և ողջամտությունը հուշում են, որ արդյունքները հիասթափեցնող կլինեն, քանի որ նման IDE- ները պահանջում են մեծ հիշողություն և պրոցեսորի հզորություն, ինչպես նաև հեռավոր GUI- ի կողմից ներդրված ցանցի ուշացում:

Ե՛վ Eclipse- ը, և՛ NetBeans- ը շատ լավ են աշխատում աշխատակայանում: Eclipse- ի դեպքում ծածկագիր գրելը հաճելի փորձ է, սակայն ծրագիրը կառուցելը ոչ. ծրագրի ներբեռնումը պետք է տեղի ունենա Eclipse- ից դուրս; Pi- ի վրա ծրագրի իրականացումը լիովին անկախ է Խավարումից: Ընդհանուր արդյունքը բազմաքայլ, գրեթե ցավոտ գործընթաց է, որը չի կարող աջակցել հեռակա կարգաբերում: NetBeans- ն ունի ներկառուցված կազմաձևում, կառուցում, ներբեռնում, հեռահար կատարում և հեռակա կարգաբերում ՝ այն դարձնելով գերազանց մոտեցում:

Քայլ 1: Կարգավորեք Raspberry Pi- ն

Հեռավոր զարգացման մոտեցումն օգտագործելու համար պետք է սկսել թիրախային Raspberry Pi- ի ստեղծումից: Կան բազմաթիվ ռեսուրսներ, ներառյալ Instructables, որոնք մատչելի են Raspberry Pi- ի ստեղծմանն աջակցելու համար: Տեսեք սա Pi- ի (և ավելին) տեղադրման հիմունքների համար:

Այս Instructable ենթադրում է ձեզ

• տեղադրել վերջին Raspbian- ը; համոզվեք, որ գրանցել եք Pi օգտվողի ID- ն և գաղտնաբառը
• տեղադրեք Wifi և միացեք ձեր երթուղիչին (տե՛ս սա); համոզվեք, որ գրանցել եք Pi- ի IP հասցեն
• միացրեք SSH- ին (տե՛ս սա) ՝ աշխատատեղից Pi- ին հեռակա մուտք գործելու համար

Կարգավորումն ավարտելուց հետո կարող եք անջատել և անջատել էկրանը, ստեղնաշարը և մկնիկը Pi- ից: Սա հեռավոր զարգացման հիմնական առավելություններից մեկն է: Դուք պետք է միացված Wifi- ի միացում միացնեք (իհարկե անհրաժեշտ չէ Pi մոդելի 3 -ի կամ Pi Zero W- ի համար), այնուհետև կարող եք միացնել Pi- ն:

Փորձարկելու համար բացեք ssh հաճախորդ ձեր աշխատակայանում, օրինակ ՝ MacOS- ի տերմինալ կամ Windows- ում ՝ ծեփոն: Այնուհետև մուտքագրեք ssh (ապահով պատյան) հրամանը հետևյալ ձևով.

ssh the_pi_ip_address -l the_pi_user_id

Դուք պետք է հուշում ստանաք մուտքագրելու ձեր Pi օգտվողի ID- ի գաղտնաբառը: Եթե ոչ մի հուշում չի հայտնվում, ստուգեք, որպեսզի համոզվեք, որ ssh հրամանում մուտքագրել եք ճիշտ IP հասցեն: Մուտքագրեք ձեր գաղտնաբառը (այն թաքցված կլինի), և այնուհետև պետք է տեսնեք Pi- ի պատյան հուշումը, որը հայտնվում է այսպես.

pi@raspberrypi: ~ $

Եթե չեք տեսնում հուշումը, ստուգեք օգտագործված օգտվողի ID- ն և գաղտնաբառը:

Այժմ դուք պետք է գտնեք Java- ի գործարկման ժամանակի ուղին և հաստատեք, որ կանխադրված տարբերակը Java 8 -ն է (պետք է ճիշտ լինի վերջին Raspbian- ի համար): Java- ի գործարկման ժամանակը գտնելու համար ssh հաճախորդում մուտքագրեք հրամանը

sudo update-alternatives-ցուցադրել java

Դուք պետք է պատասխան տեսնեք առաջին երկու տողերով, որոնք նման են հետևյալին.

java - ավտոմատ ռեժիմ

հղումը լավագույն տարբերակն է/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java

Երկրորդ տողում «-8-»-ը հաստատում է, որ լռելյայն գործարկման ժամանակը Java 8-ն է: Գրանցեք երկրորդ տողի ուղին, քանի որ դա ձեզ անհրաժեշտ կլինի `հետագա փուլում NetBeans- ի հեռավոր զարգացման համար կազմաձևելու համար:

Եթե լռելյայն գործարկման ժամանակը Java 8 չէ, ssh հաճախորդում մուտքագրեք Java- ի 8 -ին անցնելու հետևյալ հրամանը (ենթադրելով, որ այն տեղադրված է)

sudo update-alternatives-config java

Քայլ 2: Տեղադրեք NetBeans աշխատատեղում

Այժմ դուք պետք է տեղադրեք NetBeans ձեր աշխատատեղում: Ձեր աշխատատեղի դիտարկիչն ուղղեք դեպի NetBeans ներբեռնման էջը: Դուք կտեսնեք մի քանի հնարավոր փաթեթներ, որոնք աջակցում են Java- ի երկու հրատարակություններին, ինչպես նաև այլ լեզուների: Raspberry Pi- ի համար Java- ի զարգացման համար անհրաժեշտ է միայն Java SE, սակայն կարող եք ձեռք բերել Java EE փաթեթ կամ All փաթեթ: Երբ որոշեք, թե որ փաթեթն եք ցանկանում սեղմել համապատասխան Ներբեռնման կոճակը: Այստեղ կարող եք գտնել ձեր աշխատանքային կայանի ՕՀ -ի տեղադրման լրացուցիչ հրահանգներ:

Երբ տեղադրեք NetBeans- ը, սկսեք այն (այն կարող է ինքնաբերաբար դա անել տեղադրումից հետո): Դուք պետք է տեսնեք NetBeans- ի հիմնական պատուհանը, ինչպես ցույց է տրված նկարում: Նկարը արված է Mac- ով, և հիմնական պատուհանը Windows- ում կարող է մի փոքր այլ տեսք ունենալ:

Երբ հաջողությամբ տեղադրեք և գործարկեք NetBeans- ը, անցեք հաջորդ քայլին:

Քայլ 3. Կարգավորեք Raspberry Pi- ն որպես հեռակա հարթակ NetBeans- ում

Հետևյալ գործողությունները կազմաձևում են Raspberry Pi- ն որպես հեռավոր Java SE հարթակ NetBeans- ի համար: Սա NetBeans- ին հնարավորություն է տալիս ներբեռնել և կատարել Java ծրագրեր Pi- ում: Այստեղ կարող եք գտնել որոշ ընդհանուր նկարագրություն:

Նշում. Այս և հաջորդ քայլերում ես ցույց եմ տալիս իմ միջավայրին հատուկ արժեքներ `կազմաձևման և կոդավորման տարբեր ասպեկտների համար. ձերն ակնհայտորեն տարբեր կլինի:

Pi- ն որպես հեռավոր հարթակ կազմաձևելու համար.

1. NetBeans- ի հիմնական ընտրացանկի բարում ընտրեք Գործիքներ -> Java հարթակներ: Դուք կտեսնեք Java Platform Manager- ի բացվող պատուհանը (նկար մեկ):
2. Կտտացրեք Ավելացնել հարթակ ներքևի ձախ մասում: Դուք կտեսնեք «Ավելացնել Java պլատֆորմ» [պլատֆորմի տեսակը] թռուցիկ (նկար երկրորդ):
3. Ընտրեք Remote Java Standard Edition: Կտտացրեք Հաջորդը: Դուք կտեսնեք «Ավելացնել Java պլատֆորմ» [ստեղծել հեռավոր հարթակ] թռուցիկ (երրորդ նկարը ցույց է տալիս թռուցիկը դաշտերում իմ միջավայրի համապատասխան արժեքները մուտքագրելուց հետո):
4. Պլատֆորմի անուն դաշտում մուտքագրեք Pi- ի անունը: Դուք կարող եք օգտագործել գրեթե ամեն ինչ, բայց այն պետք է լինի յուրահատուկ:
5. Հոսթ դաշտում մուտքագրեք 1 -ին քայլին գտնված Pi- ի IP հասցեն:
6. Օգտվողի անուն դաշտում մուտքագրեք օգտվողի անունը, որն օգտագործել եք 1 -ին քայլում:
7. Ընտրված թողեք Օգտագործեք գաղտնաբառի նույնականացումը և Գաղտնաբառի դաշտում մուտքագրեք 1 -ին քայլում ստեղծված գաղտնաբառը:
8. Հեռավոր JRE ուղի դաշտում դուք պետք է մուտքագրեք Pi- ի վրա Java- ի գործարկման ժամանակաշրջանի մեծ մասը: Քայլ 1-ում դա/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java էր: Այնուամենայնիվ, դաշտի արժեքում պետք է բաց թողնել /bin /java:
9. NetBeans- ը ներլցնում է գործարկվող ծրագիրը Pi- ի աշխատանքային գրացուցակում, որը նշված է Working դաշտում: Լռելյայն է/the_Pi_user_ID/NetBeansProjects/և դա միանգամայն ընդունելի է: Youանկության դեպքում կարող եք օգտագործել այլ բան, չնայած այն պետք է հասանելի լինի the_Pi_user_ID- ին (նկար երեք):
10. Կտտացրեք «Ավարտել» պատուհանի ներքևի աջ մասում: Մշակելուց հետո դուք պետք է ևս մեկ անգամ տեսնեք Java Platform Manager- ի բացվող պատուհանը: Այժմ դուք պետք է տեսնեք ձեր հեռակա Pi- ն (այն անվան տակ, որն օգտագործել եք վերը նշված 4 -րդ գործողությունում) կատեգորիայի տակ ՝ Հեռակա Java SE (նկար չորս):
11. Սեղմեք Test Platform- ը ներքևի ձախ մասում `NetBeans- ի և ձեր Pi- ի միջև կապը ստուգելու համար: Սկզբում կտեսնեք մի թռուցիկ, որն ասում է «Հեռակա հարթակ հաստատելը»: Հաջողության դեպքում դուք կստանաք երկրորդ պատուհան, որը ցույց է տալիս Միացումը… հաջողությամբ հաստատված: Եթե ոչ, ապա պետք է ստուգեք և ուղղեք այն տեղեկությունները, որոնք մուտքագրել եք «Ավելացնել Java պլատֆորմ» [ստեղծել հեռավոր հարթակ] թռուցիկ վերևում 5-9 գործողություններում: Դա կարող եք անել Java Platform Manager Manager- ի պատուհանից; պարզապես ընտրեք ձեր Pi հարթակը, այնուհետև խմբագրեք բացվող պատուհանի աջ կողմում գտնվող դաշտերը:
12. Հաջող կապից հետո, Java Platform Manager Manager- ի պատուհանում կտտացրեք Փակել: Այժմ դուք կտեսնեք NetBeans- ի հիմնական պատուհանը:

Այժմ իսկական զվարճանքը կարող է սկսվել:

Քայլ 4. Ստեղծեք Java նախագիծ աշխատակայանում

Սա նախատեսված չէ NetBeans- ի կամ Java- ի օգտագործման ամբողջական բացատրություն լինելու համար, բայց ես կներկայացնեմ աշխատատեղում NetBeans- ում ծրագիր գրելու և, ի վերջո, Raspberry Pi- ի վրա հեռակա գործարկելու նվազագույն գործողությունները:

NetBeans- ում նախ պետք է ստեղծեք ծրագիր, որը կանցկացնի ծրագրի Java դասը (եր): Բացի այդ, Java- ում դասերը գտնվում են կազմակերպությունների և անվտանգության ապահովման համար նախատեսված փաթեթներում: Նախագիծը ստեղծելու և ընտրովի փաթեթ և դասի ֆայլ ստեղծելու համար.

1. NetBeans- ի հիմնական պատուհանում կտտացրեք ծրագրի նոր պատկերակին (ձախից երկրորդը): Դուք կտեսնեք Նոր նախագիծ [ընտրել նախագիծը] պատուհանը (նկար մեկ):
2. Կանխադրված պարամետրերը (Կատեգորիա. Java, Նախագիծ. Java Application) ճիշտ են այս օրինակի համար, այնպես որ պարզապես կտտացրեք Հաջորդը: Դուք կտեսնեք Նոր Java հավելվածի [անունը և վայրը] պատուհանը (նկար երկու ցույց է տալիս իմ օրինակի արժեքները): Ո NOTՇԱԴՐՈԹՅՈՆ. Ես վերափոխել եմ իմ օգտվողի տվյալները `օգտագործելով գունավոր ուղղանկյունները:
3. Նախագծի անուն դաշտում մուտքագրեք ձեր նախընտրած Java ծրագրի վավեր անունը: Անունը պետք է սկսվի մեծատառով, և կոնվենցիան առաջարկում է ուղտի դեպք ՝ բառերը միացնելիս:
4. Locationրագրի տեղադրման դաշտը վերահսկում է, թե որտեղ է գտնվում նախագիծը ձեր ֆայլային համակարգում: Լռելյայնությունը տարբերվում է ՝ կախված օպերացիոն համակարգից, բայց անվտանգ է ընդունելը:
5. Project Folder դաշտը թույլ է տալիս վերահսկել նախագծի թղթապանակի անունը: Ես գտնում եմ, որ լավագույնն է օգտագործել կանխադրվածը, որը Տեղադրության դաշտի և Անվան դաշտի համակցումն է:
6. Ստեղծման հիմնական տուփի նշման վանդակի ստուգման դեպքում NetBeans- ն ինքնաբերաբար ստեղծում է փաթեթ և հիմնական դասի ֆայլ (ծրագիր, որը կարող է գործարկվել հրամանի տողից) ՝ նույն անունով, ինչ նախագիծը: Կարծում եմ, որ սովորաբար այն պետք է չստուգվի, բայց այս դեպքում ես դա կթողնեմ ստուգված, ինչը վերացնում է դրա համար այլապես անհրաժեշտ գործողությունները (նկար երկրորդ):
7. Կտտացրեք Ավարտել ՝ նախագիծը, փաթեթը և հիմնական դասի ֆայլը ստեղծելու համար: Այժմ NetBeans- ի հիմնական պատուհանի վերին ձախ պատուհանը ցույց է տալիս ձեր նախագիծը, որը պարունակում է մեկ փաթեթ, որն իր հերթին պարունակում է մեկ դասի ֆայլ `հիմնական () մեթոդով: Վերին աջ վահանակը պարունակում է հիմնական դասի (ծրագրի) լռելյայն սկզբնաղբյուրը, որն ավտոմատ կերպով ստեղծվում է NetBeans- ի կողմից (նկար երեք):

Այս պահին կարող եք հիմնական ծածկագրում գրել որոշակի ծածկագիր և այն գործարկել աշխատակայանում: Դա երբեմն ցանկալի է, բայց այս Ուղեցույցի համար անհրաժեշտ չէ, այնպես որ անցեք հաջորդ քայլին:

Քայլ 5. Կազմաձևեք NetBeans նախագիծը ՝ հեռավոր գործելու Raspberry Pi- ով

NetBeans նախագիծը և այն պարունակող ծրագիրը կազմաձևելու համար ՝ Raspberry Pi- ի վրա հեռակա աշխատելու համար կատարեք հետևյալը.

1. Աջ կամ 2 մատով (կախված աշխատակայանի ՕՀ-ից) ծրագրի վրա `NetBeans հիմնական պատուհանի Projects պատուհանում` ծրագրի ընտրացանկը ցուցադրելու և կտտացրեք Հատկություններ: Դուք կտեսնեք «Propertրագրի հատկություններ» պատուհանը (նկարը ցույց է տալիս թռուցիկը `իմ օրինակին համապատասխան արժեքներով):
2. Ձախ կողմում գտնվող կատեգորիաների ներքո ընտրեք Գործարկել:
3. Կտտացրեք Նոր ՝ Կազմաձևման դաշտի աջ կողմում: Ստացված Ստեղծեք նոր կոնֆիգուրացիա բացվող պատուհանում մուտքագրեք կազմաձևի անունը և կտտացրեք OK: Անունը կարող է լինել ցանկացած; Ես պարզապես նորից օգտագործեցի հարթակի անունը («Իմ Պի»): Մեկ անգամ ևս կտեսնեք «Propertրագրի հատկություններ» պատուհանը:
4. Կտտացրեք բացվող պատկերակին Runtime Platform դաշտի աջ կողմում: Բացվող ցուցակից ընտրեք ձեր ստեղծած հեռավոր հարթակը (իմ միջավայրում ՝ «Իմ Pi»):
5. Clickրագրի հեռակա հարթակը կարգավորելու համար կտտացրեք OK: Դուք կրկին կտեսնեք հիմնական պատուհանը:

Այժմ դուք պատրաստ եք գրել կոդը և գործարկել ծրագիրը հեռակա կարգով:

Քայլ 6. Գրեք Java ծրագիր աշխատանքային կայանի վրա և գործարկեք այն Raspberry Pi- ի վրա

NetBeans- ի հիմնական պատուհանի աջ վահանակը ցույց է տալիս NetBeans- ի կողմից ստեղծված հիմնական դասի ֆայլը: Դասի ֆայլի հիմնական մեթոդում մուտքագրեք պարզ տպագիր հայտարարություն (նկար 1): Այն այժմ ամբողջական Java ծրագիր է, որը ինչ -որ բան անում է, չնայած շատ պարզ բան է:

Pi- ի վրա ծրագիրը գործարկելու համար կտտացրեք «Run» պատկերակին (կանաչ ձախ սլաքը) հիմնական պատուհանում: NetBeans- ը կազմում է ծածկագիրը, կառուցում է jar ֆայլ, ներբեռնում է jar ֆայլը Raspberry Pi- ում ՝ հեռավոր հարթակի կողմից որոշված, կատարում է ծրագիրը Pi- ի վրա, գրավում ծրագրի ելքը (System.out) և արձագանքում NetBeans- ին Ելքային պատուհան հիմնական պատուհանի ներքևի աջ մասում (նկար երկրորդ):

Այժմ դուք զգալիորեն ընդլայնել եք Raspberry Pi- ի վրա նախագծեր մշակելու հմտությունները: Բայց սպասիր…. Կա ավելին!

Քայլ 7. Վրիպազերծել Java ծրագիրը NetBeans- ով

NetBeans- ի պես արդյունաբերական հզորության ինտեգրված զարգացման միջավայրի ամենահզոր հատկանիշներից է ծրագիրը գործարկելիս վրիպազերծելու ունակությունը: NetBeans- ը թույլ է տալիս օգտագործել հեռակա կարգով վրիպազերծման գործիքների ամբողջ փաթեթը: Սա ներառում է ծրագրի «կարևոր» կամ «անհանգստացնող» վայրերում ճեղքման կետերի սահմանում և փոփոխականների արժեքի ընթացիկ կատարման վիճակի ուսումնասիրություն:

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

Վրիպազերծման գործիքներից օգտվելու համար նախ պետք է սահմանեք մեկ կամ մի քանի ընդմիջման կետ: Անջատիչ կետ սահմանելու համար կտտացրեք գծի համարին, որտեղ ցանկանում եք դադարեցնել կատարումը. հայտնվում է կարմիր ուղղանկյուն պատկերակ, և ամբողջ տողը ձեռք է բերում կարմիր ֆոն (նկար 1):

Pi- ով աշխատող ծրագիրը վրիպազերծելու համար կտտացրեք Debug պատկերակին (Run- ի պատկերակի անմիջապես աջ կողմում) NetBeans- ի հիմնական պատուհանում: Ինչպես սովորական կատարման դեպքում, NetBeans- ը կազմում է, կառուցում, ներբեռնում, կատարում, գրավում է արտադրանքը և արձագանքում այդ ելքին: Բայց վրիպազերծման դեպքում NetBeans- ը դադարեցնում է կատարումը ընդմիջման կետերում և թույլ է տալիս ուսումնասիրել կատարման վիճակը (նկար երկրորդ, որը ցույց է տալիս «Փոփոխականներ» պատուհանը ներքևի աջ կողմում):

Կատարումը դադարում է ընդմիջման կետում ՝ նախքան խզման կետով գծի վերաբերյալ հրահանգի կատարումը: Կանաչ ֆոնը ցույց է տալիս հաջորդ հայտարարությունը, որը պետք է կատարվի: Այսպիսով, իմ օրինակում, 9 -րդ տողում խզման կետով, a փոփոխականը դեռ գոյություն չունի, առավել ևս ՝ արժեք:

Այժմ սլաքը դրեք հիմնական պատուհանի վրիպազերծման ընտրացանկի պատկերակի վրա (առաջին երկակի սլաքը ներքևի պատկերակը ՝ Debug պատկերակի աջ կողմում) և կտտացրեք «Step Over» պատկերակին (այն ունի կապույտ փաստաթուղթ հետին պլանում և կանաչ ժամացույցի սլաքի հակառակ սլաք առաջին պլան). [EԱՆՈԹՈԹՅՈՆ. Եթե ձեր NetBeans- ի հիմնական պատուհանը բավականաչափ լայն դարձնեք, ապա կարգաբերման ընտրացանկը կընդլայնվի, և կարգաբերման գործողությունների պատկերակները կհայտնվեն Debug պատկերակի աջ կողմում]: Այժմ կտեսնեք, որ a փոփոխականը գոյություն ունի և ունի ակնկալվող արժեքը (նկար երեք):

Երկու անգամ կտտացրեք «Քայլ առ քայլ» պատկերակին: Դուք կտեսնեք, որ երեք փոփոխականներն էլ ունեն արժեքներ. նշենք, որ c- ն դեռ զրո է (նկար չորս):

Մեկ անգամ կտտացրեք «Քայլ առ քայլ» պատկերակին: Դուք կտեսնեք, որ c փոփոխականն այժմ ունի համապատասխան արժեք, այսինքն ՝ a և b փոփոխականների գումարը (նկար հինգ):

Ի վերջո, վրիպազերծման ընտրացանկում կտտացրեք «Գործարկել» պատկերակին (կանաչ շրջանակ սպիտակ սլաքով): Դա հանգեցնում է նրան, որ կատարումը կշարունակվի մինչև հաջորդ խզման կետը կամ ծրագրի ավարտը, որն առաջինն է գալիս:Այժմ հայտնվում է Ելքի վահանակը և ցույց է տալիս նույն ելքը, ինչ սովորական կատարման դեպքում, այս դեպքում տեքստը տպված հայտարարության մեջ:

Քայլ 8. Գործարկեք NetBeans- ից անկախ ծրագիրը

Կարող է գալ այն պահը, երբ ցանկանում եք իրականացնել ձեր ծրագիրը Raspberry Pi- ով ՝ առանց NetBeans- ի «օգնության» կամ «միջամտության»: Դա շատ պարզ է: Նախ, բացեք ssh հաճախորդ ձեր Pi- ի համար:

3 -րդ քայլից հիշեք, որ NetBeans- ը ձեր նախագծի բանկան տեղադրում է Pi- ի աշխատանքային գրացուցակում: Լռելյայն բազան/home/pi/NetBeansProjects է pi օգտվողի համար: Հատուկ գրացուցակը նույն անունն ունի, ինչ ձեր նախագիծը: NetBeans- ը բանկան տեղադրում է dist անվանումով ենթակայքում: Իմ օրինակի համար ամբողջական ուղին է/home/pi/NetBeansProjects/MyRemoteProg/dist. Pi- ի ssh հաճախորդում ծրագիրը գործարկելու համար կարող եք օգտագործել java հրամանը 'jar' տարբերակով.

java -jar /home/pi/NetBeansProjects/MyRemoteProg/dist/MyRemoteProg.jar

Կատարման արդյունքները կտեսնեք ssh հաճախորդում; իմ օրինակում ելքը կլինի

Ողջույն, Raspberry Pi- ից:

Սա աշխատում է, քանի որ բանկա ֆայլում եղած տեղեկատվությունը որոշում է, թե որ հիմնական դասը պետք է կատարվի:

Կարող եք նաև աշխատանքային գրացուցակը (cd- ի միջոցով) փոխել jar ֆայլի գտնվելու վայրին, այնուհետև թողնել ավելի կարճ հրաման ՝ նույն արդյունքները ստանալու համար:

java -jar MyRemoteProg.jar

Քայլ 9. Կառուցեք և ներբեռնեք, բայց չկատարեք ծրագիրը NetBeans- ի միջոցով

Կան իրավիճակներ, երբ ցանկանում եք, որ NetBeans- ը կառուցի և ներբեռնի ձեր ծրագիրը, բայց չկատարի այն: Նման իրավիճակ է առաջանում, երբ ձեր ծրագրին անհրաժեշտ է ստեղնաշարի մուտքագրում: Եթե դա այդպես է, օգտագործելով նախորդ քայլի տեխնիկան, կառուցելուց և ներբեռնելուց հետո ծրագիրը գործարկում է Raspberry Pi- ով և, հետևաբար, ակնկալում է Pi- ից ստեղնաշարի մուտքագրում, բայց, իհարկե, Pi- ին կցված ստեղնաշար չկա, այնպես որ ծրագիրը կախված է `լավ չէ:

Haveրագիրը գործարկելու համար դուք պետք է օգտագործեք մի փոքր այլ տեխնիկա: Սկզբունքորեն, դուք ստեղծում եք «կեղծ» հիմնական դասի ֆայլ, որն ըստ էության ոչինչ չի անում, և այն ճանաչում եք որպես ներբեռնումից հետո կատարվելիք ծրագիր: Այս դեպքում «կեղծիքը» մահապատժի է ենթարկվում, և այնուհետև կարող եք գործարկել ձեր «իրական» ծրագիրը անմիջապես Pi- ով:

Այս տեխնիկան օգտագործելու համար նախ ստեղծեք նոր հիմնական դաս.

1. Բերեք ծրագրի ընտրացանկը, ինչպես 5-րդ քայլում և կտտացրեք Նոր-> Java հիմնական դասարան: Դուք կտեսնեք Նոր Java հիմնական դասի պատուհանը:
2. Դասի անվանում դաշտում մուտքագրեք անուն: Անունը կարող է լինել այն ամենը, ինչ ձեզ դուր է գալիս; Ես օգտագործել եմ «Dummy» - ը: Փաթեթի դաշտը թույլ է տալիս բացահայտել դասի փաթեթը. Դուք ընտրում եք փաթեթ ՝ օգտագործելով դաշտի աջ կողմում գտնվող բացվող պատուհանը: Դասը կարող է լինել ձեր «իրական» ծրագրի նույն փաթեթում կամ այլ փաթեթում; Նոր դասարանը դրեցի նույն փաթեթում: Կտտացրեք Ավարտել: Այժմ դուք կտեսնեք NetBeans- ի հիմնական պատուհանը ՝ նոր ֆայլով ՝ վերևի աջ վահանակում (նկար մեկ): Ես ավելացրեցի պարզ տպագիր հայտարարություն Pi- ով աշխատելու մասին, բայց իրականում ոչինչ պետք չէ:

Ներբեռնումից հետո «Dummy» գործարկելու համար դուք պետք է այն դարձնեք «լռելյայն կատարման հիմնական դասը» նախագծի համար.

1. Բացեք Project Properties- ը, ինչպես քայլ 5 -ում: Ընտրեք Run կատեգորիան: Կտտացրեք Փնտրել հիմնական դասի դաշտի աջ կողմում: Դուք կտեսնեք «Թերթել հիմնական դասեր» թռուցիկը (նկար երկրորդ):
2. Ընտրեք «Dummy» դասը: Կտտացրեք Ընտրել հիմնական դասը: Դուք ևս մեկ անգամ կտեսնեք րագրի հատկությունները:
3. Սեղմեք OK: Դուք կվերադառնաք հիմնական պատուհանը:

Այժմ, երբ կտտացնում եք Run պատկերակին, NetBeans- ը համապատասխանում է/կառուցում է ամբողջ նախագիծը, ներբեռնում է Pi- ի դասի բոլոր ֆայլերը պարունակող բանկան և իրականացնում է «Dummy» դասը (նկար երեք):

Pi- ում ձեր իրական ծրագիրը գործարկելու համար այժմ պետք է օգտագործեք java հրամանը «classpath» տարբերակով, որը պահանջում է, որ դուք հստակորեն նշեք կատարման հիմնական դասը: Ssh հաճախորդից գնացեք ձեր նախագծի dist գրացուցակ: Իշտ հրամանը ունի հետևյալ ձևը.

java -cp project_name.jar package_name.class_name

Նախագծի անունը ակնհայտորեն վերաբերում է նախագծին. որը փոխվում է միայն նոր նախագծով զբաղվելիս: Package_name- ը, իհարկե, վերաբերում է փաթեթին, և class_name- ը վերաբերում է կատարման հիմնական դասին: Ինչպես արդեն նշվեց, նախագիծը կարող է պարունակել բազմաթիվ փաթեթներ: Նմանապես, փաթեթը կարող է պարունակել բազմաթիվ դասեր, և բոլորը կարող են լինել հիմնական դասեր կամ ծրագրեր, որոնք կարող են կատարվել հրամանի տողից: Այսպիսով, «դասուղու» տեխնիկան բավականին օգտակար է բազմաթիվ դասարաններով բարդ ծրագրեր մշակելու համար, որոնցից մի քանիսը հիմնական դասեր են միայն միավորների թեստավորմանն աջակցելու համար:

Հետևյալ հրամանը կատարում է իմ օրինակելի ծրագիրը.

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Քայլ 10. Օգտագործեք NetBeans գրադարանի կառավարումը

Բարդ ծրագրերի ամենադժվար, բայց ամենակարևոր ասպեկտներից մեկը գրադարանների հետ գործ ունենալն է, այսինքն ՝ ուրիշի արդեն գրած ծածկագիրը: NetBeans- ը հիասքանչ աշխատանք է կատարում `հեռացնելով գրադարանի կառավարման ցավը:

Որպես օրինակ ես կօգտագործեմ Pi4J- ը, որը Java ծրագրերին հնարավորություն է տալիս մուտք գործել Raspberry Pi GPIO, I2C ավտոբուս և այլ սարքավորումների I/O: Pi4J- ն աջակցության միայն մեկ օրինակ է ՝ Java- ով Pi- ով շատ զվարճալի բաներ կատարելու համար:

Նախ պետք է գրադարանը ներբեռնեք ձեր աշխատատեղ: Տես Pi4J ներբեռնման էջը: Քանի որ դուք Pi4J- ը Pi- ի վրա չեք տեղադրում, ներբեռնեք ձեր աշխատատեղի փոստային հասցեն: Zip- ի ներբեռնումից հետո դուք կարող եք կամ չպետք է հստակորեն բացեք ֆայլը:

Այժմ դուք պետք է ստեղծեք «գլոբալ գրադարան» NetBeans- ում.

1. NetBeans- ի հիմնական ընտրացանկում կտտացրեք Գործիքներ -> Գրադարաններ: Դուք կտեսնեք «Մրջյունների գրադարանի կառավարիչ» պատուհանը (նկար 1):
2. Կտտացրեք Նոր գրադարան ներքևի ձախ մասում: Դուք կտեսնեք «Նոր գրադարան» պատուհանը (նկար երկու):
3. Մուտքագրեք իմաստալից անուն, որը ցանկանում եք օգտագործել և կտտացրեք OK: Դուք կրկին կտեսնեք Ant գրադարանի մենեջերի պատուհանը: Այժմ այն ցույց է տալիս ձեր ստեղծած նոր գրադարանը (նկար երեք):
4. Կտտացրեք Ավելացնել JAR/Թղթապանակ աջ կողմում: Դուք կտեսնեք Browse JAR/Folder թռուցիկը (նկար չորս):
5. Գնացեք և ընտրեք pi4j-core.jar: Այնուհետեւ կտտացրեք Ավելացնել JAR/Թղթապանակ: Դուք կվերադառնաք «Մրջյունների գրադարանի կառավարիչ» թռուցիկ:
6. Մրջյունների գրադարանի մենեջերում բացվող պատուհանում կտտացրեք OK: Դուք կվերադառնաք NetBeans- ի հիմնական պատուհան:

Դուք ավելացրել եք գրադարանը, որպեսզի այն կարողանա օգտագործվել ցանկացած նախագծում: Այժմ դուք պետք է գրադարան ավելացնեք ձեր նախագծին.

1. Բերեք «Projectրագրի հատկություններ» պատուհանը (տես քայլ 5) և ընտրեք «Գրադարաններ» կատեգորիան (նկար հինգ):
2. Կտտացրեք Ավելացնել գրադարան բացվող պատուհանի աջ կողմում: Դուք կտեսնեք «Ավելացնել գրադարան» պատուհանը (նկար վեց):
3. Գնացեք գրադարան և ընտրեք այն: Այնուհետև կտտացրեք Ավելացնել գրադարան: Կրկին կտեսնեք «Projectրագրի հատկություններ» պատուհանը: Այժմ գրադարանը հայտնվում է բացվող պատուհանում կազմվող ժամանակի գրադարանների ցանկում:
4. Propertրագրի հատկություններ բացվող պատուհանում կտտացրեք OK: Դուք կվերադառնաք հիմնական պատուհանը:

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

Գրադարանն անհրաժեշտ է երեք անգամ ՝ կազմել, կազմել և կատարել: Բարեբախտաբար, NetBeans- ի հետ միասին, գրադարանն ավելացնելը, ինչպես ցույց է տրված վերևում, կարգավորում է բոլորը: Սա հաստատելու համար ես ստեղծել եմ մեկ այլ հիմնական դաս, որը կատարում է Pi4J- ում I2C հնարավորությունը օգտագործելու համար անհրաժեշտ բացարձակ նվազագույնը (նկար յոթ): Այն փաստը, որ ցուցադրման սխալներ չկան, նշանակում է, որ TestPi4J դասը կազմում է: Սեղմելով Run հաջողությամբ կառուցում և ներլցումներ; NetBeans- ը բեռնում է գրադարանը, բացի բանկա ֆայլից, ուստի ծրագիրը կիրականացվի: Վերջինս հաստատելու համար կարող եք օգտագործել 9 -րդ քայլի տեխնիկան և ssh հաճախորդում մուտքագրել հետևյալ հրամանը (dist գրացուցակից).

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Ուսուցիչ է հասկանալ, թե ինչպես է NetBeans- ը զբաղվում գրադարաններով: Մինչև ձեր նախագծի dist գրացուցակում, նշեք գրացուցակի բովանդակությունը (օգտագործեք ls հրամանը) և կտեսնեք lib ենթաուղեկալույց: Թվարկեք այդ գրացուցակի բովանդակությունը և կտեսնեք գլոբալ գրադարանում բացահայտված բանկա ֆայլը, որն իմ օրինակում pi4j-core.jar է: Բոլոր գրադարանները, որոնք ավելացնում եք նախագծին, կհայտնվեն lib գրացուցակում և, հետևաբար, հասանելի կլինեն նախագծի jar ֆայլի բոլոր ծրագրերին:

Քայլ 11: Գնացեք զվարճացեք:

Ես նկարագրել եմ Raspberry Pi- ի համար Java- ի շատ արդյունավետ զարգացման հասնելու մոտեցումը: Raspberry Pi- ն շատ տարածված տեխնոլոգիա է նախագծերի լայն սպեկտրի համար: Java- ն մասնագիտացված ծրագրավորման լեզու է, որն առաջարկում է կատարողական առավելություններ Python- ի նկատմամբ և ապահովում անվտանգության առավելություններ C/C ++ - ի նկատմամբ: NetBeans- ը պրոֆեսիոնալ դասարանի IDE է, որը մեծապես բարձրացնում է ծրագրավորողի արտադրողականությունը:

Կարծում եմ, որ համադրությունը բավականին ազդեցիկ է: Այժմ, գնացեք զվարճացեք, օգտագործելով ձեր նախագծերի համադրությունը: