Ufanisi wa Maendeleo ya Java kwa Raspberry Pi: Hatua 11 (na Picha)

2024 Mwandishi: John Day | [email protected]. Mwisho uliobadilishwa: 2024-01-30 12:48

Hii inaelezea njia inayofaa sana ya kukuza programu za Java kwa Raspberry Pi. Nimetumia njia hiyo kukuza uwezo wa Java kuanzia msaada wa kiwango cha chini cha kifaa hadi mipango mingi na msingi wa mtandao. Njia sio nzuri tu, ni bure!

Kimsingi, njia hiyo ni maendeleo ya mbali kutumia NetBeans. NetBeans inaendesha kituo cha kazi (desktop au kompyuta ya mbali, sio Raspberry Pi) iliyounganishwa kupitia Wifi kwa Raspberry Pi. Mara tu kila kitu kinapowekwa vizuri, unaweza kuandika programu ya Java kwenye NetBeans na kisha bonyeza mara moja unakusanya na kujenga programu kwenye kituo cha kazi, kupakua programu hiyo kwa Pi, kuendesha programu kwenye Pi, na kutoa pato kwa kiweko cha NetBeans. Uchawi! Unaweza hata kurekebisha programu inayoendesha, kuweka njia za mapumziko na kuchunguza maadili yanayobadilika. Uchawi zaidi!

Utangulizi wa utangulizi huu unaelezea msukumo wa kutumia Java na kwa maendeleo ya mbali kutumia NetBeans. Ikiwa unajali motisha, soma. Ikiwa haujali, nenda hatua ya 1.

Kwa nini utumie Java kwenye Raspberry Pi?

Kuna lugha nyingi za programu zinazopatikana kwa Raspberry Pi, lakini nitapunguza majadiliano kwa lugha za programu za "daraja la kitaalam" ambazo zinalenga mipango ya pekee, inasaidia kazi nyingi, kuruhusu vifaa na ufikiaji wa mtandao, nk Hiyo inamaanisha Java, Python, au C / C ++. Matoleo ya hivi karibuni ya Raspbian ni pamoja na maendeleo na msaada wa wakati wa kukimbia kwa lugha hizi zote.

Python ni kweli "imekuzwa" kwa matumizi ya Pi, angalau kwa sehemu kwa urahisi wa kujifunza kwa watengenezaji vipya. Mimi ni mtaalamu wa programu na sipendi Python kwa sababu ya kupenda kutokukubaliwa kwa sifa kadhaa, kwa mfano, kuchapa kwa nguvu. Kuna tabia moja ya chatu ambayo kupenda kwangu ni lengo - utendaji. Chanzo hiki kinaonyesha kuwa Java huwa haraka kuliko Python 3, na kwa kweli inaweza kukimbia mara mia kwa kasi, kulingana na kazi.

C kwa maoni yangu, ni "lugha ya mashine ya kiwango cha juu", yaani, kitu ambacho ni karibu sana na vifaa vya mfumo, au angalau mfumo wa uendeshaji. Unaweza kufanya kitu chochote sana, na unaweza kuifanya haraka iwezekanavyo; kwa kweli, chanzo hiki kinadokeza C inaweza kukimbia hadi 7X haraka kama Java. Mimi pia sipendi C kwani mimi (subjective) sipendi sifa zake zingine ambazo mimi hupata mionzi, ya kizamani, au zote mbili; kwa mfano, viashiria wazi. Kwa kweli, ukweli kwamba unaweza kufanya chochote inamaanisha kuwa wewe ni mdudu asiyejulikana (kwa mfano, hesabu mbaya ya pointer au memcpy yenye makosa) mbali na kuandika kumbukumbu na uwezekano wa kugonga programu au hata mfumo mzima. Java inazuia hatari kama hizo, kwa hivyo Java ni salama zaidi. Ninahisi usalama pia unaboresha uzalishaji wa programu. Ninaona C ++ kama "kanga" inayolenga kitu karibu na C ambayo haifanyi chochote kuondoa hatari za C.

Jambo kuu: Java ni haraka kuliko Python. Java ni salama kuliko C.

Je! Kuna mapungufu wakati wa kutumia Java?

Hadi sasa, nimeweza kufanya kila kitu katika Java ambacho ninaweza kufanya katika Python. Kuna mambo ambayo mtu anaweza kufanya katika C ambayo mtu hawezi kufanya katika Java, lakini tena, hadi sasa kila kitu nilichotaka kufanya kimeshughulikiwa na mashabiki wa Java katika jamii ya Pi. Nitatoa mfano katika hatua ya baadaye. Hiyo ilisema, nimenunua sensorer kutoka kwa wauzaji ambao walitoa "madereva" kwa sensorer tu katika Python (au C / C ++ kwa Arduino), kwa hivyo ilibidi niandike sawa Java; juhudi ya ziada sio lazima iwe na tija, lakini inaweza kusababisha ufahamu mkubwa juu ya utendaji wa sensa.

Kwa nini maendeleo ya kijijini kulingana na NetBeans?

Nimegundua kuwa maendeleo ya kijijini ya msingi wa NetBeans huongeza sana tija wakati wa kutumia Java kwa Raspberry Pi. Nina hakika kuwa unaweza kutumia njia kuunda programu za haraka na salama, kwa sababu ya tabia ya asili ya Java, wakati unaziandika, kuziunda na kuzitatua haraka sana kuliko njia zingine nilizozipata, kwa sababu ya maendeleo ya mbali kutumia "mtaalam daraja "Mazingira Jumuishi ya Maendeleo ya NetBeans (IDE).

Inaweza kuwa muhimu kujadili kwa kifupi "njia zingine". Zote zinakidhi vigezo vya msingi ambavyo Raspberry Pi haina kibodi, panya, au onyesho lililounganishwa. Kuna sababu nyingi za kigezo hiki, lakini sababu yangu ya msingi ni kwamba ninaunda roboti za rununu, na sitaki Pi iunganishwe kwa pembejeo yoyote isipokuwa mifumo ya roboti, hata wakati wa maendeleo.

Seva ya VNC iliyojumuishwa katika Raspbian hutoa kielelezo cha kielelezo cha kielelezo cha mtumiaji (GUI) ambacho kinaruhusu aina ya maendeleo ya kijijini, ambapo ni GUI ya mbali tu inayoendesha kituo cha kazi na kila kitu kingine, kuandika, kukusanya na kujenga, hufanyika kwenye Pi. Na VNC ni rahisi kutumia zana za maendeleo zenye uwezo wa Java ambazo zinasafirisha Raspbian, kama BlueJ, Geany, na Greenfoot. Baadhi ya hizi zinaweza kuzingatiwa kama IDE; Walakini, ninawapata mbali na daraja la kitaalam.

Kitaalam inawezekana kusanikisha kiwango cha kitaalam cha Java IDE kama Eclipse au NetBeans kwenye Raspberry Pi na kuitumia kwa mbali kupitia VNC. Ripoti, na busara, zinaonyesha kuwa matokeo yatakuwa ya kukatisha tamaa, kwa sababu ya alama kubwa ya kumbukumbu na nguvu ya CPU kama vile IDE zinahitaji, na pia latency ya mtandao iliyoletwa na GUI ya mbali.

Eclipse na NetBeans zinaendesha vizuri sana kwenye kituo cha kazi. Na Eclipse, nambari ya kuandika ni uzoefu wa kupendeza, hata hivyo, kujenga programu sio; kupakua programu lazima ifanyike nje ya Eclipse; kutekeleza mpango kwenye Pi ni huru kabisa na Kupatwa. Matokeo ya jumla ni hatua nyingi, karibu chungu, mchakato ambao hauwezi kusaidia utatuzi wa mbali. NetBeans imejumuisha kujumuika, kujenga, kupakua, utekelezaji wa kijijini, na utatuzi wa mbali, na kuifanya iwe njia bora.

Hatua ya 1: Sanidi Raspberry Pi

Kutumia mbinu ya maendeleo ya mbali lazima uanze kwa kuweka lengo la Raspberry Pi. Kuna rasilimali nyingi, pamoja na Maagizo, inapatikana kusaidia kuanzisha Raspberry Pi. Tazama hii kwa misingi ya kuanzisha Pi (na zaidi).

Hii ya kufundisha inakufikiria

• sakinisha Raspbian ya hivi karibuni; hakikisha unarekodi Kitambulisho cha mtumiaji wa Pi na nywila
• weka Wifi na unganisha kwenye router yako (tazama hii); hakikisha unarekodi anwani ya IP ya Pi
• wezesha SSH (tazama hii) kuruhusu ufikiaji wa kijijini kwa Pi kutoka kituo cha kazi

Mara tu ukimaliza usanidi, unaweza kuzima na kukata onyesho, kibodi, na panya kutoka kwa Pi. Hii ni moja ya faida muhimu kwa maendeleo ya mbali. Lazima uache dongle yoyote ya Wifi iliyounganishwa (haihitajiki, kwa kweli, kwa mfano wa Pi 3 au Pi Zero W), na kisha uweze kuongeza nguvu ya Pi.

Ili kujaribu, fungua mteja wa ssh kwenye kituo chako cha kazi, kwa mfano, Kituo kwenye MacOS au putty kwenye Windows. Kisha ingiza amri ya ssh (salama shell) na fomu ifuatayo:

ssh the_pi_ip_adress -l the_pi_user_id

Unapaswa kupata kidokezo cha kuingiza nywila yako ya mtumiaji wa Pi. Ikiwa hakuna haraka inayoonekana, angalia kuhakikisha kuwa umeingiza anwani sahihi ya IP kwenye amri ya ssh. Ingiza nywila yako (itafichwa) na unapaswa kuona mwendo wa ganda la Pi ambalo linaonekana kama hii:

pi @ raspberrypi: ~ $

Ikiwa hauoni haraka, angalia kitambulisho cha mtumiaji na nywila uliyotumia.

Sasa lazima utafute njia ya kwenda kwa wakati wa kukimbia wa Java na uthibitishe toleo chaguo-msingi ni Java 8 (inapaswa kuwa kweli kwa Raspbian wa hivi karibuni). Ili kupata njia ya kukimbia kwa Java, kwenye mteja wa ssh ingiza amri

njia mbadala za sasisho za sudo - onyesha java

Unapaswa kuona majibu na mistari miwili ya kwanza ambayo inaonekana kama ifuatayo:

java - hali ya kiotomatiki

kiunga toleo bora ni / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java

"-8-" katika mstari wa pili inathibitisha kuwa wakati wa kukimbia ni Java 8. Rekodi njia kwenye laini ya pili kwani utaihitaji kusanidi NetBeans kwa maendeleo ya mbali katika hatua ya baadaye.

Ikiwa wakati wa kukimbia sio Java 8, kwenye mteja wa ssh weka amri ifuatayo ili ugeukie Java 8 (ukifikiri kuwa imewekwa)

njia mbadala za sasisho za sudo --config java

Hatua ya 2: Sakinisha NetBeans kwenye Kituo cha Kazi

Sasa unahitaji kusanikisha NetBeans kwenye kituo chako cha kazi. Elekeza kivinjari chako cha kituo cha kazi kwenye ukurasa wa kupakua wa NetBeans. Utaona vifungu kadhaa vinavyowezekana vinavyounga mkono matoleo mawili ya Java na lugha zingine. Wote unahitaji kwa maendeleo ya Java kwa Raspberry Pi ni Java SE, lakini unaweza kupata kifungu cha Java EE au kifungu cha All. Mara baada ya kuamua ni kifungu gani unachotaka bonyeza kitufe cha Upakuaji kinacholingana. Unaweza kupata maagizo ya ziada ya usanidi wa kituo chako cha kazi cha OS hapa.

Mara tu ikiwa umeweka NetBeans, anza (inaweza kufanya hivyo kiatomati baada ya usanikishaji). Unapaswa kuona dirisha kuu la NetBeans kama inavyoonekana kwenye picha. Picha hiyo ilichukuliwa kwenye Mac, na dirisha kuu linaweza kuonekana tofauti kwenye Windows.

Mara baada ya kufanikiwa kusanikisha na kuanza NetBeans, endelea kwa hatua inayofuata.

Hatua ya 3: Sanidi Raspberry Pi Kama Jukwaa la Kijijini katika NetBeans

Vitendo vifuatavyo vinasanidi Pi ya Raspberry kama jukwaa la mbali la Java SE la NetBeans. Hii inawezesha NetBeans kupakua na kutekeleza programu za Java kwenye Pi. Unaweza kupata maelezo ya jumla hapa.

KUMBUKA: Katika hatua hii na ifuatayo, ninaonyesha maadili maalum kwa mazingira yangu kwa mambo anuwai ya usanidi na usimbuaji; yako itakuwa wazi kuwa tofauti.

Kusanidi Pi kama jukwaa la mbali:

1. Kwenye bar ya menyu kuu ya NetBeans, chagua Zana -> Majukwaa ya Java. Utaona kidirisha cha kidukizo cha Meneja wa Jukwaa la Java (picha moja).
2. Bonyeza Ongeza Jukwaa chini kushoto. Utaona popup Jukwaa la Java [aina ya jukwaa] ibukizi (picha mbili).
3. Chagua Toleo la kawaida la Java ya mbali. Bonyeza Ijayo. Utaona Jukwaa la Ongeza Java [weka jukwaa la mbali] kidukizo (picha tatu inaonyesha dukizo baada ya kuingia maadili sahihi ya mazingira yangu mashambani).
4. Kwenye uwanja wa Jina la Jukwaa ingiza jina la Pi. Unaweza kutumia kitu chochote sana, lakini lazima iwe ya kipekee.
5. Kwenye uwanja wa Jeshi ingiza anwani ya IP ya Pi inayopatikana katika hatua ya 1.
6. Kwenye uwanja wa jina la mtumiaji ingiza jina la mtumiaji ulilotumia katika hatua ya 1.
7. Acha Kutumia Uthibitishaji wa Nenosiri uliochaguliwa na kwenye uwanja wa Nenosiri ingiza nywila uliyounda katika hatua ya 1.
8. Kwenye uwanja wa Njia ya Mbali ya JRE lazima uingize njia nyingi kwa wakati wa kukimbia wa Java kwenye Pi. Katika hatua ya 1, ilikuwa / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java. Walakini lazima uangushe / bin / java katika thamani ya uwanja.
9. NetBeans hupakua programu inayoendeshwa kwa saraka inayofanya kazi kwenye Pi, iliyotambuliwa katika uwanja wa Working Dir. Chaguo-msingi ni / the_Pi_user_ID / NetBeansProjects / na inakubalika kabisa. Unaweza kutumia kitu tofauti ikiwa unatamani, ingawa lazima ipatikane kwa_Pi_user_ID (picha ya tatu).
10. Bonyeza Maliza chini kulia mwa ibukizi. Baada ya usindikaji, unapaswa kuona tena dirisha dukizi la Meneja wa Jukwaa la Java. Sasa unapaswa kuona Pi yako ya mbali (chini ya jina ulilotumia katika hatua 4 hapo juu) chini ya kategoria Remote Java SE (picha ya nne).
11. Bonyeza Jukwaa la Mtihani chini kushoto ili kujaribu unganisho kati ya NetBeans na Pi yako. Kwanza utaona kidukizo kikisema Kuthibitisha Jukwaa la Kijijini. Ukifanikiwa, utapata kidukizo cha pili kinachoonyesha Muunganisho… imeanzishwa kwa mafanikio. Ikiwa sivyo, unahitaji kuangalia na kusahihisha habari uliyoingiza kwenye Jukwaa la Ongeza Java [weka jukwaa la mbali] ibukizi kwa vitendo 5-9 hapo juu. Unaweza kufanya hivyo kutoka kwa kidukizo cha Meneja wa Jukwaa la Java; chagua tu jukwaa lako la Pi na kisha uhariri sehemu kwenye upande wa kulia wa kidukizo.
12. Baada ya unganisho lililofanikiwa, bofya Funga kwenye kidukizo cha Meneja wa Jukwaa la Java. Sasa utaona dirisha kuu la NetBeans.

Sasa furaha ya kweli inaweza kuanza!

Hatua ya 4: Unda Mradi wa Java kwenye Kituo cha Kazi

Hii haikusudiwi kuwa ufafanuzi kamili wa jinsi ya kutumia NetBeans, au Java, lakini nitaelezea hatua ndogo za kuandika programu katika NetBeans kwenye kituo cha kazi na, mwishowe, kuendesha programu hiyo kwa mbali kwenye Raspberry Pi.

Katika NetBeans lazima kwanza uunda mradi wa kushikilia darasa la Java kwa programu. Kwa kuongezea, katika Java, darasa hukaa katika vifurushi kusaidia shirika na usalama. Kuunda mradi na kwa hiari kuunda kifurushi na faili ya darasa:

1. Kwenye dirisha kuu la NetBeans, bonyeza ikoni mpya ya mradi (2 kutoka kushoto). Utaona Mradi Mpya [chagua mradi] ibukizi (picha moja).
2. Chaguo-msingi (Jamii: Java, Mradi: Maombi ya Java) ni sahihi kwa mfano huu, kwa hivyo bonyeza tu Ijayo. Utaona Kidokezo kipya cha Maombi ya Java [jina na eneo] [picha mbili zinaonyesha maadili kwa mfano wangu]. KUMBUKA: Nimebadilisha maelezo yangu ya mtumiaji kwa kutumia mstatili wenye rangi.
3. Kwenye uwanja wa Jina la Mradi, ingiza jina halali la mradi wa Java uliochagua. Jina lazima lianze na herufi kubwa, na mkusanyiko unaonyesha kesi ya ngamia wakati wa kusadikisha maneno.
4. Sehemu ya Mradi wa Mahali inadhibiti ambapo mradi unakaa katika mfumo wako wa faili. Chaguo-msingi hutofautiana kulingana na mfumo wa uendeshaji, lakini ni salama kukubaliwa.
5. Sehemu ya Folda ya Mradi hukuruhusu kudhibiti jina la folda ya mradi huo. Ninaona ni bora kutumia chaguo-msingi, ambayo ni mkusanyiko wa uwanja wa Mahali na uwanja wa Jina.
6. Wakati kisanduku cha kuangalia cha Uundaji wa darasa kuu kinakaguliwa NetBeans huunda kifurushi na faili kuu ya darasa (mpango ambao unaweza kuendeshwa kutoka kwa laini ya amri) na jina sawa na mradi huo. Nadhani kawaida haipaswi kukaguliwa, lakini katika kesi hii, nitaiacha ikiangaliwa ambayo huondoa vitendo dhahiri vinginevyo vinavyohitajika kufanya hivyo (picha mbili).
7. Bonyeza Maliza kuunda mradi, kifurushi na faili kuu ya darasa. Sasa kidirisha cha kushoto cha juu cha dirisha kuu la NetBeans kinaonyesha mradi wako, ambao una kifurushi kimoja, ambacho nacho kina faili moja ya darasa na njia kuu (). Kidirisha cha juu cha kulia kina kificho chaguomsingi cha darasa kuu (mpango) uliozalishwa kiatomati na NetBeans (picha tatu).

Kwa wakati huu, unaweza kuandika nambari kadhaa kwa njia kuu na kuiendesha kwenye kituo cha kazi. Hiyo inaweza kuhitajika wakati mwingine, lakini haihitajiki kwa Agizo hili, kwa hivyo endelea kwa hatua inayofuata.

Hatua ya 5: Sanidi Mradi wa NetBeans Kuendesha kwa mbali kwenye Raspberry Pi

Ili kusanidi mradi wa NetBeans, na programu inayo, kuendesha kwa mbali kwenye Raspberry Pi, fanya yafuatayo:

1. Bonyeza kidole kulia au 2 (inategemea kituo cha kazi OS) kwenye mradi kwenye kidirisha cha Miradi kwenye dirisha kuu la NetBeans kuleta menyu ya mradi na bonyeza Mali. Utaona dukizo la Mali ya Mradi (picha inaonyesha dukizo na maadili sahihi ya mfano wangu).
2. Chini ya Jamii kushoto, chagua Run.
3. Bonyeza Mpya kulia kwa uwanja wa Usanidi. Katika matokeo ya kuunda Undaji mpya wa Usanidi, ingiza jina la usanidi na bonyeza OK. Jina linaweza kuwa chochote; Nilitumia tu jina la jukwaa ("My Pi"). Mara nyingine tena utaona dukizo la Sifa za Mradi.
4. Bonyeza ikoni ya kushuka upande wa kulia wa uwanja wa Jukwaa la Runtime. Kutoka kwenye orodha kwenye kidukizo, chagua jukwaa la mbali ulilounda mapema (katika mazingira yangu, "My Pi").
5. Bonyeza OK ili kuanzisha jukwaa la mbali la mradi. Mara nyingine utaona dirisha kuu.

Sasa uko tayari kuandika nambari na kuendesha programu hiyo kwa mbali.

Hatua ya 6: Andika Programu ya Java kwenye Kituo cha Kazi na Uiendeshe kwenye Raspberry Pi

Jopo la kulia kwenye dirisha kuu la NetBeans linaonyesha faili kuu ya darasa iliyoundwa na NetBeans. Chapa taarifa rahisi ya kuchapisha kwa njia kuu ya faili ya darasa (picha moja). Sasa ni mpango kamili wa Java ambao hufanya kitu, ingawa ni kitu rahisi sana.

Ili kuendesha programu kwenye Pi, bonyeza kitufe cha Run (mshale wa kijani unaoelekeza kushoto) kwenye dirisha kuu. NetBeans inakusanya nambari, inaunda faili ya jar, inapakua faili ya jar kwenye Raspberry Pi inayotambuliwa na jukwaa la mbali, inafanya programu hiyo kwenye Pi, inachukua programu (System.out) ya programu, na inaunga pato hilo kwa NetBeans Paneli ya pato kulia chini ya dirisha kuu (picha mbili).

Sasa umepanua sana ujuzi wako wa kuweka miradi kwenye Raspberry Pi! Lakini subiri…. Kuna zaidi!

Hatua ya 7: Ondoa Programu ya Java na NetBeans

Moja ya huduma zenye nguvu zaidi za mazingira ya Jumuishi ya Mazingira ya Maendeleo kama NetBeans ni uwezo wa kurekebisha mpango wakati wa kuendesha. NetBeans hukuruhusu kuongeza matumizi kamili ya vifaa vya utatuzi wakati unafanya kazi mbali. Hii ni pamoja na kuweka maeneo ya mapumziko katika maeneo "muhimu" au "matata" katika programu na kuchunguza thamani ya vigeuzi katika hali ya sasa ya utekelezaji.

Programu rahisi katika hatua ya mwisho ni rahisi sana kuonyesha utatuzi, kwa hivyo niliongeza nambari ya ziada kwenye programu. Nambari ya ziada inaongeza vigeuzi viwili.

Ili kutumia zana za utatuzi, lazima kwanza uweke sehemu moja au zaidi ya mapumziko. Kuweka kituo cha kuvunja, bonyeza nambari ya laini ambapo unataka kusimamisha utekelezaji; ikoni ya mstatili nyekundu inaonekana, na laini nzima hupata msingi nyekundu (picha ya kwanza).

Kutatua programu inayoendesha kwenye Pi, bonyeza ikoni ya Kutatua (mara moja kulia kwa ikoni ya Run) kwenye dirisha kuu la NetBeans. Kama ilivyo kwa utekelezaji wa kawaida, NetBeans hukusanya, huunda, kupakua, kutekeleza, kunasa pato, na kunasa pato hilo. Lakini kwa utatuzi, NetBeans huacha utekelezaji wakati wa mapumziko na hukuruhusu kukagua hali ya utekelezaji (picha mbili, ikionesha kidirisha cha Viwambo chini kulia).

Utekelezaji unasimama mahali pa mapumziko kabla ya kutekeleza maagizo kwenye mstari na mahali pa kuvunja. Asili ya kijani inaonyesha taarifa inayofuata kutekelezwa. Kwa hivyo katika mfano wangu, na sehemu ya kuvunja kwenye laini ya 9, kutofautisha a bado haipo, kidogo kuwa na thamani.

Sasa hover mshale juu ya aikoni ya menyu ya utatuzi kwenye dirisha kuu (aikoni ya kwanza ya mshale-chini mara mbili kulia kwa ikoni ya Kutatua) na ubonyeze ikoni ya Step Over (ina hati ya samawati nyuma na mshale wa kijani kinyume cha saa. mbele). [KUMBUKA: ikiwa utafanya dirisha kuu la NetBeans kuwa pana kwa kutosha, menyu ya utatuzi inapanuka na aikoni za kitendo cha utatuzi zinaonekana kulia kwa ikoni ya Kutatua.] NetBeans hufanya taarifa wakati wa kuvunja na kusitisha utekelezaji kabla ya taarifa inayofuata. Sasa utaona kuwa anuwai ipo na ina thamani inayotarajiwa (picha ya tatu).

Bonyeza ikoni ya Hatua Zaidi mara mbili. Utaona kwamba vigeuzi vyote vitatu vina maadili; kumbuka kuwa c bado ni sifuri (picha ya nne).

Bonyeza ikoni ya Hatua Zaidi mara moja. Utaona kwamba ubadilishaji c sasa una thamani inayofaa, i.e., jumla ya anuwai a na b (picha ya tano).

Mwishowe, kwenye menyu ya utatuzi, bonyeza ikoni ya Run (mduara wa kijani na mshale mweupe). Hiyo inasababisha utekelezaji kuendelea hadi mahali pengine, au hadi mwisho wa programu, yoyote ambayo inakuja kwanza. Sasa paneli ya Pato inaonekana na inaonyesha pato sawa na utekelezaji wa kawaida, katika kesi hii maandishi katika taarifa ya kuchapisha.

Hatua ya 8: Tekeleza Mpango Huru wa Wavu

Wakati unaweza kuja wakati unataka kutekeleza programu yako kwenye Raspberry Pi, bila "msaada" au "kuingiliwa" kutoka kwa NetBeans. Ni rahisi sana. Kwanza, fungua mteja wa ssh kwa Pi yako.

Kumbuka kutoka hatua ya 3 kwamba NetBeans inaweka jar ya mradi wako kwenye saraka inayofanya kazi kwenye Pi. Msingi msingi ni / home / pi / NetBeansProjects for user pi. Saraka maalum ina jina sawa na mradi wako. NetBeans huweka jar kwenye saraka ndogo inayoitwa dist. Kwa mfano wangu, njia kamili ni / home / pi / NetBeansProjects / MyRemoteProg / dist. Katika mteja wa ssh kwenye Pi, kutekeleza programu unaweza kutumia amri ya java na chaguo la 'jar':

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

Utaona matokeo ya utekelezaji katika mteja wa ssh; katika mfano wangu, pato litakuwa

Halo kutoka kwa Raspberry Pi!

Hii inafanya kazi kwa sababu habari kwenye faili ya jar hutambua ni darasa gani kuu kwenye jar kufanya.

Unaweza pia kubadilisha saraka inayofanya kazi (kupitia cd) hadi eneo la faili ya jar na kisha utoe amri fupi ili kutoa matokeo sawa.

java -jar MyRemoteProg.jar

Hatua ya 9: Jenga na Upakue, lakini Usitekeleze Programu Kupitia NetBeans

Kuna hali ambapo unataka NetBeans kujenga na kupakua programu yako, lakini usiitekeleze. Hali kama hiyo hutokea wakati programu yako inahitaji uingizaji wa kibodi. Ikiwa ndivyo ilivyo, ukitumia mbinu katika hatua ya awali, mara tu unapojenga na kupakua, programu hiyo itatekelezwa kwenye Raspberry Pi na kwa hivyo inatarajia uingizaji wa kibodi kutoka kwa Pi, lakini kwa kweli, hakuna kibodi iliyoambatanishwa na Pi, kwa hivyo mpango hutegemea - sio mzuri.

Lazima utumie mbinu tofauti kutekeleza mpango huo. Kimsingi, unaunda faili kuu ya "dummy" ambayo kwa kweli haifanyi chochote, na kuitambua kama mpango utakaotekelezwa baada ya kupakuliwa. Katika kesi hii, "dummy" hunyongwa, na unaweza basi kuendesha programu yako "halisi" moja kwa moja kwenye Pi.

Kutumia mbinu hii, kwanza tengeneza darasa kuu kuu:

1. Kuleta menyu ya mradi kama katika hatua ya 5 na bonyeza New-> Java Class Class. Utaona kidukizo kipya cha Darasa Kuu la Java.
2. Kwenye uwanja wa Jina la Darasa ingiza jina. Jina linaweza kuwa chochote unachopenda; Nilitumia "Dummy". Sehemu ya Kifurushi hukuruhusu kutambua kifurushi cha darasa; unachagua kifurushi ukitumia kushuka chini kulia kwa uwanja. Darasa linaweza kuwa kwenye kifurushi sawa na programu yako "halisi" au kwenye kifurushi tofauti; Niliweka darasa jipya kwenye kifurushi kimoja. Bonyeza Maliza. Sasa utaona dirisha kuu la NetBeans na faili mpya kwenye paneli ya juu kulia (picha ya kwanza). Niliongeza taarifa rahisi ya kuchapisha juu ya kukimbia kwenye Pi, lakini hakuna kitu kinachohitajika.

Ili kuendesha "Dummy" baada ya kupakua lazima uifanye "darasa kuu kutekeleza kwa msingi" kwa mradi huo:

1. Fungua Sifa za Mradi kama ilivyo katika hatua ya 5. Chagua kategoria ya Run. Bonyeza Vinjari upande wa kulia wa uwanja wa Darasa Kuu. Utaona Kivinjari cha Darasa Kuu (picha mbili).
2. Chagua darasa la "Dummy". Bonyeza Chagua Darasa Kuu. Kwa mara nyingine utaona Sifa za Mradi.
3. Bonyeza OK. Utarudi kwenye dirisha kuu.

Sasa unapobofya ikoni ya Run, NetBeans inakubali / huunda mradi mzima, inapakua jar iliyo na faili zote za darasa kwa Pi, na kutekeleza darasa la "Dummy" (picha ya tatu).

Ili kutekeleza programu yako halisi kwenye Pi, lazima sasa utumie amri ya java na chaguo la 'classpath', ambayo inahitaji kwamba utambue wazi darasa kuu la kutekeleza. Kutoka kwa mteja wa ssh nenda kwenye saraka ya dist ya mradi wako. Amri sahihi ni ya fomu:

java -cp mradi_name.jar package_name.class_name

Jina_ la mradi ni wazi linamaanisha mradi; hiyo hubadilika tu wakati wa kushughulika na mradi mpya. Jina la kifurushi bila shaka linamaanisha kifurushi, na jina la darasa linamaanisha darasa kuu kutekeleza. Kama nilivyosema hapo awali, mradi unaweza kuwa na vifurushi vingi. Vivyo hivyo, kifurushi kinaweza kuwa na madarasa mengi, na yote yanaweza kuwa darasa kuu, au programu, ambazo zinaweza kutekelezwa kutoka kwa laini ya amri. Kwa hivyo, mbinu ya 'classpath' ni muhimu sana kwa kukuza mipango ya kisasa na madarasa mengi, ambayo mengine ni madarasa kuu kusaidia upimaji wa kitengo.

Amri ifuatayo inafanya mpango wangu wa mfano:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Hatua ya 10: Pata Usimamizi wa Maktaba ya NetBeans

Moja ya mambo magumu lakini muhimu zaidi ya mipango ya kisasa ni kushughulika na maktaba, yaani, nambari mtu mwingine tayari ameandika. NetBeans inafanya kazi nzuri ya kuondoa maumivu mengi ya usimamizi wa maktaba.

Nitatumia kama mfano Pi4J, ambayo inatoa programu za Java kupata Raspberry Pi GPIO, basi ya I2C, na vifaa vingine vya I / O. Pi4J ni mfano mmoja tu wa msaada wa kufanya vitu vingi vya kufurahisha kwenye Pi na Java.

Lazima kwanza upakue maktaba kwenye kituo chako cha kazi. Tazama ukurasa wa upakuaji wa Pi4J. Kwa kuwa hausanidi Pi4J kwenye Pi, pakua zip kwenye kituo chako cha kazi. Unaweza au usilazimike kufungua wazi zip mara tu zip inapopakuliwa.

Sasa lazima uunda "maktaba ya ulimwengu" katika NetBeans:

1. Kwenye menyu kuu ya NetBeans, bonyeza Zana -> Maktaba. Utaona kidukizo cha Meneja wa Maktaba ya Ant (picha ya kwanza).
2. Bonyeza Maktaba Mpya chini kushoto. Utaona kidukizo kipya cha Maktaba (picha mbili).
3. Andika jina lenye maana unalotaka kutumia na ubonyeze sawa. Mara nyingine utaona kidukizo cha Meneja wa Maktaba ya Ant. Sasa inaonyesha maktaba mpya uliyounda (picha ya tatu).
4. Bonyeza Ongeza JAR / Folda upande wa kulia. Utaona Kivinjari cha JAR / Folda (picha ya nne).
5. Nenda kwa kisha uchague pi4j-core.jar. Kisha bonyeza Ongeza JAR / Folda. Utarudi kwa kidukizo cha Meneja wa Maktaba ya Ant.
6. Kwenye kidukizo cha Meneja wa Maktaba ya Ant bonyeza sawa. Utarudi kwenye dirisha kuu la NetBeans.

Umeongeza maktaba ili iweze kutumika katika mradi wowote. Sasa lazima uongeze maktaba kwenye mradi wako:

1. Kuleta dukizo la Mali ya Mradi (angalia hatua ya 5) na uchague kitengo cha Maktaba (picha ya tano).
2. Bonyeza Ongeza Maktaba upande wa kulia wa kidukizo. Utaona kidukizo cha Ongeza Maktaba (picha ya sita).
3. Nenda kwenye maktaba na uchague. Kisha bonyeza Ongeza Maktaba. Utaona tena dukizo la Sifa za Mradi. Maktaba sasa inaonekana kwenye orodha ya Maktaba za wakati wa kukusanya katika kidukizo.
4. Katika dukizo la Mali ya Mradi bonyeza OK. Utarudi kwenye dirisha kuu.

Umeongeza maktaba kwenye mradi wako ili programu yako iweze kuitumia. Unaweza kufanya mlolongo sawa wa vitendo kwa maktaba yoyote unayohitaji kwa programu.

Kuna mara tatu unahitaji maktaba - kukusanya, kujenga, na kutekeleza. Kwa bahati nzuri, na NetBeans, kuongeza maktaba kama inavyoonyeshwa hapo juu inashughulikia zote. Ili kudhibitisha hili, nimeunda darasa lingine kuu ambalo lina kiwango cha chini kabisa muhimu kutumia uwezo wa I2C katika Pi4J (picha ya saba). Ukweli kwamba hakuna makosa yanayoonyesha inamaanisha kuwa darasa la TestPi4J linajumuisha. Kubonyeza Run kwa mafanikio hujenga na kupakua; NetBeans hupakua maktaba pamoja na faili ya jar, kwa hivyo programu itafanya. Ili kudhibitisha mwisho, unaweza kutumia mbinu katika hatua ya 9 na katika mteja wa ssh ingiza amri ifuatayo (kutoka saraka ya dist):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Inafundisha kuelewa jinsi NetBeans inavyoshughulikia maktaba. Ukiwa kwenye saraka ya dist ya mradi wako, orodhesha yaliyomo kwenye saraka (tumia amri ya ls) na utaona saraka ndogo ya lib. Orodhesha yaliyomo kwenye saraka hiyo na utaona faili ya jar iliyotambuliwa kwenye maktaba ya ulimwengu, ambayo kwa mfano wangu ni pi4j-core.jar. Maktaba zote unazoongeza kwenye mradi zitaonekana kwenye saraka ya lib, na kwa hivyo zinapatikana kwa programu zote kwenye faili ya jar ya mradi.

Hatua ya 11: Nenda Uburudike

Nimeelezea njia ya kufanikisha maendeleo bora ya Java kwa Raspberry Pi. Raspberry Pi ni teknolojia maarufu sana kwa wigo mpana wa miradi. Java ni lugha ya programu ya daraja la kitaalam ambayo inatoa faida za utendaji juu ya Python na inatoa faida za usalama juu ya C / C ++. NetBeans ni IDE ya kiwango cha kitaalam ambayo huongeza sana tija ya programu.

Nadhani mchanganyiko huo ni wa kulazimisha. Sasa, nenda uburudike kwa kutumia mchanganyiko wa miradi yako.