Doeltreffende Java -ontwikkeling vir die Raspberry Pi: 11 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:23

Hierdie Instructable beskryf 'n baie doeltreffende benadering vir die ontwikkeling van Java -programme vir die Raspberry Pi. Ek het die benadering gebruik om Java-vermoëns te ontwikkel, wat wissel van lae vlak toestelondersteuning tot multi-threaded en netwerkgebaseerde programme. Die benadering is nie net doeltreffend nie, dit is gratis!

Die benadering is fundamenteel die ontwikkeling op afstand met NetBeans. NetBeans werk op 'n werkstasie ('n lessenaar of skootrekenaar, nie die Raspberry Pi nie) wat via Wifi aan die Raspberry Pi gekoppel is. Sodra alles behoorlik opgestel is, kan u 'n Java -program in NetBeans skryf, en dan kan 'n enkele klik die program op die werkstasie saamstel en aflaai, die program aflaai na die Pi, die program op die Pi uitvoer en die uitvoer na die NetBeans -konsole lewer. Towerkuns! U kan selfs die lopende program ontfout, breekpunte stel en veranderlike waardes ondersoek. Meer towerkuns!

Die res van hierdie inleiding beskryf die motivering vir die gebruik van Java en vir ontwikkeling op afstand met NetBeans. As u omgee vir motivering, lees verder. As u nie omgee nie, gaan na stap 1.

Waarom Java op die Raspberry Pi gebruik?

Daar is baie programmeertale beskikbaar vir die Raspberry Pi, maar ek sal die bespreking beperk tot 'professionele programmeertale' wat op selfstandige programme gerig is, multi-tasking ondersteun, hardeware- en netwerktoegang moontlik maak, ens. Dit beteken Java, Python, of C/C ++. Die mees onlangse weergawes van Raspbian bevat ontwikkeling en ondersteuning vir al hierdie tale.

Python word in werklikheid 'bevorder' vir gebruik op die Pi, ten minste gedeeltelik omdat dit maklik is om te leer vir nuwe programmeerders. Ek is 'n ervare programmeerder en hou nie van Python nie as gevolg van 'n weliswaar subjektiewe afkeer van 'n aantal kenmerke daarvan, byvoorbeeld dinamiese tik. Daar is een kenmerk van Python waarvoor my afkeer objektief is - prestasie. Hierdie bron toon dat Java altyd vinniger is as Python 3, en in werklikheid honderde kere vinniger kan loop, afhangende van die taak.

C is na my mening 'n 'masjientaal op hoë vlak', dit wil sê iets wat baie naby die stelsels hardeware is, of ten minste die bedryfstelsel. U kan omtrent alles doen, en u kan dit so vinnig as moontlik doen; hierdie bron stel eintlik voor dat C tot 7X so vinnig as Java kan hardloop. Ek is ook nie mal oor C nie, aangesien ek (subjektief) nie hou by sommige van die kenmerke wat ek vind nie, argaïes of albei; byvoorbeeld eksplisiete wenke. Die feit dat u enigiets kan doen, beteken objektief dat u slegs 'n duistere fout is (byvoorbeeld 'n slegte wyserrekord of 'n foutiewe geheue) weg van die oorskryf van geheue en moontlik dat die program of selfs die hele stelsel neerstort. Java voorkom sulke gevare, dus is Java veiliger. Ek voel dat die veiligheid ook die produktiwiteit van programmeerders verbeter. Ek beskou C ++ as 'n objekgeoriënteerde "omhulsel" rondom C wat niks doen om die gevare van C uit te skakel nie.

Die uiteinde: Java is vinniger as Python. Java is veiliger as C.

Is daar beperkings by die gebruik van Java?

Tot dusver kon ek alles in Java doen wat ek in Python kan doen. Daar is dinge wat u in C kan doen wat u nie in Java kan doen nie, maar weer, tot dusver is alles wat ek wou doen, deur Java -aanhangers in die Pi -gemeenskap aangespreek. Ek bied 'n voorbeeld in 'n latere stap. Dit gesê, ek het sensors gekoop van verskaffers wat slegs 'bestuurders' vir die sensors in Python (of C/C ++ vir die Arduino) verskaf het, so ek moes die Java -ekwivalent skryf; die ekstra inspanning is nie noodwendig produktief nie, maar kan groter insig in die werking van 'n sensor tot gevolg hê.

Waarom ontwikkeling op afstand gebaseer op NetBeans?

Ek het gevind dat op NetBeans gebaseerde afstandontwikkeling die produktiwiteit aansienlik verhoog wanneer Java vir die Raspberry Pi gebruik word. Ek is vol vertroue dat u die benadering kan gebruik om vinnige en veilige programme te skep, as gevolg van die inherente kenmerke van Java, terwyl u dit baie vinniger skryf, bou en ontfout as ander benaderings wat ek gevind het, as gevolg van eksterne ontwikkeling met behulp van die "professionele graad "NetBeans Integrated Development Environment (IDE).

Dit kan nuttig wees om kortliks die 'ander benaderings' te bespreek. Almal voldoen aan die basiese kriteria dat die Raspberry Pi nie 'n sleutelbord, muis of skerm het nie. Daar is baie redes vir hierdie kriteria, maar my primêre rede is dat ek mobiele robotte ontwikkel, en ek wil nie hê dat die Pi aan enige randapparatuur gekoppel is nie, behalwe robotiese subsisteme, selfs nie tydens ontwikkeling nie.

Die VNC -bediener wat by Raspbian ingesluit is, bied 'n afgeleë grafiese gebruikerskoppelvlak (GUI) wat 'n vorm van afstandontwikkeling moontlik maak, waar slegs die eksterne GUI op die werkstasie loop en alles anders, skryf, opstel en bou, op die Pi plaasvind. Met VNC is dit maklik om Java-ontwikkelingshulpmiddels te gebruik wat in Raspbian gestuur word, soos BlueJ, Geany en Greenfoot. Sommige hiervan kan as 'n IDE beskou word; Ek vind hulle egter ver van professionele graad.

Dit is tegnies moontlik om 'n professionele Java IDE soos Eclipse of NetBeans op die Raspberry Pi te installeer en op afstand via VNC te gebruik. Verslae en gesonde verstand dui daarop dat die resultate teleurstellend sou wees vanweë die groot geheue -voetspoor en CPU -krag wat sulke IDE's benodig, sowel as netwerkvertraging wat deur 'n eksterne GUI ingestel is.

Beide Eclipse en NetBeans werk baie goed op 'n werkstasie. Met Eclipse is die skryf van kode 'n aangename ervaring, maar die bou van die program is nie; die aflaai van die program moet plaasvind buite Eclipse; die uitvoering van die program op die Pi is heeltemal onafhanklik van Eclipse. Die algehele resultaat is 'n multi-stap, amper pynlike, proses wat nie op afstand ontfouting kan ondersteun nie. NetBeans het 'n ingeboude opstel, bou, aflaai, eksterne uitvoering en ontfouting op afstand, wat dit 'n uitstekende benadering maak.

Stap 1: Stel die Raspberry Pi op

Om die afstandsontwikkelingsbenadering te gebruik, moet u begin met die opstel van die doelwit Raspberry Pi. Daar is baie hulpbronne, insluitend Instructables, beskikbaar om te help met die opstel van 'n Raspberry Pi. Kyk hier na die basiese beginsels van die opstel van die Pi (en meer).

Hierdie Instrueerbare veronderstel jou

• installeer die nuutste Raspbian; maak seker dat u die Pi -gebruikers -ID en wagwoord opneem
• stel Wifi op en maak verbinding met u router (sien dit); maak seker dat u die Pi se IP -adres opneem
• Aktiveer SSH (sien hierdie) om afstands toegang tot die Pi vanaf die werkstasie toe te laat

Nadat u die opstelling voltooi het, kan u die skerm, die sleutelbord en die muis van die Pi afskakel en ontkoppel. Dit is een van die belangrikste voordele vir ontwikkeling op afstand. U moet enige Wifi -dongle verbonde laat (natuurlik nie nodig vir 'n Pi -model 3 of Pi Zero W nie), en dan kan u die Pi aanskakel.

Om te toets, maak 'n ssh -kliënt op u werkstasie oop, byvoorbeeld Terminal op MacOS of stopverf op Windows. Voer dan die ssh (beveiligde dop) -opdrag in met die volgende vorm:

ssh the_pi_ip_address -l die_pi_user_id

U moet 'n boodskap kry om die wagwoord van u Pi -gebruikers -ID in te voer. As daar geen opdrag verskyn nie, maak seker dat u die regte IP -adres in die ssh -opdrag ingevoer het. Voer u wagwoord in (dit sal weggesteek word), en u moet dan die dop van die Pi -dop sien wat so lyk:

pi@raspberrypi: ~ $

Kontroleer die gebruikers -ID en wagwoord wat u gebruik het as u die aanwysing nie sien nie.

Nou moet u die pad na die Java -runtime vind en bevestig dat die standaardweergawe Java 8 is (moet die geval wees met die nuutste Raspbian). Om die Java -runtime -pad te vind, voer die opdrag in die ssh -kliënt in

sudo update-alternatiewe-vertoon java

U behoort 'n antwoord te sien met die eerste twee reëls wat soos volg lyk:

java - outomatiese modus

skakel beste weergawe is/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java

Die "-8-" in die tweede reël bevestig dat die standaard runtime Java 8. Teken die pad in die tweede reël aan, aangesien u dit nodig het om NetBeans in 'n latere stap vir eksterne ontwikkeling op te stel.

As die standaard runtime nie Java 8 is nie, voer die volgende opdrag in die ssh -kliënt in om oor te skakel na Java 8 (as dit geïnstalleer is)

sudo update-alternatiewe --config java

Stap 2: Installeer NetBeans op die werkstasie

Nou moet u NetBeans op u werkstasie installeer. Wys jou werkstasie -blaaier na die NetBeans -aflaai -bladsy. U sien verskeie moontlike bundels wat die twee uitgawes van Java sowel as ander tale ondersteun. Al wat u nodig het vir Java -ontwikkeling vir die Raspberry Pi is Java SE, maar u kan die Java EE -bundel of die All -bundel kry. Sodra u besluit watter bundel u wil hê, klik op die ooreenstemmende aflaai -knoppie. U kan hier addisionele installasie -instruksies vir u werkstasie -bedryfstelsel vind.

Sodra u NetBeans geïnstalleer het, begin dit (dit kan dit outomaties doen na die installasie). U moet die NetBeans -hoofvenster sien, soos op die foto getoon. Die foto is op 'n Mac geneem, en die hoofvenster kan 'n bietjie anders lyk op Windows.

Nadat u NetBeans suksesvol geïnstalleer en begin het, gaan na die volgende stap.

Stap 3: Stel die Raspberry Pi op as 'n afgeleë platform in NetBeans

Die volgende aksies stel die Raspberry Pi op as 'n afgeleë Java SE -platform vir NetBeans. Dit stel NetBeans in staat om Java -programme op die Pi af te laai en uit te voer. U kan 'n ietwat algemene beskrywing hier vind.

LET WEL: In hierdie en die volgende stappe toon ek waardes wat spesifiek is vir my omgewing vir verskillende aspekte van konfigurasie en kodering; joune sal duidelik anders wees.

Om die Pi as 'n afgeleë platform op te stel:

1. Kies Tools -> Java Platforms in die NetBeans -hoofkiesbalk. U sien die opspringvenster van Java Platform Manager (prentjie een).
2. Klik op Voeg platform links onder. U sien die pop -upvenster Voeg Java -platform [platformtipe] by (prentjie twee).
3. Kies Remote Java Standard Edition. Klik op Volgende. U sal die pop -upvenster Add Java Platform [set up remote platform] sien (prent drie toon die pop -up nadat ek die regte waardes vir my omgewing in die velde ingevoer het).
4. Voer in die veld Platformnaam 'n naam in vir die Pi. U kan omtrent alles gebruik, maar dit moet uniek wees.
5. Voer in die gasheerveld die IP -adres in vir die Pi wat in stap 1 gevind is.
6. Voer in die veld Gebruikersnaam die gebruikersnaam in wat u in stap 1 gebruik het.
7. Laat Gebruik die wagwoordverifikasie gekies en voer die wagwoord in wat u in stap 1 geskep het in die veld Wagwoord.
8. In die Remote JRE Path -veld moet u die grootste deel van die pad na die Java -runtime op die Pi invoer. In stap 1 was dit/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java. U moet egter /bin /java in die veldwaarde aflaai.
9. NetBeans laai die uitvoerbare program af na 'n werkende gids op die Pi, geïdentifiseer in die veld Working Dir. Die standaard is/the_Pi_user_ID/NetBeansProjects/en dit is heeltemal aanvaarbaar. U kan iets anders gebruik as u wil, alhoewel dit beskikbaar moet wees vir die_Pi_user_ID (prent drie).
10. Klik op Voltooi regs onder in die opspringvenster. Na die verwerking moet u weer die pop -upvenster van Java Platform Manager sien. Nou moet u u afgeleë Pi (onder die naam wat u in aksie 4 hierbo gebruik het) onder die kategorie Remote Java SE (prent vier) sien.
11. Klik op Toetsplatform links onder om die verbinding tussen NetBeans en u Pi te toets. U sal eers 'n opspringvenster sien wat die verifiëring van eksterne platform verifieer. As dit suksesvol is, kry u 'n tweede pop -up wat aandui dat die verbinding … suksesvol gevestig is. As dit nie die geval is nie, moet u die inligting wat u ingevoer het in die pop-upvenster Add Java Platform [set up remote platform] nagaan en regstel in aksies 5-9 hierbo. U kan dit doen vanaf die opspringvenster Java Platform Manager; kies eenvoudig u Pi -platform en wysig dan die velde aan die regterkant van die pop -up.
12. Na 'n suksesvolle verbinding, klik op Sluit in die pop -upvenster van Java Platform Manager. U sal nou die NetBeans -hoofvenster sien.

Nou kan die regte pret begin!

Stap 4: Skep 'n Java -projek op die werkstasie

Dit is nie bedoel om 'n volledige verduideliking te wees van hoe u NetBeans of Java moet gebruik nie, maar ek sal die minimale aksies beskryf om 'n program in NetBeans op die werkstasie te skryf en uiteindelik die program op afstand op die Raspberry Pi te laat loop.

In NetBeans moet u eers 'n projek skep om die Java -klasse (s) vir die program te hou. In Java vind lesse ook plaas in pakkette ter ondersteuning van organisasie en veiligheid. Om die projek te skep en opsioneel 'n pakket en 'n klaslêer te skep:

1. Klik in die NetBeans -hoofvenster op die nuwe projekikoon (2de van links). U sal die opspringvenster Nuwe projek [kies projek] (prentjie een) sien.
2. Die standaardinstellings (kategorie: Java, projek: Java -toepassing) is korrek vir hierdie voorbeeld, so klik eenvoudig op Volgende. U sal die pop -upvenster Nuwe Java -toepassing [naam en ligging] sien (prentjie twee toon waardes vir my voorbeeld). LET WEL: Ek het my gebruikersinligting verander met behulp van die gekleurde reghoeke.
3. Voer in die veld Projeknaam 'n geldige Java -projeknaam in wat u verkies. Die naam moet met 'n hoofletter begin, en die konvensie dui op 'n kameelkas by die aaneenvoeging van woorde.
4. Die veld Project Project bepaal waar die projek in u lêerstelsel geleë is. Die standaard wissel na gelang van die bedryfstelsel, maar dit is veilig om te aanvaar.
5. Met die veld Projekmap kan u die vouernaam vir die projek beheer. Ek vind dit die beste om die standaard te gebruik, wat 'n aaneenskakeling is van die veld Locasie en die veld Naam.
6. As die boks Skep hoofklas gemerk is, skep NetBeans outomaties 'n pakket en 'n hoofklaslêer ('n program wat vanaf die opdragreël uitgevoer kan word) met dieselfde naam as die projek. Ek dink gewoonlik moet dit nie gemerk word nie, maar in hierdie geval laat ek dit nagaan, wat eksplisiete aksies elimineer wat andersins nodig is (foto twee).
7. Klik op Voltooi om die projek, 'n pakket en 'n hoofklaslêer te skep. Die venster links bo in die NetBeans -hoofvenster wys u projek, wat 'n enkele pakket bevat, wat weer 'n enkele klaslêer met 'n hoof () -metode bevat. Die venster regs bo bevat die standaard bronkode vir die hoofklas (die program) wat outomaties deur NetBeans gegenereer word (prent drie).

Op hierdie punt kan u 'n kode in die hoofmetode skryf en dit op die werkstasie laat loop. Dit kan soms wenslik wees, maar dit is nie nodig vir hierdie instruksies nie, dus gaan na die volgende stap.

Stap 5: Stel die NetBeans -projek op om op afstand op die Raspberry Pi te werk

Om die NetBeans -projek en 'n program wat dit bevat op te stel om op afstand op die Raspberry Pi te werk, doen die volgende:

1. Klik met die regter- of twee vingers (hang af van die werkstasie-bedryfstelsel) op die projek in die Projects-venster van die NetBeans-hoofvenster om die projekmenu te open en klik op Properties. U sal die opspringvenster vir projekteienskappe sien (die prentjie wys die opspring met die regte waardes vir my voorbeeld).
2. Kies Uitvoer onder kategorieë aan die linkerkant.
3. Klik op New in die regterkant van die Configuration -veld. Voer 'n naam vir die opset in die opspringvenster Skep nuwe konfigurasie in en klik op OK. Die naam kan enigiets wees; Ek het pas die naam van die platform ("My Pi") hergebruik. U sal weer die opspringvenster vir projekteienskappe sien.
4. Klik op die keuselys aan die regterkant van die veld Runtime Platform. Kies in die opspringlys die afgeleë platform wat u vroeër geskep het (in my omgewing, "My Pi").
5. Klik op OK om die afgeleë platform vir die projek op te stel. U sal weer die hoofvenster sien.

U is nou gereed om kode te skryf en die program op afstand uit te voer.

Stap 6: Skryf 'n Java -program op die werkstasie en voer dit uit op die Raspberry Pi

Die regter paneel in die NetBeans -hoofvenster toon die hoofklaslêer wat deur NetBeans gegenereer is. Tik 'n eenvoudige afdrukverklaring in die hoofmetode van die klaslêer (prent een). Dit is nou 'n volledige Java -program wat iets doen, alhoewel iets baie eenvoudig.

Om die program op die Pi uit te voer, klik op die Run-ikoon (die groen pyltjie wat links wys) in die hoofvenster. NetBeans stel die kode saam, bou 'n jar -lêer, laai die jar -lêer af na die Raspberry Pi wat deur die afgeleë platform geïdentifiseer is, voer die program op die Pi uit, vang die uitset (System.out) van die program op en weerklink die uitset na die NetBeans Uitvoerpaneel regs onder in die hoofvenster (prent twee).

U het u vaardigheidstel vir die ontwikkeling van projekte op die Raspberry Pi aansienlik uitgebrei! Maar wag…. Daar is meer!

Stap 7: Ontfout die Java -program met NetBeans

Een van die kragtigste kenmerke van 'n geïntegreerde ontwikkelingsomgewing met 'n industriële sterkte soos NetBeans, is die vermoë om die program te ontfout terwyl dit uitgevoer word. Met NetBeans kan u die volledige reeks ontfoutingshulpmiddels benut terwyl u op afstand werk. Dit sluit in die instel van breekpunte op 'belangrike' of 'lastige' plekke in die program en die ondersoek van die waarde van veranderlikes by die huidige uitvoeringstoestand.

Die eenvoudige program in die laaste stap is te eenvoudig om ontfouting aan te toon, so ek het 'n ekstra kode by die program gevoeg. Die bykomende kode voeg twee veranderlikes by.

Om die ontfoutingsinstrumente te benut, moet u eers een of meer breekpunte stel. Om 'n breekpunt in te stel, klik op die reëlnommer waar u die uitvoering wil staak; 'n rooi reghoek -ikoon verskyn, en die hele reël kry 'n rooi agtergrond (prentjie een).

Om die program wat op die Pi loop, te ontfout, klik op die Ontfout -ikoon (onmiddellik regs van die ikoon Uitvoer) in die NetBeans -hoofvenster. Net soos met normale uitvoering, stel NetBeans die uitset saam, bou, laai dit af, voer dit uit en vang die uitvoer af. Maar met ontfouting, stop NetBeans die uitvoering by breekpunte en stel u in staat om die uitvoeringstoestand te ondersoek (prentjie twee, waarin die venster veranderlikes regs onder verskyn).

Uitvoering stop by die breekpunt voordat die instruksie op die lyn met die breekpunt uitgevoer word. Die groen agtergrond dui die volgende stelling aan wat uitgevoer moet word. Dus, in my voorbeeld, met 'n breekpunt by reël 9, bestaan veranderlike a nog nie, en nog minder 'n waarde.

Beweeg nou die wyser oor die ikoon vir ontfouting in die hoofvenster (die eerste dubbele pyltjie-af-ikoon regs van die ikoon Ontfout) en klik op die ikoon Stap oor (dit het 'n blou dokument op die agtergrond en 'n groen pyltjie met die klok in op die voorgrond). [OPMERKING: as u die hoofvenster van NetBeans wyd genoeg maak, word die ontfoutingsmenu uitgebrei en die ikone vir ontfouting verskyn regs van die ikoon Ontfout.] NetBeans voer die stelling uit by die breekpunt en stop die uitvoering voor die volgende verklaring. U sal nou sien dat die veranderlike a bestaan en die verwagte waarde het (prent drie).

Klik twee keer op die ikoon Stap oor. U sal sien dat al drie veranderlikes waardes het; let op dat c steeds nul is (prent vier).

Klik een keer op die ikoon Stap oor. U sal sien dat veranderlike c nou die regte waarde het, dit wil sê die som van veranderlikes a en b (prentjie vyf).

Klik uiteindelik op die ontfout -kieslys op die ikoon Uitvoering ('n groen sirkel met 'n wit pyltjie). Dit veroorsaak dat die uitvoering na die volgende breekpunt, of na die einde van die program, voortgaan, wat ook al die eerste kom. Nou verskyn die uitvoervenster en toon dieselfde uitvoer as met normale uitvoering, in hierdie geval die teks in die afdrukverklaring.

Stap 8: voer die program onafhanklik van NetBeans uit

Die tyd kan aanbreek dat u u program op die Raspberry Pi wil uitvoer, sonder 'hulp' of 'inmenging' van NetBeans. Dit is baie eenvoudig. Maak eers 'n ssh -kliënt oop vir u Pi.

Onthou vanaf stap 3 dat NetBeans u projekpot in 'n werkgids op die Pi plaas. Die standaardbasis is/home/pi/NetBeansProjects vir user pi. Die spesifieke gids het dieselfde naam as u projek. NetBeans plaas die pot in 'n subgids dist. Vir my voorbeeld is die volledige pad/home/pi/NetBeansProjects/MyRemoteProg/dist. In die ssh -kliënt op die Pi, om die program uit te voer, kan u die java -opdrag gebruik met die 'jar' -opsie:

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

U sal die resultate van die uitvoering in die ssh -kliënt sien; in my voorbeeld sal die uitset wees

Hallo van Raspberry Pi!

Dit werk omdat inligting in die jar -lêer identifiseer watter hoofklas in die pot uitgevoer moet word.

U kan ook die werksgids (via cd) na die plek van die jar -lêer verander en dan 'n korter opdrag gee om dieselfde resultate te lewer.

java -jar MyRemoteProg.jar

Stap 9: Bou en laai die program af, maar voer dit nie uit via NetBeans nie

Daar is situasies waarin u wil hê dat NetBeans u program moet bou en aflaai, maar dit nie uitvoer nie. So 'n situasie vind plaas wanneer u program sleutelbordinvoer benodig. As dit die geval is, met behulp van die tegniek in die vorige stap, sodra u dit gebou en afgelaai het, word die program uitgevoer op die Raspberry Pi en word die sleutelbordinvoer van die Pi verwag, maar daar is natuurlik geen sleutelbord aan die Pi gekoppel nie, so die program hang - nie goed nie.

U moet 'n ietwat ander tegniek gebruik om die program uit te voer. U skep basies 'n 'dummy' hoofklaslêer wat eintlik niks doen nie, en identifiseer dit as die program wat uitgevoer moet word na aflaai. In hierdie geval word die 'dummy' uitgevoer, en u kan dan u 'regte' program direk op die Pi uitvoer.

Om hierdie tegniek te gebruik, moet u eers 'n nuwe hoofklas skep:

1. Open die projekmenu soos in stap 5 en klik op New-> Java Main Class. U sal die pop -up van die nuwe Java -hoofklas sien.
2. Voer 'n naam in die veld Klasnaam in. Die naam kan alles wees waarvan u hou; Ek het "Dummy" gebruik. Met die veld Pakket kan u die pakket van die klas identifiseer; u kies 'n pakket met die keuselys aan die regterkant van die veld. Die klas kan in dieselfde pakket as u 'regte' program of in 'n ander pakket wees; Ek sit die nuwe klas in dieselfde pakket. Klik op Voltooi. U sal nou die NetBeans -hoofvenster met die nuwe lêer in die regter boonste paneel (prent een) sien. Ek het 'n eenvoudige afdrukverklaring bygevoeg oor die werking van die Pi, maar niks is regtig nodig nie.

Om 'Dummy' na aflaai te laat loop, moet u dit die 'hoofklas maak wat standaard uitgevoer word' vir die projek:

1. Open die projekteienskappe soos in stap 5. Kies die kategorie Uitvoering. Klik op Blaai regs in die hoofklasveld. U sal die opspringvenster Blaai deur hoofklasse (prentjie twee) sien.
2. Kies die klas "Dummy". Klik op Kies hoofklas. U sal weer die projekteienskappe sien.
3. Klik op OK. U sal terugkeer na die hoofvenster.

As u nou op die Run -ikoon klik, voldoen/bou NetBeans die hele projek, laai die pot met al die klaslêers af na die Pi en voer die "Dummy" -klas uit (prent drie).

Om u regte program op die Pi uit te voer, moet u nou die java -opdrag gebruik met die 'classpath' -opsie, wat vereis dat u uitdruklik die hoofklas identifiseer wat u moet uitvoer. Gaan vanaf 'n ssh -kliënt na die dist -gids vir u projek. Die regte opdrag het die vorm:

java -cp projeknaam.jar pakketnaam.klasnaam

Die projeknaam verwys natuurlik na die projek; dit verander slegs as u 'n nuwe projek hanteer. Die pakketnaam verwys natuurlik na die pakket, en die klasnaam verwys na die hoofklas wat uitgevoer moet word. Soos vroeër gesê, kan 'n projek baie pakkette bevat. Net so kan 'n pakket baie klasse bevat, en almal kan hoofklasse of programme wees wat vanaf die opdragreël uitgevoer kan word. Die 'klaspad' -tegniek is dus baie handig vir die ontwikkeling van gesofistikeerde programme met baie klasse, waarvan sommige slegs hoofklasse is om eenheidstoetse te help.

Die volgende opdrag voer my voorbeeldprogram uit:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Stap 10: Maak gebruik van NetBeans -biblioteekbestuur

Een van die moeilikste, maar belangrikste aspekte van gesofistikeerde programme, is die hantering van biblioteke, naamlik kode wat iemand anders al geskryf het. NetBeans doen 'n wonderlike taak om die meeste pyn van biblioteekbestuur te verwyder.

Ek sal Pi4J as voorbeeld gebruik, wat Java -programme toegang gee tot die Raspberry Pi GPIO, I2C -bus en ander hardeware -I/O. Pi4J is slegs 'n voorbeeld van ondersteuning om baie prettige dinge op die Pi met Java te doen.

U moet eers die biblioteek na u werkstasie aflaai. Sien die Pi4J aflaai bladsy. Aangesien u Pi4J nie op die Pi installeer nie, moet u die zip na u werkstasie aflaai. U hoef dit uitdruklik uit te pak sodra die zip afgelaai is.

Nou moet u 'n 'globale biblioteek' in NetBeans skep:

1. Klik in die hoofmenu van NetBeans op Tools -> Libraries. U sien die pop -up van Ant Library Manager (prent een).
2. Klik op Nuwe biblioteek links onder. U sal die pop -up van die nuwe biblioteek sien (prentjie twee).
3. Tik 'n betekenisvolle naam in wat u wil gebruik en klik op OK. U sal weer die pop -up van Ant Library Manager sien. Dit wys nou die nuwe biblioteek wat u geskep het (prent drie).
4. Klik regs op Voeg JAR/gids by. U sal die opspringblaai JAR/gids sien (prent vier).
5. Navigeer na en kies dan pi4j-core.jar. Klik dan op Voeg JAR/gids by. U sal terugkeer na die pop -upvenster vir Ant Library Manager.
6. Klik op die pop -up pop -up van die Ant Library Manager. U sal terugkeer na die NetBeans -hoofvenster.

U het die biblioteek bygevoeg sodat dit in enige projek gebruik kan word. Nou moet u die biblioteek by u projek voeg:

1. Open die opspringvenster vir projekteienskappe (sien stap 5) en kies die kategorie biblioteke (prent vyf).
2. Klik op Voeg biblioteek by aan die regterkant van die pop -up. U sal die pop -up byvoeg biblioteek (prent ses) sien.
3. Gaan na die biblioteek en kies dit. Klik dan op Voeg biblioteek by. U sal weer die opspringvenster vir projekteienskappe sien. Die biblioteek verskyn nou in die lys met kompileertydbiblioteke in die opspringvenster.
4. Klik op OK in die opspringvenster vir projekteienskappe. U sal terugkeer na die hoofvenster.

U het die biblioteek by u projek gevoeg sodat u program dit kan gebruik. U kan dieselfde volgorde van aksies doen vir enige biblioteke wat u benodig vir 'n program.

U het die biblioteek drie keer nodig - saamstel, bou en uitvoer. Gelukkig kan die byvoeging van die biblioteek, soos hierbo getoon, met NetBeans alles hanteer. Om dit te bevestig, het ek 'n ander hoofklas geskep wat die absolute minimum doen wat nodig is om die I2C -vermoë in Pi4J te gebruik (foto sewe). Die feit dat daar geen foute is nie, beteken dat die klas TestPi4J saamstel. As u op Uitvoer klik, bou en aflaai; NetBeans laai die biblioteek af behalwe die jar -lêer, sodat die program uitgevoer kan word. Om laasgenoemde te verifieer, kan u die tegniek in stap 9 gebruik en in die ssh -kliënt die volgende opdrag invoer (uit die dist -gids):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Dit is insiggewend om te verstaan hoe NetBeans biblioteke hanteer. In die dist -gids vir u projek, lys die inhoud van die gids (gebruik die ls -opdrag) en u sal 'n lib -subgids sien. Maak 'n lys van die inhoud van die gids, en u sien die jar-lêer wat geïdentifiseer is in die globale biblioteek, wat in my voorbeeld pi4j-core.jar is. Alle biblioteke wat u by die projek voeg, verskyn in die lib -gids en is dus beskikbaar vir alle programme in die projek jar -lêer.

Stap 11: Gaan om pret te hê

Ek het 'n benadering beskryf vir die bereiking van 'n baie doeltreffende Java -ontwikkeling vir die Raspberry Pi. Die Raspberry Pi is 'n uiters gewilde tegnologie vir 'n wye spektrum projekte. Java is 'n professionele programmeertaal wat prestasievoordele bo Python bied en veiligheidsvoordele bied bo C/C ++. NetBeans is 'n professionele IDE wat programmeerders se produktiwiteit aansienlik verhoog.

Ek dink die kombinasie is nogal oortuigend. Geniet die kombinasie vir u projekte.