Efficiënte Java-ontwikkeling voor de Raspberry Pi 11 stappen (met afbeeldingen)

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:14

Dit Instructable beschrijft een zeer efficiënte aanpak voor het ontwikkelen van Java-programma's voor de Raspberry Pi. Ik heb de aanpak gebruikt om Java-mogelijkheden te ontwikkelen, variërend van apparaatondersteuning op laag niveau tot multi-threaded en netwerkgebaseerde programma's. De aanpak is niet alleen efficiënt, het is gratis!

In wezen is de aanpak ontwikkeling op afstand met behulp van NetBeans. NetBeans draait op een werkstation (een desktop- of laptopcomputer, niet de Raspberry Pi) die via wifi is verbonden met de Raspberry Pi. Zodra alles correct is ingesteld, kunt u een Java-programma schrijven in NetBeans en vervolgens compileert en bouwt u het programma op het werkstation met een enkele klik, downloadt het programma naar de Pi, voert het programma uit op de Pi en levert het uitvoer aan de NetBeans-console. Magie! U kunt zelfs het lopende programma debuggen, breekpunten instellen en variabele waarden onderzoeken. Meer magie!

De rest van deze inleiding beschrijft de motivatie voor het gebruik van Java en voor ontwikkeling op afstand met NetBeans. Als je om motivatie geeft, lees dan verder. Als het je niet kan schelen, ga dan naar stap 1.

Waarom Java gebruiken op de Raspberry Pi?

Er zijn veel programmeertalen beschikbaar voor de Raspberry Pi, maar ik beperk de discussie tot "professionele" programmeertalen die zich richten op zelfstandige programma's, multitasking ondersteunen, hardware- en netwerktoegang toestaan, enz. Dat betekent Java, Python of C/C++. De meest recente releases van Raspbian bevatten ontwikkelings- en runtime-ondersteuning voor al deze talen.

Python is in feite "gepromoveerd" voor gebruik op de Pi, althans gedeeltelijk vanwege het leergemak voor nieuwe programmeurs. Ik ben een ervaren programmeur en ben niet dol op Python vanwege een weliswaar subjectieve afkeer van een aantal van zijn kenmerken, bijvoorbeeld dynamisch typen. Er is één kenmerk van Python waar ik een hekel aan heb: prestatie. Deze bron laat zien dat Java altijd sneller is dan Python 3, en in feite honderden keren sneller kan draaien, afhankelijk van de taak.

C is naar mijn mening een "machinetaal op hoog niveau", d.w.z. iets dat heel dicht bij de systeemhardware ligt, of in ieder geval het besturingssysteem. Je kunt vrijwel alles doen, en je kunt het zo snel mogelijk doen; in feite suggereert deze bron dat C tot 7x zo snel kan lopen als Java. Ik ben ook niet dol op C omdat ik (subjectief) een hekel heb aan sommige van zijn kenmerken die ik geheimzinnig, archaïsch of beide vind; bijvoorbeeld expliciete aanwijzingen. Objectief gezien betekent het feit dat je alles kunt doen dat je slechts een obscure bug (bijv. Java voorkomt dergelijke gevaren, dus Java is veiliger. Ik heb het gevoel dat de veiligheid ook de productiviteit van de programmeur verbetert. Ik beschouw C ++ als een objectgeoriënteerde "wrapper" rond C die niets doet om de gevaren van C te elimineren.

Waar het op neerkomt: Java is sneller dan Python. Java is veiliger dan C.

Zijn er beperkingen bij het gebruik van Java?

Tot nu toe heb ik alles in Java kunnen doen wat ik in Python kan doen. Er zijn dingen die je in C kunt doen die je niet in Java kunt doen, maar nogmaals, tot nu toe is alles wat ik wilde doen aangepakt door Java-fans in de Pi-gemeenschap. Ik zal in een latere stap een voorbeeld geven. Dat gezegd hebbende, ik heb sensoren gekocht van leveranciers die "stuurprogramma's" voor de sensoren alleen in Python (of C/C++ voor de Arduino) leverden, dus ik moest het Java-equivalent schrijven; de extra inspanning is niet per se productief, maar kan leiden tot meer inzicht in de werking van een sensor.

Waarom ontwikkelen op afstand op basis van NetBeans?

Ik heb ontdekt dat op NetBeans gebaseerde ontwikkeling op afstand de productiviteit aanzienlijk verhoogt bij het gebruik van Java voor de Raspberry Pi. Ik ben ervan overtuigd dat je de aanpak kunt gebruiken om snelle en veilige programma's te maken, vanwege de inherente kenmerken van Java, terwijl je ze veel sneller schrijft, bouwt en debugt dan andere benaderingen die ik heb gevonden, dankzij ontwikkeling op afstand met behulp van de "professionele grade" NetBeans Integrated Development Environment (IDE).

Het kan nuttig zijn om die "andere benaderingen" kort te bespreken. Ze voldoen allemaal aan de basiscriteria dat de Raspberry Pi geen toetsenbord, muis of beeldscherm heeft aangesloten. Er zijn veel redenen voor dit criterium, maar mijn belangrijkste reden is dat ik mobiele robots ontwikkel, en ik wil niet dat de Pi is aangesloten op randapparatuur behalve robotsubsystemen, zelfs niet tijdens de ontwikkeling.

De VNC-server in Raspbian biedt een externe grafische gebruikersinterface (GUI) die een vorm van ontwikkeling op afstand mogelijk maakt, waarbij alleen de externe GUI op het werkstation draait en al het andere, schrijven, compileren en bouwen, plaatsvindt op de Pi. Met VNC is het gemakkelijk om de Java-compatibele ontwikkelingstools te gebruiken die in Raspbian worden geleverd, zoals BlueJ, Geany en Greenfoot. Sommige hiervan kunnen als een IDE worden beschouwd; ik vind ze echter verre van professionele kwaliteit.

Het is technisch mogelijk om een professionele Java IDE zoals Eclipse of NetBeans op de Raspberry Pi te installeren en deze op afstand te gebruiken via VNC. Rapporten en gezond verstand suggereren dat de resultaten teleurstellend zouden zijn, vanwege de grote geheugenvoetafdruk en CPU-kracht die dergelijke IDE's vereisen, evenals netwerklatentie die wordt geïntroduceerd door een externe GUI.

Zowel Eclipse als NetBeans werken erg goed op een werkstation. Met Eclipse is het schrijven van code een prettige ervaring, maar het bouwen van het programma is dat niet; het downloaden van het programma moet buiten Eclipse plaatsvinden; het uitvoeren van het programma op de Pi is volledig onafhankelijk van Eclipse. Het algemene resultaat is een meerstaps, bijna pijnlijk proces dat foutopsporing op afstand niet ondersteunt. NetBeans heeft ingebouwde compileren, bouwen, downloaden, uitvoering op afstand en foutopsporing op afstand, waardoor het een superieure aanpak is.

Stap 1: Stel de Raspberry Pi in

Om de ontwikkelingsaanpak op afstand te gebruiken, moet u beginnen met het instellen van de doel-Raspberry Pi. Er zijn veel bronnen, waaronder Instructables, beschikbaar om te helpen bij het opzetten van een Raspberry Pi. Zie dit voor de basisprincipes van het instellen van de Pi (en meer).

Dit Instructable gaat ervan uit dat je

• installeer de nieuwste Raspbian; zorg ervoor dat u de Pi-gebruikers-ID en het wachtwoord noteert
• wifi instellen en verbinden met je router (zie dit); zorg ervoor dat je het IP-adres van de Pi noteert
• schakel SSH in (zie dit) om externe toegang tot de Pi vanaf het werkstation toe te staan

Nadat u de installatie hebt voltooid, kunt u het scherm, het toetsenbord en de muis uitschakelen en loskoppelen van de Pi. Dit is een van de belangrijkste voordelen van ontwikkeling op afstand. Je moet elke Wifi-dongle aangesloten laten (uiteraard niet nodig voor een Pi-model 3 of Pi Zero W), en dan kun je de Pi inschakelen.

Om te testen, opent u een ssh-client op uw werkstation, bijvoorbeeld Terminal op MacOS of putty op Windows. Voer vervolgens de opdracht ssh (secure shell) in met het volgende formulier:

ssh the_pi_ip_address -l the_pi_user_id

U zou een prompt moeten krijgen om het wachtwoord van uw Pi-gebruikers-ID in te voeren. Als er geen prompt verschijnt, controleer dan of je het juiste IP-adres hebt ingevoerd in de ssh-opdracht. Voer je wachtwoord in (het wordt verborgen) en je zou dan de shell-prompt van de Pi moeten zien die er ongeveer zo uitziet:

pi@raspberrypi:~ $

Als u de prompt niet ziet, controleert u de gebruikers-ID en het wachtwoord dat u hebt gebruikt.

Nu moet je het pad naar de Java-runtime vinden en bevestigen dat de standaardversie Java 8 is (moet waar zijn voor de nieuwste Raspbian). Om het Java-runtimepad te vinden, voert u in de ssh-client de opdracht in:

sudo update-alternatives --display java

U zou een reactie moeten zien met de eerste twee regels die er als volgt uitzien:

java - automatische modus

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

De "-8-" in de tweede regel bevestigt dat de standaard runtime Java 8 is. Noteer het pad in de tweede regel, aangezien u dit in een latere stap nodig zult hebben om NetBeans te configureren voor ontwikkeling op afstand.

Als de standaardruntime niet Java 8 is, voert u in de ssh-client de volgende opdracht in om over te schakelen naar Java 8 (ervan uitgaande dat het is geïnstalleerd)

sudo update-alternatives --config java

Stap 2: Installeer NetBeans op het werkstation

Nu moet je NetBeans op je werkstation installeren. Ga met uw werkstationbrowser naar de NetBeans-downloadpagina. U zult verschillende mogelijke bundels zien die zowel de twee edities van Java als andere talen ondersteunen. Alles wat je nodig hebt voor Java-ontwikkeling voor de Raspberry Pi is Java SE, maar je kunt de Java EE-bundel of de All-bundel krijgen. Zodra je hebt besloten welke bundel je wilt, klik je op de bijbehorende downloadknop. Aanvullende installatie-instructies voor het besturingssysteem van uw werkstation vindt u hier.

Zodra je NetBeans hebt geïnstalleerd, start je het (dit kan automatisch gebeuren na de installatie). U zou het hoofdvenster van NetBeans moeten zien zoals weergegeven in de afbeelding. De foto is gemaakt op een Mac en het hoofdvenster kan er op Windows iets anders uitzien.

Nadat u NetBeans met succes hebt geïnstalleerd en gestart, gaat u verder met de volgende stap.

Stap 3: Configureer de Raspberry Pi als een extern platform in NetBeans

De volgende acties configureren de Raspberry Pi als een extern Java SE-platform voor NetBeans. Hierdoor kan NetBeans Java-programma's downloaden en uitvoeren op de Pi. Een ietwat generieke beschrijving vind je hier.

OPMERKING: In deze en volgende stappen toon ik waarden die specifiek zijn voor mijn omgeving voor verschillende aspecten van configuratie en codering; die van jou zal duidelijk anders zijn.

De Pi configureren als een extern platform:

1. Selecteer in de hoofdmenubalk van NetBeans Tools -> Java Platforms. U ziet het pop-upvenster Java Platform Manager (afbeelding één).
2. Klik linksonder op Platform toevoegen. U ziet de pop-up Java-platform toevoegen [platformtype] (afbeelding twee).
3. Kies Remote Java Standard Edition. Klik volgende. Je zult de Add Java Platform [set up remote platform] pop-up zien (afbeelding drie toont de pop-up nadat ik de juiste waarden voor mijn omgeving in de velden heb ingevoerd).
4. Voer in het veld Platformnaam een naam in voor de Pi. Je kunt vrijwel alles gebruiken, maar het moet wel uniek zijn.
5. Voer in het veld Host het IP-adres in voor de Pi die u in stap 1 hebt gevonden.
6. Voer in het veld Gebruikersnaam de gebruikersnaam in die u in stap 1 hebt gebruikt.
7. Laat Wachtwoordverificatie gebruiken geselecteerd en voer in het veld Wachtwoord het wachtwoord in dat u in stap 1 hebt gemaakt.
8. In het veld JRE-pad op afstand moet u het grootste deel van het pad naar de Java-runtime op de Pi invoeren. In stap 1 was het /usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java. U moet echter /bin/java achterlaten in de veldwaarde.
9. NetBeans downloadt het uitvoerbare programma naar een werkmap op de Pi, geïdentificeerd in het veld Working Dir. De standaard is /the_Pi_user_ID/NetBeansProjects/ en het is volkomen acceptabel. Je kunt iets anders gebruiken als je wilt, hoewel het beschikbaar moet zijn voor de_Pi_user_ID (afbeelding drie).
10. Klik op Voltooien rechtsonder in de pop-up. Na verwerking zou u opnieuw het pop-upvenster Java Platform Manager moeten zien. Nu zou je je remote Pi (onder de naam die je in actie 4 hierboven hebt gebruikt) moeten zien onder de categorie Remote Java SE (afbeelding vier).
11. Klik linksonder op Test Platform om de verbinding tussen NetBeans en je Pi te testen. U zult eerst een pop-up zien met de tekst Verifying Remote Platform. Als dit is gelukt, krijgt u een tweede pop-upvenster met de melding dat de verbinding … succesvol tot stand is gebracht. Als dat niet het geval is, moet u de informatie controleren en corrigeren die u hebt ingevoerd in de pop-up Java-platform toevoegen [op afstand platform instellen] in acties 5-9 hierboven. U kunt dit doen vanuit de pop-up Java Platform Manager; selecteer eenvoudig uw Pi-platform en bewerk vervolgens de velden aan de rechterkant van de pop-up.
12. Klik na een succesvolle verbinding op Sluiten in de pop-up Java Platform Manager. U ziet nu het hoofdvenster van NetBeans.

Nu kan het echte genieten beginnen!

Stap 4: Maak een Java-project op het werkstation

Dit is niet bedoeld als een volledige uitleg van het gebruik van NetBeans of Java, maar ik zal de minimale handelingen beschrijven om een programma in NetBeans op het werkstation te schrijven en uiteindelijk het programma op afstand op de Raspberry Pi uit te voeren.

In NetBeans moet u eerst een project maken om de Java-klasse(n) voor het programma te bevatten. Verder bevinden klassen zich in Java in pakketten om de organisatie en beveiliging te ondersteunen. Om het project aan te maken en optioneel een pakket en een klassenbestand te maken:

1. Klik in het hoofdvenster van NetBeans op het nieuwe projectpictogram (2e van links). U ziet de pop-up Nieuw project [kies project] (foto één).
2. De standaardwaarden (Categorie: Java, Project: Java-toepassing) zijn correct voor dit voorbeeld, dus klik gewoon op Volgende. U ziet de pop-up Nieuwe Java-toepassing [naam en locatie] (afbeelding twee toont waarden voor mijn voorbeeld). OPMERKING: ik heb mijn gebruikersinformatie geredigeerd met behulp van de gekleurde rechthoeken.
3. Voer in het veld Projectnaam een geldige Java-projectnaam naar keuze in. De naam moet beginnen met een hoofdletter, en conventie suggereert kameelgeval bij het aaneenschakelen van woorden.
4. Het veld Projectlocatie bepaalt waar het project zich in uw bestandssysteem bevindt. De standaardwaarde is afhankelijk van het besturingssysteem, maar kan veilig worden geaccepteerd.
5. In het veld Projectmap kunt u de mapnaam voor het project beheren. Ik vind het het beste om de standaard te gebruiken, wat een aaneenschakeling is van het veld Locatie en het veld Naam.
6. Als het selectievakje Hoofdklasse maken is aangevinkt, maakt NetBeans automatisch een pakket en een hoofdklassebestand (een programma dat vanaf de opdrachtregel kan worden uitgevoerd) met dezelfde naam als het project. Ik denk dat het normaal gesproken niet aangevinkt zou moeten zijn, maar in dit geval laat ik het aangevinkt, wat expliciete acties elimineert die anders nodig zijn om dit te doen (afbeelding twee).
7. Klik op Voltooien om het project, een pakket en een hoofdklassebestand te maken. Nu toont het linkerbovenpaneel van het hoofdvenster van NetBeans uw project, dat een enkel pakket bevat, dat op zijn beurt een enkel klassenbestand met een main()-methode bevat. Het deelvenster rechtsboven bevat de standaardbroncode voor de hoofdklasse (het programma) die automatisch wordt gegenereerd door NetBeans (afbeelding drie).

Op dit punt zou u wat code in de hoofdmethode kunnen schrijven en deze op het werkstation kunnen uitvoeren. Dat kan soms wenselijk zijn, maar is niet nodig voor deze Instructable, dus ga verder met de volgende stap.

Stap 5: Configureer het NetBeans-project om op afstand op de Raspberry Pi te draaien

Om het NetBeans-project en een programma dat het bevat, te configureren om op afstand op de Raspberry Pi te draaien, doe je het volgende:

1. Klik met de rechtermuisknop of met twee vingers (afhankelijk van het besturingssysteem van het werkstation) op het project in het deelvenster Projecten van het hoofdvenster van NetBeans om het projectmenu te openen en klik op Eigenschappen. U ziet de pop-up Projecteigenschappen (de afbeelding toont de pop-up met de juiste waarden voor mijn voorbeeld).
2. Selecteer onder Categorieën aan de linkerkant Uitvoeren.
3. Klik op Nieuw rechts van het veld Configuratie. Voer in het resulterende pop-upvenster Nieuwe configuratie maken een naam in voor de configuratie en klik op OK. De naam kan van alles zijn; Ik heb zojuist de naam van het platform ("My Pi") hergebruikt. Nogmaals, je ziet de pop-up Projecteigenschappen.
4. Klik op het vervolgkeuzepictogram rechts van het veld Runtime Platform. Selecteer in de lijst in de pop-up het externe platform dat u eerder hebt gemaakt (in mijn omgeving, "Mijn Pi").
5. Klik op OK om het externe platform voor het project in te stellen. U ziet opnieuw het hoofdvenster.

U bent nu klaar om code te schrijven en het programma op afstand uit te voeren.

Stap 6: Schrijf een Java-programma op het werkstation en voer het uit op de Raspberry Pi

Het rechterpaneel in het hoofdvenster van NetBeans toont het hoofdklassebestand dat door NetBeans is gegenereerd. Typ een eenvoudige printopdracht in de hoofdmethode van het klassenbestand (afbeelding één). Het is nu een compleet Java-programma dat iets doet, maar wel iets heel eenvoudigs.

Om het programma op de Pi uit te voeren, klikt u op het pictogram Uitvoeren (de groene naar links wijzende pijl) in het hoofdvenster. NetBeans compileert de code, bouwt een jar-bestand, downloadt het jar-bestand naar de Raspberry Pi die wordt geïdentificeerd door het externe platform, voert het programma uit op de Pi, legt de uitvoer (System.out) van het programma vast en echoot die uitvoer naar de NetBeans Uitvoervenster rechtsonder in het hoofdvenster (afbeelding twee).

Je hebt nu je vaardigheden voor het ontwikkelen van projecten op de Raspberry Pi aanzienlijk uitgebreid! Maar wacht…. Er is meer!

Stap 7: Debug het Java-programma met NetBeans

Een van de krachtigste kenmerken van een geïntegreerde ontwikkelomgeving met industriële kracht, zoals NetBeans, is de mogelijkheid om fouten in het programma op te sporen terwijl het wordt uitgevoerd. Met NetBeans kunt u gebruikmaken van de volledige reeks debugging-tools terwijl u op afstand werkt. Dit omvat het instellen van breekpunten op "belangrijke" of "lastige" locaties in het programma en het onderzoeken van de waarde van variabelen in de huidige uitvoeringsstatus.

Het eenvoudige programma in de laatste stap is te eenvoudig om foutopsporing te demonstreren, dus heb ik wat extra code aan het programma toegevoegd. De aanvullende code voegt twee variabelen toe.

Om gebruik te kunnen maken van de foutopsporingsprogramma's, moet u eerst een of meer onderbrekingspunten instellen. Om een onderbrekingspunt in te stellen, klikt u op het regelnummer waar u de uitvoering wilt onderbreken; er verschijnt een rood rechthoekig pictogram en de hele regel krijgt een rode achtergrond (afbeelding één).

Om fouten op te sporen in het programma dat op de Pi draait, klikt u op het pictogram Debug (direct rechts van het pictogram Uitvoeren) in het hoofdvenster van NetBeans. Net als bij normale uitvoering, compileert, bouwt, downloadt, voert NetBeans uit, legt het de uitvoer vast en echoot die uitvoer. Maar met debuggen stopt NetBeans de uitvoering op breekpunten en kunt u de uitvoeringsstatus onderzoeken (afbeelding twee, met het paneel Variabelen rechtsonder).

De uitvoering stopt bij het breekpunt voordat de instructie wordt uitgevoerd op de regel met het breekpunt. De groene achtergrond geeft het volgende uit te voeren statement aan. Dus in mijn voorbeeld, met een breekpunt op regel 9, bestaat variabele a nog niet, laat staan een waarde hebben.

Beweeg de cursor nu over het debug-menupictogram in het hoofdvenster (het eerste pictogram met dubbele pijl-omlaag rechts van het pictogram Debug) en klik op het pictogram Step Over (het heeft een blauw document op de achtergrond en een groene pijl tegen de klok in op de voorgrond). [OPMERKING: als u uw NetBeans-hoofdvenster breed genoeg maakt, wordt het debug-menu groter en verschijnen de debug-actiepictogrammen rechts van het Debug-pictogram.] NetBeans voert de instructie uit op het breekpunt en stopt de uitvoering vóór de volgende instructie. Je zult nu zien dat de variabele a bestaat en de verwachte waarde heeft (afbeelding drie).

Klik twee keer op het pictogram Overstappen. Je zult zien dat alle drie de variabelen waarden hebben; merk op dat c nog steeds nul is (afbeelding vier).

Klik eenmaal op het pictogram Overstappen. Je zult zien dat variabele c nu de juiste waarde heeft, d.w.z. de som van variabelen a en b (afbeelding vijf).

Klik ten slotte in het foutopsporingsmenu op het pictogram Uitvoeren (een groene cirkel met een witte pijl). Dat zorgt ervoor dat de uitvoering doorgaat tot het volgende onderbrekingspunt, of tot het einde van het programma, wat zich het eerst voordoet. Nu verschijnt het deelvenster Uitvoer en toont dezelfde uitvoer als bij normale uitvoering, in dit geval de tekst in het printstatement.

Stap 8: Voer het programma onafhankelijk van NetBeans uit

Er kan een moment komen dat je je programma op de Raspberry Pi wilt uitvoeren, zonder "hulp" of "interferentie" van NetBeans. Het is erg makkelijk. Open eerst een ssh-client naar uw Pi.

Onthoud vanaf stap 3 dat NetBeans uw projectpot in een werkmap op de Pi plaatst. De standaardbasis is /home/pi/NetBeansProjects voor gebruiker pi. De specifieke map heeft dezelfde naam als uw project. NetBeans plaatst de jar in een submap met de naam dist. Voor mijn voorbeeld is het volledige pad /home/pi/NetBeansProjects/MyRemoteProg/dist. In de ssh-client op de Pi, om het programma uit te voeren, kun je het java-commando gebruiken met de 'jar'-optie:

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

U ziet de resultaten van de uitvoering in de ssh-client; in mijn voorbeeld zal de output zijn

Hallo van Raspberry Pi!

Dit werkt omdat informatie in het jar-bestand aangeeft welke hoofdklasse in de jar moet worden uitgevoerd.

U kunt ook de werkdirectory (via cd) wijzigen naar de locatie van het jar-bestand en dan een kortere opdracht geven om dezelfde resultaten te produceren.

java -jar MyRemoteProg.jar

Stap 9: Bouw en download, maar voer het programma niet uit via NetBeans

Er zijn situaties waarin u wilt dat NetBeans uw programma bouwt en downloadt, maar het niet uitvoert. Een dergelijke situatie doet zich voor wanneer uw programma toetsenbordinvoer nodig heeft. Als dit het geval is, wordt het programma, met behulp van de techniek in de vorige stap, zodra u het hebt gebouwd en gedownload, uitgevoerd op de Raspberry Pi en verwacht dus toetsenbordinvoer van de Pi, maar er is natuurlijk geen toetsenbord aangesloten op de Pi. dus het programma blijft hangen -- niet goed.

U moet een iets andere techniek gebruiken om het programma uit te voeren. Fundamenteel maakt u een "dummy" hoofdklassebestand dat in wezen niets doet, en identificeert u het als het programma dat moet worden uitgevoerd na het downloaden. In dit geval wordt de "dummy" uitgevoerd en kunt u uw "echte" programma rechtstreeks op de Pi uitvoeren.

Om deze techniek te gebruiken, maakt u eerst een nieuwe hoofdklasse aan:

1. Open het projectmenu zoals in stap 5 en klik op Nieuw->Java Main Class. U ziet de pop-up New Java Main Class.
2. Voer in het veld Class Name een naam in. De naam kan van alles zijn; Ik heb "Dummie" gebruikt. In het veld Pakket kunt u het pakket van de klas identificeren; u selecteert pakket met behulp van de vervolgkeuzelijst rechts van het veld. De klasse kan in hetzelfde pakket zitten als je "echte" programma of in een ander pakket; Ik heb de nieuwe klasse in hetzelfde pakket geplaatst. Klik op Voltooien. U ziet nu het hoofdvenster van NetBeans met het nieuwe bestand in het paneel rechtsboven (afbeelding één). Ik heb een eenvoudige printverklaring toegevoegd over het draaien op de Pi, maar niets is echt nodig.

Om "Dummy" na het downloaden uit te voeren, moet u het de "hoofdklasse maken die standaard moet worden uitgevoerd" voor het project:

1. Open de Projecteigenschappen zoals in stap 5. Selecteer de categorie Uitvoeren. Klik op Bladeren rechts van het veld Hoofdklasse. U ziet de pop-up Bladeren door hoofdklassen (afbeelding twee).
2. Selecteer de klasse "Dummy". Klik op Hoofdklasse selecteren. U ziet weer de Projecteigenschappen.
3. Klik OK. U keert terug naar het hoofdvenster.

Als u nu op het pictogram Uitvoeren klikt, voert NetBeans het volledige project uit/bouwt het de jar met alle klassebestanden naar de Pi en voert het de klasse "Dummy" uit (afbeelding drie).

Om je echte programma op de Pi uit te voeren, moet je nu het java-commando gebruiken met de optie 'classpath', wat vereist dat je expliciet de hoofdklasse identificeert die moet worden uitgevoerd. Ga vanuit een ssh-client naar de dist-map voor uw project. Het juiste commando is van de vorm:

java -cp projectnaam.jar pakketnaam.klassenaam

De projectnaam verwijst uiteraard naar het project; dat verandert alleen bij een nieuw project. De pakketnaam verwijst natuurlijk naar het pakket en de klassenaam verwijst naar de hoofdklasse die moet worden uitgevoerd. Zoals eerder gezegd, kan een project veel pakketten bevatten. Evenzo kan een pakket veel klassen bevatten, en dit kunnen allemaal hoofdklassen of programma's zijn die vanaf de opdrachtregel kunnen worden uitgevoerd. De 'classpath'-techniek is dus heel nuttig voor het ontwikkelen van geavanceerde programma's met veel klassen, waarvan sommige hoofdklassen zijn om unit-tests te ondersteunen.

De volgende opdracht voert mijn voorbeeldprogramma uit:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Stap 10: Maak gebruik van NetBeans-bibliotheekbeheer

Een van de moeilijkste maar belangrijkste aspecten van geavanceerde programma's is het omgaan met bibliotheken, d.w.z. code die iemand anders al heeft geschreven. NetBeans doet bewonderenswaardig werk door het grootste deel van de pijn van bibliotheekbeheer weg te nemen.

Ik gebruik als voorbeeld Pi4J, dat Java-programma's toegang geeft tot de Raspberry Pi GPIO, I2C-bus en andere hardware I/O. Pi4J is maar één voorbeeld van ondersteuning voor het doen van veel leuke dingen op de Pi met Java.

U moet eerst de bibliotheek downloaden naar uw werkstation. Zie de Pi4J downloadpagina. Aangezien u Pi4J niet op de Pi installeert, downloadt u de zip naar uw werkstation. U kunt wel of niet expliciet uitpakken zodra de zip is gedownload.

Nu moet u een "algemene bibliotheek" in NetBeans maken:

1. Klik in het hoofdmenu van NetBeans op Extra ->Bibliotheken. U ziet de pop-up Ant Library Manager (afbeelding één).
2. Klik linksonder op Nieuwe bibliotheek. U ziet de pop-up Nieuwe bibliotheek (afbeelding twee).
3. Typ een betekenisvolle naam die u wilt gebruiken en klik op OK. U zult opnieuw de pop-up Ant Library Manager zien. Het toont nu de nieuwe bibliotheek die u hebt gemaakt (afbeelding drie).
4. Klik rechts op JAR/map toevoegen. U ziet de pop-up Browse JAR/Folder (afbeelding vier).
5. Navigeer naar en selecteer pi4j-core.jar. Klik vervolgens op JAR/map toevoegen. U keert terug naar de pop-up Ant Library Manager.
6. Klik in de pop-up Ant Library Manager op OK. U keert terug naar het hoofdvenster van NetBeans.

U hebt de bibliotheek toegevoegd zodat deze in elk project kan worden gebruikt. Nu moet u de bibliotheek aan uw project toevoegen:

1. Open de pop-up Projecteigenschappen (zie stap 5) en selecteer de categorie Bibliotheken (afbeelding vijf).
2. Klik op Bibliotheek toevoegen aan de rechterkant van de pop-up. U ziet de pop-up Bibliotheek toevoegen (afbeelding zes).
3. Navigeer naar de bibliotheek en selecteer deze. Klik vervolgens op Bibliotheek toevoegen. U zult opnieuw de pop-up Projecteigenschappen zien. De bibliotheek verschijnt nu in de lijst met Compile-time bibliotheken in de pop-up.
4. Klik in het pop-upvenster Projecteigenschappen op OK. U keert terug naar het hoofdvenster.

U hebt de bibliotheek aan uw project toegevoegd zodat uw programma deze kan gebruiken. U kunt dezelfde reeks acties uitvoeren voor alle bibliotheken die u voor een programma nodig hebt.

Er zijn drie keer dat je de bibliotheek nodig hebt - compileren, bouwen en uitvoeren. Gelukkig, met NetBeans, regelt het toevoegen van de bibliotheek zoals hierboven weergegeven alles. Om dit te bevestigen, heb ik nog een hoofdklasse gemaakt die het absolute minimum doet dat nodig is om de I2C-mogelijkheid in Pi4J te gebruiken (afbeelding zeven). Het feit dat er geen fouten worden weergegeven, betekent dat de klasse TestPi4J compileert. Door op Uitvoeren te klikken, bouwt en downloadt u succesvol; NetBeans downloadt de bibliotheek naast het jar-bestand, zodat het programma wordt uitgevoerd. Om dit laatste te verifiëren, kunt u de techniek in stap 9 gebruiken en in de ssh-client de volgende opdracht invoeren (uit de dist-map):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Het is leerzaam om te begrijpen hoe NetBeans omgaat met bibliotheken. Terwijl u zich in de dist-directory voor uw project bevindt, vermeldt u de inhoud van de directory (gebruik de opdracht ls) en u zult een lib-subdirectory zien. Maak een lijst van de inhoud van die map en je zult het jar-bestand zien dat is geïdentificeerd in de globale bibliotheek, wat in mijn voorbeeld pi4j-core.jar is. Alle bibliotheken die u aan het project toevoegt, verschijnen in de lib-directory en zijn dus beschikbaar voor alle programma's in het project-jar-bestand.

Stap 11: Ga veel plezier

Ik heb een aanpak beschreven voor het bereiken van zeer efficiënte Java-ontwikkeling voor de Raspberry Pi. De Raspberry Pi is een enorm populaire technologie voor een breed spectrum aan projecten. Java is een programmeertaal van professionele kwaliteit die prestatievoordelen biedt ten opzichte van Python en veiligheidsvoordelen biedt ten opzichte van C/C++. NetBeans is een professionele IDE die de productiviteit van programmeurs aanzienlijk verhoogt.

Ik denk dat de combinatie behoorlijk overtuigend is. Veel plezier met het gebruik van de combinatie voor uw projecten.