Effektiv Java -utvikling for Raspberry Pi: 11 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:21

Denne instruksjonsboken beskriver en veldig effektiv tilnærming for å utvikle Java -programmer for Raspberry Pi. Jeg har brukt tilnærmingen til å utvikle Java-muligheter, alt fra lavt nivå enhetsstøtte til flertrådede og nettverksbaserte programmer. Tilnærmingen er ikke bare effektiv, den er gratis!

Grunnleggende er tilnærmingen fjernutvikling ved bruk av NetBeans. NetBeans kjører på en arbeidsstasjon (en stasjonær eller bærbar datamaskin, ikke Raspberry Pi) koblet via Rifi til Raspberry Pi via Wifi. Når alt er riktig konfigurert, kan du skrive et Java -program i NetBeans og deretter et enkelt klikk kompilerer og bygger programmet på arbeidsstasjonen, laster ned programmet til Pi, kjører programmet på Pi og leverer utgang til NetBeans -konsollen. Magi! Du kan til og med feilsøke programmet som kjører, sette brytepunkter og undersøke variable verdier. Mer magi!

Resten av denne introduksjonen beskriver motivasjonen for å bruke Java og for ekstern utvikling ved bruk av NetBeans. Hvis du bryr deg om motivasjon, les videre. Hvis du ikke bryr deg, gå til trinn 1.

Hvorfor bruke Java på Raspberry Pi?

Det er mange programmeringsspråk tilgjengelig for Raspberry Pi, men jeg vil begrense diskusjonen til programmeringsspråk av "profesjonell karakter" som retter seg mot frittstående programmer, støtter multi-tasking, tillater maskinvare og nettverkstilgang, etc. Det betyr Java, Python eller C/C ++. De siste utgivelsene av Raspbian inkluderer støtte for utvikling og kjøretid for alle disse språkene.

Python er i virkeligheten "promotert" for bruk på Pi, i hvert fall delvis for at den er enkel å lære for nye programmerere. Jeg er en erfaren programmerer og er ikke glad i Python på grunn av en ganske subjektiv motvilje til en rekke av dens egenskaper, for eksempel dynamisk skriving. Det er en egenskap ved Python som min motvilje er objektiv - ytelse. Denne kilden viser at Java alltid er raskere enn Python 3, og faktisk kan kjøre hundrevis av ganger raskere, avhengig av oppgaven.

C etter min mening er et "maskinspråk på høyt nivå", det vil si noe som er veldig nær systemets maskinvare, eller i det minste operativsystemet. Du kan gjøre stort sett alt, og du kan gjøre det omtrent så raskt som mulig; Faktisk antyder denne kilden at C kan kjøre opptil 7 ganger så raskt som Java. Jeg er heller ikke glad i C siden jeg (subjektivt) misliker noen av egenskapene som jeg synes er urovekkende, arkaisk eller begge deler; for eksempel eksplisitte tips. Objektivt sett betyr det at du kan gjøre hva som helst at du bare er en uklar feil (f.eks. Dårlig peker -aritmetikk eller feilaktig memcpy) borte fra å overskrive minne og potensielt krasje programmet eller til og med hele systemet. Java forhindrer slike farer, så Java er tryggere. Jeg føler at sikkerheten også forbedrer programmererens produktivitet. Jeg anser C ++ som en objektorientert "omslag" rundt C som ikke gjør noe for å eliminere farene ved C.

Poenget: Java er raskere enn Python. Java er tryggere enn C.

Er det begrensninger ved bruk av Java?

Så langt har jeg kunnet gjøre alt i Java som jeg kan gjøre i Python. Det er ting man kan gjøre i C som man ikke kan gjøre i Java, men igjen, så langt har alt jeg ønsket å gjøre blitt adressert av Java -fans i Pi -samfunnet. Jeg kommer med et eksempel i et senere trinn. Når det er sagt, har jeg kjøpt sensorer fra leverandører som bare leverte "drivere" for sensorene i Python (eller C/C ++ for Arduino), så jeg måtte skrive Java -ekvivalenten; den ekstra innsatsen er ikke nødvendigvis produktiv, men kan resultere i større innsikt i en sensors drift.

Hvorfor fjernutvikling basert på NetBeans?

Jeg har funnet ut at NetBeans-basert fjernutvikling øker produktiviteten kraftig når du bruker Java til Raspberry Pi. Jeg er overbevist om at du kan bruke tilnærmingen til å lage raske og sikre programmer på grunn av de iboende egenskapene til Java, mens du skriver, bygger og feilsøker dem mye raskere enn andre tilnærminger jeg har funnet, på grunn av fjernutvikling ved hjelp av "profesjonelle" klasse "NetBeans Integrated Development Environment (IDE).

Det kan være nyttig å kort diskutere de "andre tilnærmingene". Alle oppfyller de grunnleggende kriteriene om at Raspberry Pi ikke har tilkoblet tastatur, mus eller skjerm. Det er mange grunner til disse kriteriene, men min primære årsak er at jeg utvikler mobile roboter, og jeg vil ikke at Pi skal være koblet til eksterne enheter, bortsett fra robotiske undersystemer, selv under utvikling.

VNC -serveren som er inkludert i Raspbian gir et eksternt grafisk brukergrensesnitt (GUI) som tillater en form for fjernutvikling, der bare den eksterne GUI -en kjøres på arbeidsstasjonen og alt annet, skriving, kompilering og bygging, finner sted på Pi. Med VNC er det enkelt å bruke Java-kompatible utviklingsverktøy som leveres i Raspbian, som BlueJ, Geany og Greenfoot. Noen av disse kan betraktes som en IDE; Imidlertid finner jeg dem langt fra profesjonell karakter.

Det er teknisk mulig å installere en Java IDE av profesjonell karakter som Eclipse eller NetBeans på Raspberry Pi og bruke den eksternt via VNC. Rapporter og sunn fornuft antyder at resultatene ville være skuffende på grunn av det store minnefotavtrykket og CPU -kraften som slike IDE -er krever, samt nettverksforsinkelse introdusert av en ekstern GUI.

Både Eclipse og NetBeans kjører veldig bra på en arbeidsstasjon. Med Eclipse er det en hyggelig opplevelse å skrive kode, men å bygge programmet er ikke det; nedlasting av programmet må skje utenfor Eclipse; å kjøre programmet på Pi er helt uavhengig av Eclipse. Det samlede resultatet er en flertrinns, nesten smertefull, prosess som ikke kan støtte ekstern feilsøking. NetBeans har innebygd kompilering, bygging, nedlasting, ekstern kjøring og ekstern feilsøking, noe som gjør det til en overlegen tilnærming.

Trinn 1: Sett opp Raspberry Pi

For å bruke fjernutviklingsmetoden må du starte med å sette opp målet Raspberry Pi. Det er mange ressurser, inkludert Instructables, tilgjengelig for å hjelpe deg med å sette opp en Raspberry Pi. Se dette for det grunnleggende om å sette opp Pi (og mer).

Denne instruksen antar deg

• installere den nyeste Raspbian; sørg for å registrere Pi bruker -ID og passord
• sett opp Wifi og koble til ruteren din (se dette); sørg for å registrere Pi -IP -adressen
• aktiver SSH (se dette) for å tillate ekstern tilgang til Pi fra arbeidsstasjonen

Når du har fullført oppsettet, kan du slå av og koble skjermen, tastaturet og musen fra Pi. Dette er en av de viktigste fordelene med fjernutvikling. Du må la en hvilken som helst Wifi -dongle være tilkoblet (selvfølgelig ikke nødvendig for en Pi -modell 3 eller Pi Zero W), og deretter kan du slå på Pi -en.

For å teste, åpne en ssh -klient på arbeidsstasjonen din, for eksempel Terminal på MacOS eller kitt på Windows. Skriv deretter inn kommandoen ssh (secure shell) med følgende skjema:

ssh the_pi_ip_address -l the_pi_user_id

Du bør få en melding om å angi passordet til din Pi -bruker -ID. Hvis ingen melding vises, må du kontrollere at du har angitt riktig IP -adresse i ssh -kommandoen. Skriv inn passordet ditt (det vil være skjult), og du bør da se Pi -skallet som viser noe slikt:

pi@raspberrypi: ~ $

Hvis du ikke ser ledeteksten, må du sjekke bruker -ID og passord du brukte.

Nå må du finne banen til Java -kjøretiden og bekrefte at standardversjonen er Java 8 (skal være sant for den nyeste Raspbian). For å finne Java -runtime -banen, skriv inn kommandoen i ssh -klienten

sudo oppdateringsalternativer-vis java

Du bør se et svar med de to første linjene som ser ut som følgende:

java - automatisk modus

lenken beste versjonen er/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java

"-8-" i den andre linjen bekrefter at standard kjøretid er Java 8. Registrer banen i den andre linjen, da du trenger den for å konfigurere NetBeans for fjernutvikling i et senere trinn.

Hvis standard kjøretid ikke er Java 8, skriver du inn følgende kommando i ssh -klienten for å bytte til Java 8 (forutsatt at den er installert)

sudo update-alternativer --config java

Trinn 2: Installer NetBeans på arbeidsstasjonen

Nå må du installere NetBeans på arbeidsstasjonen din. Pek nettstasjonen på arbeidsstasjonen mot NetBeans nedlastingsside. Du vil se flere mulige bunter som støtter de to utgavene av Java så vel som andre språk. Alt du trenger for Java -utvikling for Raspberry Pi er Java SE, men du kan få Java EE -pakken eller All -pakken. Når du har bestemt hvilken pakke du vil klikke på den tilsvarende nedlastingsknappen. Du finner flere installasjonsinstruksjoner for arbeidsstasjonens operativsystem her.

Når du har installert NetBeans, starter du den (den kan gjøre det automatisk etter installasjonen). Du bør se NetBeans hovedvindu som vist på bildet. Bildet er tatt på en Mac, og hovedvinduet kan se litt annerledes ut på Windows.

Når du har installert og startet NetBeans, går du videre til neste trinn.

Trinn 3: Konfigurer Raspberry Pi som en ekstern plattform i NetBeans

Følgende handlinger konfigurerer Raspberry Pi som en ekstern Java SE -plattform for NetBeans. Dette gjør at NetBeans kan laste ned og kjøre Java -programmer på Pi. Du finner en litt generisk beskrivelse her.

MERK: I dette og følgende trinn viser jeg verdier som er spesifikke for miljøet mitt for ulike aspekter av konfigurasjon og koding; din vil tydeligvis være annerledes.

Slik konfigurerer du Pi som en ekstern plattform:

1. Velg Verktøy -> Java -plattformer i NetBeans hovedmenylinje. Du vil se Java Platform Manager -vinduet (bilde ett).
2. Klikk på Legg til plattform nederst til venstre. Du vil se Legg til Java -plattform [plattformtype] -vinduet (bilde to).
3. Velg Remote Java Standard Edition. Klikk Neste. Du vil se popup -vinduet Legg til Java -plattform [sett opp ekstern plattform] (bilde tre viser popup -vinduet etter at jeg skrev inn de riktige verdiene for miljøet mitt i feltene).
4. I feltet Plattformnavn skriver du inn et navn for Pi. Du kan bruke stort sett alt, men det må være unikt.
5. I vertsfeltet skriver du inn IP -adressen for Pi funnet i trinn 1.
6. Skriv inn brukernavnet du brukte i trinn 1 i feltet Brukernavn.
7. La bruk passordautentisering være valgt, og skriv inn passordet du opprettet i trinn 1 i feltet Passord.
8. I feltet Remote JRE Path må du angi det meste av banen til Java -kjøretiden på Pi. I trinn 1 var det/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java. Du må imidlertid slippe av /bin /java i feltverdien.
9. NetBeans laster ned programmet som kan kjøres til en arbeidskatalog på Pi, identifisert i Working Dir -feltet. Standarden er/the_Pi_user_ID/NetBeansProjects/og det er helt akseptabelt. Du kan bruke noe annet hvis du ønsker det, selv om det må være tilgjengelig for_Pi_user_ID (bilde tre).
10. Klikk på Fullfør nederst til høyre i popup -vinduet. Etter behandling bør du igjen se popup -vinduet for Java Platform Manager. Nå bør du se din eksterne Pi (under navnet du brukte i handling 4 ovenfor) under kategorien Remote Java SE (bilde fire).
11. Klikk på Testplattform nederst til venstre for å teste forbindelsen mellom NetBeans og din Pi. Du vil først se en popup som sier Verifying Remote Platform. Hvis det lykkes, får du en annen popup som indikerer at tilkoblingen … er opprettet. Hvis ikke, må du sjekke og korrigere informasjonen du angav i popup-vinduet Legg til Java-plattform [konfigurer ekstern plattform] i handlingene 5-9 ovenfor. Du kan gjøre det fra Java Platform Manager -forgrunnsvinduet; Bare velg din Pi -plattform og rediger deretter feltene på høyre side av popup -vinduet.
12. Etter en vellykket tilkobling klikker du Lukk i Java Platform Manager -forgrunnsvinduet. Du vil nå se NetBeans hovedvindu.

Nå kan den virkelige moroa begynne!

Trinn 4: Opprett et Java -prosjekt på arbeidsstasjonen

Dette er ikke ment å være en fullstendig forklaring på hvordan du bruker NetBeans eller Java, men jeg vil beskrive de minimale handlingene for å skrive et program i NetBeans på arbeidsstasjonen og til slutt kjøre programmet eksternt på Raspberry Pi.

I NetBeans må du først opprette et prosjekt for å holde Java -klassen (e) for programmet. Videre ligger klasser i Java i pakker for å støtte organisasjon og sikkerhet. For å opprette prosjektet og eventuelt opprette en pakke og en klassefil:

1. Klikk på det nye prosjektikonet (2. fra venstre) i hovedvinduet i NetBeans. Du vil se Nytt prosjekt [velg prosjekt] popup (bilde ett).
2. Standardinnstillingene (Kategori: Java, Prosjekt: Java -applikasjon) er riktige for dette eksemplet, så bare klikk på Neste. Du vil se popup -vinduet Nytt Java -program [navn og plassering] (bilde to viser verdier for mitt eksempel). MERK: Jeg har redigert brukerinformasjonen min ved hjelp av de fargede rektanglene.
3. I feltet Prosjektnavn skriver du inn et gyldig Java -prosjektnavn du velger. Navnet må begynne med en stor bokstav, og konvensjonen antyder kamelhylster når ord blir sammenkoblet.
4. Feltet Prosjektplassering kontrollerer hvor prosjektet ligger i filsystemet ditt. Standarden varierer avhengig av operativsystem, men er trygt å godta.
5. Med feltet Prosjektmappe kan du kontrollere mappenavnet for prosjektet. Jeg synes det er best å bruke standarden, som er en sammenkobling av feltet Plassering og feltet Navn.
6. Når det er merket av for Opprett hovedklasse, oppretter NetBeans automatisk en pakke og en hovedklassefil (et program som kan kjøres fra kommandolinjen) med samme navn som prosjektet. Jeg tror vanligvis det bør være ukontrollert, men i dette tilfellet lar jeg det være kontrollert, noe som eliminerer eksplisitte handlinger som ellers er nødvendig for å gjøre det (bilde to).
7. Klikk Fullfør for å opprette prosjektet, en pakke og en hovedklassefil. Nå viser ruten øverst til venstre i NetBeans -hovedvinduet prosjektet ditt, som inneholder en enkelt pakke, som igjen inneholder en enkelt klassefil med en hovedmetode (). Den øverste høyre ruten inneholder standard kildekoden for hovedklassen (programmet) som automatisk genereres av NetBeans (bilde tre).

På dette tidspunktet kan du skrive noen kode i hovedmetoden og kjøre den på arbeidsstasjonen. Det kan til tider være ønskelig, men er unødvendig for denne instruksen, så fortsett til neste trinn.

Trinn 5: Konfigurer NetBeans -prosjektet til å kjøres eksternt på Raspberry Pi

Gjør følgende for å konfigurere NetBeans -prosjektet, og et program det inneholder, for å kjøre eksternt på Raspberry Pi:

1. Høyreklikk eller 2-finger-klikk (avhenger av arbeidsstasjonens operativsystem) på prosjektet i Prosjekter-ruten i NetBeans-hovedvinduet for å åpne prosjektmenyen og klikke Egenskaper. Du vil se Project Properties -popup -vinduet (bildet viser popup -vinduet med de riktige verdiene for mitt eksempel).
2. Velg Kjør under Kategorier til venstre.
3. Klikk Ny til høyre for konfigurasjonsfeltet. I den resulterende popup -vinduet Opprett ny konfigurasjon skriver du inn et navn på konfigurasjonen og klikker OK. Navnet kan være hva som helst; Jeg har nettopp gjenbrukt navnet på plattformen ("My Pi"). Igjen ser du popup -vinduet Prosjektegenskaper.
4. Klikk på rullegardinikonet til høyre for Runtime Platform -feltet. Fra listen i popup -vinduet, velg den eksterne plattformen du opprettet tidligere (i mitt miljø, "My Pi").
5. Klikk OK for å konfigurere den eksterne plattformen for prosjektet. Du vil igjen se hovedvinduet.

Du er nå klar til å skrive kode og kjøre programmet eksternt.

Trinn 6: Skriv et Java -program på arbeidsstasjonen og kjør det på Raspberry Pi

Panelet til høyre i NetBeans hovedvindu viser hovedklassefilen generert av NetBeans. Skriv inn en enkel utskriftserklæring i hovedmetoden for klassefilen (bilde én). Det er nå et komplett Java -program som gjør noe, men noe veldig enkelt.

For å kjøre programmet på Pi, klikk på Kjør-ikonet (den grønne pilen til venstre) i hovedvinduet. NetBeans kompilerer koden, bygger en jar -fil, laster ned jar -filen til Raspberry Pi identifisert av den eksterne plattformen, kjører programmet på Pi, fanger ut utgangen (System.out) av programmet og ekko den utgangen til NetBeans Utdatarute nederst til høyre i hovedvinduet (bilde to).

Du har nå utvidet ferdighetssettet ditt betydelig for å utvikle prosjekter på Raspberry Pi! Men vent…. Det er mer!

Trinn 7: Feilsøk Java -programmet med NetBeans

En av de kraftigste egenskapene til et industrielt styrket integrert utviklingsmiljø som NetBeans er muligheten til å feilsøke programmet mens du kjører. NetBeans lar deg utnytte hele pakken med feilsøkingsverktøy mens du kjører eksternt. Dette inkluderer å sette brytepunkter på "viktige" eller "plagsomme" steder i programmet og undersøke verdien av variabler ved den nåværende utførelsestilstanden.

Det enkle programmet i det siste trinnet er for enkelt til å demonstrere feilsøking, så jeg la til litt ekstra kode til programmet. Tilleggskoden legger til to variabler.

For å utnytte feilsøkingsverktøyene må du først angi ett eller flere bruddpunkter. For å angi et brytpunkt, klikk på linjenummeret der du ønsker å avbryte utførelsen; et rødt rektangelikon vises, og hele linjen får en rød bakgrunn (bilde ett).

For å feilsøke programmet som kjører på Pi, klikker du på Debug -ikonet (umiddelbart til høyre for Run -ikonet) i NetBeans -hovedvinduet. Som med vanlig utførelse, kompilerer, bygger, laster ned, kjører, fanger ut NetBeans utdata og gjenspeiler utdataene. Men med feilsøking stopper NetBeans utførelsen ved brytpunkter og lar deg undersøke utførelsestilstanden (bilde to, som viser panelet Variabler nederst til høyre).

Utførelsen stopper ved brytepunktet før instruksjonen utføres på linjen med bruddpunktet. Den grønne bakgrunnen indikerer den neste setningen som skal utføres. Således i mitt eksempel, med et brytpunkt på linje 9, eksisterer variabel a ennå ikke, langt mindre har en verdi.

Hold nå markøren over feilsøkingsmenyikonet i hovedvinduet (det første dobbeltpilen nedover til høyre for feilsøkingsikonet) og klikk på trinnover-ikonet (det har et blått dokument i bakgrunnen og en grønn pil mot klokken i forgrunnen). [MERK: Hvis du gjør NetBeans -hovedvinduet stort nok, utvides feilsøkingsmenyen og feilsøkingsikonene vises til høyre for feilsøkingsikonet.] NetBeans kjører setningen ved brytpunktet og stopper utførelsen før neste setning. Du vil nå se at variabelen a eksisterer og har den forventede verdien (bilde tre).

Klikk på Step Over -ikonet to ganger. Du vil se at alle tre variablene har verdier; Vær oppmerksom på at c fortsatt er null (bilde fire).

Klikk på Step Over -ikonet en gang. Du vil se at variabelen c nå har den riktige verdien, dvs. summen av variablene a og b (bilde fem).

Til slutt klikker du på Kjør -ikonet i feilsøkingsmenyen (en grønn sirkel med en hvit pil). Det får kjøringen til å fortsette til neste brytpunkt, eller til slutten av programmet, avhengig av hva som kommer først. Nå vises Output -ruten og viser den samme outputen som ved normal kjøring, i dette tilfellet teksten i utskriftssetningen.

Trinn 8: Utfør programmet uavhengig av NetBeans

Tiden kan komme når du vil kjøre programmet ditt på Raspberry Pi, uten "assistanse" eller "forstyrrelser" fra NetBeans. Det er veldig enkelt. Først åpner du en ssh -klient til din Pi.

Husk fra trinn 3 at NetBeans plasserer prosjektglasset i en arbeidskatalog på Pi. Standardbasen er/home/pi/NetBeansProjects for user pi. Den spesifikke katalogen har samme navn som prosjektet ditt. NetBeans plasserer glasset i en underkatalog som kalles dist. For mitt eksempel er hele banen/home/pi/NetBeansProjects/MyRemoteProg/dist. I ssh -klienten på Pi kan du bruke java -kommandoen for å kjøre programmet med alternativet 'jar':

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

Du vil se resultatene av utførelsen i ssh -klienten; i mitt eksempel vil utgangen være

Hei fra Raspberry Pi!

Dette fungerer fordi informasjonen i jar -filen identifiserer hvilken hovedklasse i glasset som skal kjøres.

Du kan også endre arbeidskatalogen (via cd) til plasseringen av jar -filen og deretter utstede en kortere kommando for å produsere de samme resultatene.

java -jar MyRemoteProg.jar

Trinn 9: Bygg og last ned, men ikke kjør programmet via NetBeans

Det er situasjoner der du vil at NetBeans skal bygge og laste ned programmet, men ikke utføre det. En slik situasjon oppstår når programmet trenger tastaturinngang. Hvis dette er tilfelle, ved å bruke teknikken i forrige trinn, når du bygger og laster ned, kjører programmet på Raspberry Pi og forventer så tastaturinngang fra Pi, men det er selvfølgelig ikke tastatur festet til Pi, så programmet henger - ikke bra.

Du må bruke en litt annen teknikk for å utføre programmet. I utgangspunktet lager du en "dummy" hovedklassefil som egentlig ikke gjør noe, og identifiserer den som programmet som skal kjøres etter nedlasting. I dette tilfellet blir "dummy" kjørt, og du kan deretter kjøre ditt "ekte" program direkte på Pi.

For å bruke denne teknikken må du først lage en ny hovedklasse:

1. Åpne prosjektmenyen som i trinn 5 og klikk på Ny-> Java hovedklasse. Du vil se New Java Main Class -popupen.
2. Skriv inn et navn i feltet Klassenavn. Navnet kan være hva du vil; Jeg brukte "Dummy". Pakken -feltet lar deg identifisere klassens pakke; du velger pakke ved å bruke rullegardinmenyen til høyre for feltet. Klassen kan være i samme pakke som ditt "ekte" program eller i en annen pakke; Jeg la den nye klassen i samme pakke. Klikk på Fullfør. Du vil nå se NetBeans hovedvindu med den nye filen øverst i høyre panel (bilde ett). Jeg la til en enkel utskriftserklæring om å kjøre på Pi, men ingenting er virkelig nødvendig.

For å kjøre "Dummy" etter nedlasting må du gjøre den til "hovedklassen som skal utføres som standard" for prosjektet:

1. Åpne prosjektegenskapene som i trinn 5. Velg kategorien Kjør. Klikk Bla gjennom til høyre for feltet Hovedklasse. Du vil se Bla gjennom hovedklasser -popup (bilde to).
2. Velg klassen "Dummy". Klikk på Velg hovedklasse. Du vil igjen se prosjektegenskapene.
3. Klikk OK. Du kommer tilbake til hovedvinduet.

Når du klikker på Kjør -ikonet, følger/bygger NetBeans hele prosjektet, laster ned glasset som inneholder alle klassefilene til Pi og kjører "Dummy" -klassen (bilde tre).

For å utføre ditt virkelige program på Pi, må du nå bruke java -kommandoen med alternativet 'classpath', som krever at du eksplisitt identifiserer hovedklassen som skal kjøres. Fra en ssh -klient går du til dist -katalogen for prosjektet ditt. Den riktige kommandoen er av formen:

java -cp project_name.jar package_name.class_name

Project_name refererer åpenbart til prosjektet; som bare endres når vi arbeider med et nytt prosjekt. Package_name refererer selvfølgelig til pakken, og class_name refererer til hovedklassen som skal kjøres. Som sagt tidligere, kan et prosjekt inneholde mange pakker. På samme måte kan en pakke inneholde mange klasser, og alle kan være hovedklasser eller programmer som kan kjøres fra kommandolinjen. Dermed er 'classpath' -teknikken ganske nyttig for å utvikle sofistikerte programmer med mange klasser, hvorav noen bare er hovedklasser for å hjelpe enhetstesting.

Følgende kommando utfører mitt eksempelprogram:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Trinn 10: Utnytt NetBeans Library Management

En av de tøffeste, men viktigste aspektene ved sofistikerte programmer er å håndtere biblioteker, dvs. kode noen andre allerede har skrevet. NetBeans gjør en beundringsverdig jobb med å fjerne det meste av smerten ved biblioteksadministrasjon.

Jeg vil bruke som et eksempel Pi4J, som gir Java -programmer tilgang til Raspberry Pi GPIO, I2C -bussen og annen maskinvare -I/O. Pi4J er bare ett eksempel på støtte for å gjøre mange morsomme ting på Pi med Java.

Du må først laste ned biblioteket til arbeidsstasjonen din. Se nedlastingssiden for Pi4J. Siden du ikke installerer Pi4J på Pi, kan du laste ned zip til arbeidsstasjonen din. Du må kanskje ikke eksplisitt pakke ut zip -en når zip -filen er lastet ned.

Nå må du opprette et "globalt bibliotek" i NetBeans:

1. Klikk på Verktøy -> Biblioteker i hovedmenyen i NetBeans. Du vil se Ant Library Manager -popupen (bilde én).
2. Klikk på Nytt bibliotek nederst til venstre. Du vil se popup -vinduet Nytt bibliotek (bilde to).
3. Skriv inn et meningsfylt navn du vil bruke, og klikk OK. Du vil igjen se Ant Library Manager -popupen. Det viser nå det nye biblioteket du opprettet (bilde tre).
4. Klikk på Legg til JAR/mappe til høyre. Du vil se bla gjennom JAR/mappe -popup (bilde fire).
5. Naviger til og velg deretter pi4j-core.jar. Klikk deretter på Legg til JAR/mappe. Du kommer tilbake til Ant Library Manager -popup -vinduet.
6. Klikk på OK i popup -vinduet Ant Library Manager. Du kommer tilbake til NetBeans hovedvindu.

Du har lagt til biblioteket slik at det kan brukes i ethvert prosjekt. Nå må du legge til biblioteket i prosjektet ditt:

1. Åpne popup -vinduet Prosjektegenskaper (se trinn 5) og velg kategorien Bibliotek (bilde fem).
2. Klikk på Legg til bibliotek på høyre side av forgrunnsvinduet. Du vil se Legg til bibliotek -popup (bilde seks).
3. Naviger til biblioteket og velg det. Klikk deretter på Legg til bibliotek. Du vil igjen se Project Properties -popup -vinduet. Biblioteket vises nå i listen over kompileringstidsbiblioteker i forgrunnsvinduet.
4. Klikk på OK i popup -vinduet Prosjektegenskaper. Du kommer tilbake til hovedvinduet.

Du har lagt til biblioteket i prosjektet ditt slik at programmet ditt kan bruke det. Du kan utføre samme handlingsrekkefølge for alle biblioteker du trenger for et program.

Det er tre ganger du trenger biblioteket - kompilere, bygge og utføre. Heldigvis håndterer alt med NetBeans å legge til biblioteket som vist ovenfor. For å bekrefte dette har jeg laget en annen hovedklasse som gjør det absolutte minimum som er nødvendig for å bruke I2C -funksjonen i Pi4J (bilde syv). Det at det ikke er noen feil som viser betyr at klassen TestPi4J kompilerer. Hvis du klikker på Kjør, bygger og laster du ned; NetBeans laster ned biblioteket i tillegg til jar -filen, så programmet kjøres. For å bekrefte sistnevnte kan du bruke teknikken i trinn 9 og i ssh -klienten angi følgende kommando (fra dist -katalogen):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Det er lærerikt å forstå hvordan NetBeans håndterer biblioteker. Mens du er i dist -katalogen for prosjektet, viser du innholdet i katalogen (bruk kommandoen ls), og du vil se en lib -underkatalog. List innholdet i den katalogen, og du vil se jar-filen identifisert i det globale biblioteket, som i mitt eksempel er pi4j-core.jar. Alle bibliotekene du legger til i prosjektet vil vises i lib -katalogen, og er dermed tilgjengelige for alle programmene i prosjektboksfilen.

Trinn 11: Go Have Fun

Jeg har beskrevet en tilnærming for å oppnå meget effektiv Java -utvikling for Raspberry Pi. Raspberry Pi er en enormt populær teknologi for et bredt spekter av prosjekter. Java er et profesjonelt programmeringsspråk som gir ytelsesfordeler i forhold til Python og tilbyr sikkerhetsfordeler i forhold til C/C ++. NetBeans er en profesjonell IDE som øker programmererens produktivitet kraftig.

Jeg synes kombinasjonen er ganske overbevisende. Nå, ha det gøy med kombinasjonen for prosjektene dine.