Sviluppo Java efficiente per Raspberry Pi: 11 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Questo Instructable descrive un approccio molto efficiente per lo sviluppo di programmi Java per Raspberry Pi. Ho utilizzato l'approccio per sviluppare funzionalità Java che vanno dal supporto di dispositivi di basso livello ai programmi multi-thread e basati sulla rete. L'approccio non è solo efficiente, è gratuito!

Fondamentalmente, l'approccio è lo sviluppo remoto utilizzando NetBeans. NetBeans funziona su una workstation (un computer desktop o laptop, non il Raspberry Pi) collegata tramite Wifi al Raspberry Pi. Una volta che tutto è impostato correttamente, puoi scrivere un programma Java in NetBeans e quindi un solo clic compila e costruisce il programma sulla workstation, scarica il programma sul Pi, esegue il programma sul Pi e invia l'output alla console NetBeans. Magia! Puoi persino eseguire il debug del programma in esecuzione, impostare punti di interruzione ed esaminare i valori delle variabili. Più magia!

Il resto di questa introduzione descrive la motivazione per l'utilizzo di Java e per lo sviluppo remoto utilizzando NetBeans. Se ti interessa la motivazione, continua a leggere. Se non ti interessa, vai al passaggio 1.

Perché usare Java sul Raspberry Pi?

Esistono molti linguaggi di programmazione disponibili per il Raspberry Pi, ma limiterò la discussione ai linguaggi di programmazione "di livello professionale" che prendono di mira programmi autonomi, supportano il multitasking, consentono l'accesso all'hardware e alla rete, ecc. Ciò significa Java, Python o C/C++. Le versioni più recenti di Raspbian includono il supporto per lo sviluppo e il runtime per tutte queste lingue.

Python è in effetti "promosso" per l'uso sul Pi, almeno in parte per la sua facilità di apprendimento per i nuovi programmatori. Sono un programmatore esperto e non amo Python a causa di una certa avversione soggettiva per alcune delle sue caratteristiche, ad esempio la digitazione dinamica. C'è una caratteristica di Python per cui la mia antipatia è oggettiva: le prestazioni. Questa fonte mostra che Java è sempre più veloce di Python 3 e in effetti può essere eseguito centinaia di volte più velocemente, a seconda dell'attività.

C a mio parere, è un "linguaggio macchina di alto livello", cioè qualcosa che è molto vicino all'hardware del sistema, o almeno al sistema operativo. Puoi fare praticamente qualsiasi cosa e puoi farlo il più velocemente possibile; infatti, questa fonte suggerisce che C può essere eseguito fino a 7 volte più velocemente di Java. Inoltre non amo il C poiché (soggettivamente) non mi piacciono alcune delle sue caratteristiche che trovo arcane, arcaiche o entrambe; ad esempio, puntatori espliciti. Oggettivamente, il fatto che tu possa fare qualsiasi cosa significa che sei solo un bug oscuro (ad esempio, aritmetica del puntatore errata o un memcpy errante) lontano dalla sovrascrittura della memoria e potenzialmente dal crash del programma o addirittura dell'intero sistema. Java previene tali rischi, quindi Java è più sicuro. Sento che la sicurezza migliora anche la produttività del programmatore. Considero il C++ un "involucro" orientato agli oggetti attorno al C che non fa nulla per eliminare i pericoli del C.

In conclusione: Java è più veloce di Python. Java è più sicuro di C.

Ci sono limitazioni quando si utilizza Java?

Finora, sono stato in grado di fare tutto in Java che posso fare in Python. Ci sono cose che si possono fare in C che non si possono fare in Java, ma ancora una volta, tutto ciò che volevo fare è stato affrontato dai fan di Java nella comunità Pi. Offrirò un esempio in un passaggio successivo. Detto questo, ho acquistato sensori da fornitori che fornivano "driver" per i sensori solo in Python (o C/C++ per Arduino), quindi ho dovuto scrivere l'equivalente Java; lo sforzo extra non è necessariamente produttivo, ma può portare a una maggiore comprensione del funzionamento di un sensore.

Perché lo sviluppo remoto basato su NetBeans?

Ho scoperto che lo sviluppo remoto basato su NetBeans aumenta notevolmente la produttività quando si utilizza Java per Raspberry Pi. Sono fiducioso che tu possa utilizzare l'approccio per creare programmi veloci e sicuri, a causa delle caratteristiche intrinseche di Java, mentre li scrivi, costruisci ed esegui il debug molto più rapidamente di altri approcci che ho trovato, grazie allo sviluppo remoto utilizzando il "professionista grade" NetBeans Integrated Development Environment (IDE).

Potrebbe essere utile discutere brevemente questi "altri approcci". Tutti soddisfano i criteri di base che il Raspberry Pi non ha una tastiera, un mouse o un display collegati. Ci sono molte ragioni per questo criterio, ma la mia ragione principale è che sviluppo robot mobili e non voglio che il Pi sia collegato a nessuna periferica tranne i sottosistemi robotici, anche durante lo sviluppo.

Il server VNC incluso in Raspbian fornisce un'interfaccia utente grafica remota (GUI) che consente una forma di sviluppo remoto, in cui solo la GUI remota viene eseguita sulla workstation e tutto il resto, scrittura, compilazione e costruzione, avviene sul Pi. Con VNC è facile utilizzare gli strumenti di sviluppo compatibili con Java forniti in Raspbian, come BlueJ, Geany e Greenfoot. Alcuni di questi possono essere considerati un IDE; tuttavia, li trovo lontani dal livello professionale.

È tecnicamente possibile installare un IDE Java di livello professionale come Eclipse o NetBeans sul Raspberry Pi e utilizzarlo in remoto tramite VNC. I rapporti e il buon senso suggeriscono che i risultati sarebbero deludenti, a causa dell'ampio ingombro di memoria e della potenza della CPU richiesti da tali IDE, nonché della latenza di rete introdotta da una GUI remota.

Sia Eclipse che NetBeans funzionano molto bene su una workstation. Con Eclipse, scrivere codice è un'esperienza piacevole, ma costruire il programma non lo è; il download del programma deve avvenire al di fuori di Eclipse; l'esecuzione del programma sul Pi è completamente indipendente da Eclipse. Il risultato complessivo è un processo a più passaggi, quasi doloroso, che non può supportare il debug remoto. NetBeans dispone di compilazione, compilazione, download, esecuzione remota e debug remoto integrati, il che lo rende un approccio superiore.

Passaggio 1: configura il Raspberry Pi

Per utilizzare l'approccio di sviluppo remoto è necessario iniziare impostando il Raspberry Pi di destinazione. Ci sono molte risorse, incluso Instructables, disponibili per aiutare nella configurazione di un Raspberry Pi. Vedi questo per le basi della configurazione del Pi (e altro).

Questo Instructable presuppone che tu

• installa l'ultima versione di Raspbian; assicurati di registrare l'ID utente e la password Pi
• configura il Wifi e connettiti al tuo router (vedi questo); assicurati di registrare l'indirizzo IP del Pi
• abilitare SSH (vedi questo) per consentire l'accesso remoto al Pi dalla workstation

Una volta completata la configurazione, puoi spegnere e scollegare il display, la tastiera e il mouse dal Pi. Questo è uno dei principali vantaggi dello sviluppo remoto. È necessario lasciare collegato qualsiasi dongle Wifi (non necessario, ovviamente, per un modello Pi 3 o Pi Zero W), quindi è possibile accendere il Pi.

Per testare, apri un client ssh sulla tua workstation, ad esempio Terminal su MacOS o putty su Windows. Quindi inserisci il comando ssh (secure shell) con il seguente modulo:

ssh the_pi_ip_address -l the_pi_user_id

Dovresti ricevere una richiesta per inserire la password del tuo ID utente Pi. Se non viene visualizzato alcun messaggio, verifica di aver inserito l'indirizzo IP corretto nel comando ssh. Inserisci la tua password (sarà nascosta) e dovresti quindi vedere il prompt della shell di Pi che appare in questo modo:

pi@raspberrypi:~ $

Se non vedi la richiesta, controlla l'ID utente e la password che hai utilizzato.

Ora devi trovare il percorso del runtime Java e confermare che la versione predefinita è Java 8 (dovrebbe essere vero per l'ultimo Raspbian). Per trovare il percorso di runtime Java, nel client ssh inserisci il comando

sudo update-alternatives --display java

Dovresti vedere una risposta con le prime due righe simile alla seguente:

java - modalità automatica

la versione migliore del collegamento è /usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java

Il "-8-" nella seconda riga conferma che il runtime predefinito è Java 8. Registrare il percorso nella seconda riga poiché sarà necessario per configurare NetBeans per lo sviluppo remoto in un passaggio successivo.

Se il runtime predefinito non è Java 8, nel client ssh immettere il seguente comando per passare a Java 8 (supponendo che sia installato)

sudo update-alternatives --config java

Passaggio 2: installa NetBeans sulla workstation

Ora devi installare NetBeans sulla tua workstation. Punta il browser della tua workstation alla pagina di download di NetBeans. Vedrai diversi possibili bundle che supportano le due edizioni di Java e altri linguaggi. Tutto ciò di cui hai bisogno per lo sviluppo Java per Raspberry Pi è Java SE, ma puoi ottenere il bundle Java EE o il bundle All. Una volta deciso quale pacchetto desideri, fai clic sul pulsante Download corrispondente. Puoi trovare ulteriori istruzioni di installazione per il sistema operativo della tua workstation qui.

Una volta installato NetBeans, avvialo (potrebbe farlo automaticamente dopo l'installazione). Dovresti vedere la finestra principale di NetBeans come mostrato nell'immagine. La foto è stata scattata su un Mac e la finestra principale potrebbe avere un aspetto leggermente diverso su Windows.

Dopo aver installato e avviato con successo NetBeans, procedi al passaggio successivo.

Passaggio 3: configura il Raspberry Pi come piattaforma remota in NetBeans

Le seguenti azioni configurano il Raspberry Pi come piattaforma Java SE remota per NetBeans. Ciò consente a NetBeans di scaricare ed eseguire programmi Java sul Pi. Puoi trovare una descrizione un po' generica qui.

NOTA: In questo e nei seguenti passaggi, mostro i valori specifici del mio ambiente per vari aspetti della configurazione e della codifica; il tuo sarà ovviamente diverso

Per configurare il Pi come piattaforma remota:

1. Nella barra del menu principale di NetBeans, seleziona Strumenti -> Piattaforme Java. Vedrai la finestra popup Java Platform Manager (immagine uno).
2. Fai clic su Aggiungi piattaforma in basso a sinistra. Vedrai il popup Aggiungi piattaforma Java [tipo di piattaforma] (immagine due).
3. Scegli Remote Java Standard Edition. Fare clic su Avanti. Vedrai il popup Aggiungi piattaforma Java [imposta piattaforma remota] (l'immagine tre mostra il popup dopo che ho inserito i valori corretti per il mio ambiente nei campi).
4. Nel campo Nome piattaforma inserisci un nome per il Pi. Puoi usare praticamente qualsiasi cosa, ma deve essere unica.
5. Nel campo Host inserisci l'indirizzo IP per il Pi trovato nel passaggio 1.
6. Nel campo Nome utente inserisci il nome utente che hai utilizzato nel passaggio 1.
7. Lascia selezionata l'opzione Usa autenticazione password e nel campo Password inserisci la password creata al passaggio 1.
8. Nel campo Percorso JRE remoto è necessario immettere la maggior parte del percorso del runtime Java sul Pi. Nel passaggio 1, era /usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java. Tuttavia, devi lasciare /bin/java nel valore del campo.
9. NetBeans scarica il programma eseguibile in una directory di lavoro sul Pi, identificata nel campo Working Dir. Il valore predefinito è /the_Pi_user_ID/NetBeansProjects/ ed è perfettamente accettabile. Puoi usare qualcosa di diverso se lo desideri, anche se deve essere disponibile per the_Pi_user_ID (immagine tre).
10. Fare clic su Fine in basso a destra del popup. Dopo l'elaborazione, dovresti vedere ancora una volta la finestra popup di Java Platform Manager. Ora dovresti vedere il tuo Pi remoto (sotto il nome che hai usato nell'azione 4) nella categoria Remote Java SE (immagine quattro).
11. Fai clic su Test Platform in basso a sinistra per testare la connessione tra NetBeans e il tuo Pi. Vedrai prima un popup che dice Verifica piattaforma remota. In caso di successo, verrà visualizzato un secondo popup che indica la connessione … stabilita con successo. In caso contrario, è necessario controllare e correggere le informazioni immesse nel popup Aggiungi piattaforma Java [imposta piattaforma remota] nelle azioni 5-9 sopra. Puoi farlo dal popup Java Platform Manager; seleziona semplicemente la tua piattaforma Pi e quindi modifica i campi sul lato destro del popup.
12. Dopo una connessione riuscita, fare clic su Chiudi nel popup di Java Platform Manager. Ora vedrai la finestra principale di NetBeans.

Ora può iniziare il vero divertimento!

Passaggio 4: creare un progetto Java sulla workstation

Questa non vuole essere una spiegazione completa di come utilizzare NetBeans o Java, ma descriverò le azioni minime per scrivere un programma in NetBeans sulla workstation e, infine, eseguire il programma in remoto sul Raspberry Pi.

In NetBeans devi prima creare un progetto per contenere le classi Java per il programma. Inoltre, in Java, le classi risiedono in pacchetti per supportare l'organizzazione e la sicurezza. Per creare il progetto e, facoltativamente, creare un pacchetto e un file di classe:

1. Nella finestra principale di NetBeans, fai clic sull'icona del nuovo progetto (2° da sinistra). Vedrai il popup Nuovo progetto [scegli progetto] (immagine uno).
2. Le impostazioni predefinite (Categoria: Java, Progetto: Applicazione Java) sono corrette per questo esempio, quindi fai semplicemente clic su Avanti. Vedrai il popup New Java Application [nome e posizione] (l'immagine due mostra i valori per il mio esempio). NOTA: ho oscurato le mie informazioni utente utilizzando i rettangoli colorati.
3. Nel campo Nome progetto, inserisci un nome di progetto Java valido a tua scelta. Il nome deve iniziare con una lettera maiuscola e la convenzione suggerisce il caso di cammello quando si concatenano le parole.
4. Il campo Posizione progetto controlla dove risiede il progetto nel file system. L'impostazione predefinita varia a seconda del sistema operativo, ma è sicura da accettare.
5. Il campo Cartella progetto consente di controllare il nome della cartella per il progetto. Trovo che sia meglio utilizzare l'impostazione predefinita, che è una concatenazione del campo Posizione e del campo Nome.
6. Quando la casella di controllo Crea classe principale è selezionata, NetBeans crea automaticamente un pacchetto e un file di classe principale (un programma che può essere eseguito dalla riga di comando) con lo stesso nome del progetto. Penso che di solito dovrebbe essere deselezionato, ma in questo caso lo lascerò selezionato che elimina le azioni esplicite altrimenti necessarie per farlo (immagine due).
7. Fare clic su Fine per creare il progetto, un pacchetto e un file di classe principale. Ora il pannello in alto a sinistra della finestra principale di NetBeans mostra il tuo progetto, che contiene un singolo pacchetto, che a sua volta contiene un singolo file di classe con un metodo main(). Il riquadro in alto a destra contiene il codice sorgente predefinito per la classe principale (il programma) generato automaticamente da NetBeans (immagine tre).

A questo punto, puoi scrivere del codice nel metodo principale ed eseguirlo sulla workstation. Ciò può essere desiderabile a volte, ma non è necessario per questo Instructable, quindi procedi al passaggio successivo.

Passaggio 5: configurare il progetto NetBeans per l'esecuzione in remoto su Raspberry Pi

Per configurare il progetto NetBeans e un programma che contiene, da eseguire in remoto sul Raspberry Pi, procedi come segue:

1. Fare clic con il tasto destro o con due dita (dipende dal sistema operativo della workstation) sul progetto nel riquadro Progetti della finestra principale di NetBeans per visualizzare il menu del progetto e fare clic su Proprietà. Vedrai il popup Project Properties (l'immagine mostra il popup con i valori corretti per il mio esempio).
2. In Categorie a sinistra, seleziona Esegui.
3. Fare clic su Nuovo a destra del campo Configurazione. Nel popup Crea nuova configurazione risultante, inserisci un nome per la configurazione e fai clic su OK. Il nome può essere qualsiasi cosa; Ho appena riutilizzato il nome della piattaforma ("My Pi"). Ancora una volta vedrai il popup delle proprietà del progetto.
4. Fare clic sull'icona a discesa a destra del campo Piattaforma runtime. Dall'elenco nel popup, seleziona la piattaforma remota che hai creato in precedenza (nel mio ambiente, "My Pi").
5. Fare clic su OK per configurare la piattaforma remota per il progetto. Vedrai ancora una volta la finestra principale.

Ora sei pronto per scrivere codice ed eseguire il programma in remoto.

Passaggio 6: scrivere un programma Java sulla workstation ed eseguirlo sul Raspberry Pi

Il pannello di destra nella finestra principale di NetBeans mostra il file di classe principale generato da NetBeans. Digitare una semplice istruzione print nel metodo principale del file di classe (immagine uno). Ora è un programma Java completo che fa qualcosa, anche se molto semplice.

Per eseguire il programma sul Pi, fai clic sull'icona Esegui (la freccia verde che punta a sinistra) nella finestra principale. NetBeans compila il codice, crea un file jar, scarica il file jar sul Raspberry Pi identificato dalla piattaforma remota, esegue il programma sul Pi, acquisisce l'output (System.out) del programma e fa eco a tale output su NetBeans Riquadro di output in basso a destra della finestra principale (immagine due).

Ora hai notevolmente ampliato le tue competenze per lo sviluppo di progetti sul Raspberry Pi! Ma aspetta…. C'è dell'altro!

Passaggio 7: eseguire il debug del programma Java con NetBeans

Una delle caratteristiche più potenti di un ambiente di sviluppo integrato di forza industriale come NetBeans è la capacità di eseguire il debug del programma durante l'esecuzione. NetBeans ti consente di sfruttare la suite completa di strumenti di debug durante l'esecuzione in remoto. Ciò include l'impostazione di punti di interruzione in posizioni "importanti" o "problematiche" nel programma e l'esame del valore delle variabili nello stato di esecuzione corrente.

Il semplice programma nell'ultimo passaggio è troppo semplice per dimostrare il debug, quindi ho aggiunto del codice aggiuntivo al programma. Il codice aggiuntivo aggiunge due variabili.

Per sfruttare gli strumenti di debug, devi prima impostare uno o più punti di interruzione. Per impostare un punto di interruzione, fare clic sul numero di riga in cui si desidera sospendere l'esecuzione; appare un'icona a forma di rettangolo rosso e l'intera linea acquisisce uno sfondo rosso (figura uno).

Per eseguire il debug del programma in esecuzione sul Pi, fai clic sull'icona Debug (immediatamente a destra dell'icona Esegui) nella finestra principale di NetBeans. Come con l'esecuzione normale, NetBeans compila, costruisce, scarica, esegue, acquisisce l'output e ne fa eco. Ma con il debug, NetBeans interrompe l'esecuzione ai punti di interruzione e consente di esaminare lo stato di esecuzione (immagine due, che mostra il riquadro Variabili in basso a destra).

L'esecuzione si ferma al punto di interruzione prima di eseguire l'istruzione sulla riga con il punto di interruzione. Lo sfondo verde indica l'istruzione successiva da eseguire. Quindi nel mio esempio, con un punto di interruzione alla riga 9, la variabile a non esiste ancora, tanto meno ha un valore.

Ora passa il cursore sull'icona del menu di debug nella finestra principale (la prima icona con la doppia freccia in basso a destra dell'icona di Debug) e fai clic sull'icona Passo oltre (ha un documento blu sullo sfondo e una freccia verde in senso antiorario in primo piano). [NOTA: se si rende la finestra principale di NetBeans sufficientemente ampia, il menu di debug si espande e le icone dell'azione di debug vengono visualizzate a destra dell'icona di debug.] NetBeans esegue l'istruzione al punto di interruzione e interrompe l'esecuzione prima dell'istruzione successiva. Vedrai ora che la variabile a esiste e ha il valore previsto (figura tre).

Fare clic sull'icona Passa due volte. Vedrai che tutte e tre le variabili hanno valori; nota che c è ancora zero (figura quattro).

Fare clic una volta sull'icona Passa sopra. Vedrai che la variabile c ora ha il valore corretto, cioè la somma delle variabili a e b (figura cinque).

Infine, nel menu di debug, fai clic sull'icona Esegui (un cerchio verde con una freccia bianca). Ciò fa sì che l'esecuzione continui al punto di interruzione successivo o alla fine del programma, a seconda di quale si verifica per primo. Ora viene visualizzato il riquadro Output che mostra lo stesso output dell'esecuzione normale, in questo caso il testo nell'istruzione print.

Passaggio 8: eseguire il programma indipendentemente da NetBeans

Potrebbe venire il momento in cui vuoi eseguire il tuo programma sul Raspberry Pi, senza "assistenza" o "interferenza" da NetBeans. È molto semplice. Innanzitutto, apri un client ssh sul tuo Pi.

Ricorda dal passaggio 3 che NetBeans posiziona il jar del tuo progetto in una directory di lavoro sul Pi. La base predefinita è /home/pi/NetBeansProjects per l'utente pi. La directory specifica ha lo stesso nome del tuo progetto. NetBeans posiziona il jar in una sottodirectory chiamata dist. Per il mio esempio, il percorso completo è /home/pi/NetBeansProjects/MyRemoteProg/dist. Nel client ssh sul Pi, per eseguire il programma puoi usare il comando java con l'opzione 'jar':

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

Vedrai i risultati dell'esecuzione nel client ssh; nel mio esempio, l'output sarà

Ciao da Raspberry Pi!

Funziona perché le informazioni nel file jar identificano quale classe principale nel jar eseguire.

Puoi anche cambiare la directory di lavoro (tramite cd) nella posizione del file jar e quindi emettere un comando più breve per produrre gli stessi risultati.

java -jar MyRemoteProg.jar

Passaggio 9: crea e scarica, ma non eseguire il programma tramite NetBeans

Ci sono situazioni in cui vuoi che NetBeans crei e scarichi il tuo programma, ma non lo esegua. Una di queste situazioni si verifica quando il programma richiede l'input da tastiera. Se questo è il caso, usando la tecnica nel passaggio precedente, una volta compilato e scaricato, il programma viene eseguito sul Raspberry Pi e quindi si aspetta l'input della tastiera dal Pi, ma ovviamente non c'è una tastiera collegata al Pi, quindi il programma si blocca -- non va bene.

Devi usare una tecnica un po' diversa per eseguire il programma. Fondamentalmente, crei un file di classe principale "fittizio" che essenzialmente non fa nulla e lo identifichi come il programma da eseguire dopo il download. In questo caso, il "fittizio" viene eseguito e puoi quindi eseguire il tuo programma "reale" direttamente sul Pi.

Per utilizzare questa tecnica, crea prima una nuova classe principale:

1. Apri il menu del progetto come nel passaggio 5 e fai clic su Nuovo->Java Main Class. Vedrai il popup New Java Main Class.
2. Nel campo Nome classe inserisci un nome. Il nome può essere qualsiasi cosa ti piaccia; Ho usato "Dummy". Il campo Pacchetto permette di identificare il pacchetto della classe; si seleziona il pacchetto utilizzando il menu a discesa a destra del campo. La classe può essere nello stesso pacchetto del tuo programma "reale" o in un pacchetto diverso; Ho messo la nuova classe nello stesso pacchetto. Fare clic su Fine. Ora vedrai la finestra principale di NetBeans con il nuovo file nel pannello in alto a destra (immagine uno). Ho aggiunto una semplice dichiarazione di stampa sull'esecuzione sul Pi, ma non è davvero necessario.

Per eseguire "Dummy" dopo il download, devi renderlo la "classe principale da eseguire di default" per il progetto:

1. Aprire le proprietà del progetto come nel passaggio 5. Selezionare la categoria Esegui. Fare clic su Sfoglia a destra del campo Classe principale. Vedrai il popup Sfoglia classi principali (immagine due).
2. Seleziona la classe "Dummy". Fare clic su Seleziona classe principale. Vedrai ancora una volta le proprietà del progetto.
3. Fare clic su OK. Tornerai alla finestra principale.

Ora quando fai clic sull'icona Esegui, NetBeans soddisfa/costruisce l'intero progetto, scarica il jar contenente tutti i file di classe sul Pi ed esegue la classe "Dummy" (immagine tre).

Per eseguire il tuo vero programma sul Pi, ora devi utilizzare il comando java con l'opzione 'classpath', che richiede l'identificazione esplicita della classe principale da eseguire. Da un client ssh vai alla directory dist per il tuo progetto. Il comando corretto è della forma:

java -cp nome_progetto.jar nome_pacchetto.nome_classe

Il project_name si riferisce ovviamente al progetto; che cambia solo quando si ha a che fare con un nuovo progetto. Il nome_pacchetto si riferisce ovviamente al pacchetto e il nome_classe si riferisce alla classe principale da eseguire. Come detto in precedenza, un progetto può contenere molti pacchetti. Allo stesso modo, un pacchetto può contenere molte classi e tutte potrebbero essere classi principali o programmi eseguibili dalla riga di comando. Pertanto, la tecnica del 'classpath' è abbastanza utile per sviluppare programmi sofisticati con molte classi, alcune delle quali sono classi principali solo per assistere i test di unità.

Il seguente comando esegue il mio programma di esempio:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Passaggio 10: sfruttare la gestione della libreria NetBeans

Uno degli aspetti più difficili ma più importanti dei programmi sofisticati riguarda le librerie, ovvero il codice che qualcun altro ha già scritto. NetBeans fa un lavoro ammirevole nel rimuovere la maggior parte del dolore della gestione della libreria.

Userò come esempio Pi4J, che fornisce ai programmi Java l'accesso al GPIO Raspberry Pi, al bus I2C e ad altri I/O hardware. Pi4J è solo un esempio di supporto per fare molte cose divertenti sul Pi con Java.

Devi prima scaricare la libreria sulla tua workstation. Vedi la pagina di download di Pi4J. Poiché non stai installando Pi4J sul Pi, scarica lo zip sulla tua workstation. Potresti dover decomprimere esplicitamente o meno una volta scaricato lo zip.

Ora devi creare una "libreria globale" in NetBeans:

1. Nel menu principale di NetBeans, fai clic su Strumenti -> Librerie. Vedrai il popup Ant Library Manager (immagine uno).
2. Fai clic su Nuova libreria in basso a sinistra. Vedrai il popup Nuova libreria (immagine due).
3. Digita un nome significativo che desideri utilizzare e fai clic su OK. Vedrai ancora una volta il popup Ant Library Manager. Ora mostra la nuova libreria che hai creato (immagine tre).
4. Fare clic su Aggiungi JAR/Cartella a destra. Vedrai il popup Sfoglia JAR/Cartella (immagine quattro).
5. Passare a e quindi selezionare pi4j-core.jar. Quindi fare clic su Aggiungi JAR/Cartella. Tornerai al popup Ant Library Manager.
6. Nel popup Ant Library Manager, fare clic su OK. Tornerai alla finestra principale di NetBeans.

Hai aggiunto la libreria in modo che possa essere utilizzata in qualsiasi progetto. Ora devi aggiungere la libreria al tuo progetto:

1. Visualizza il popup delle proprietà del progetto (vedi passaggio 5) e seleziona la categoria Librerie (figura cinque).
2. Fare clic su Aggiungi libreria sul lato destro del popup. Vedrai il popup Aggiungi libreria (immagine sei).
3. Vai alla libreria e selezionala. Quindi fare clic su Aggiungi libreria. Vedrai di nuovo il popup delle proprietà del progetto. La libreria ora appare nell'elenco delle librerie in fase di compilazione nel popup.
4. Nel popup delle proprietà del progetto, fare clic su OK. Tornerai alla finestra principale.

Hai aggiunto la libreria al tuo progetto in modo che il tuo programma possa utilizzarla. Puoi eseguire la stessa sequenza di azioni per qualsiasi libreria di cui hai bisogno per un programma.

Ci sono tre volte in cui hai bisogno della libreria: compilazione, compilazione ed esecuzione. Fortunatamente, con NetBeans, l'aggiunta della libreria come mostrato sopra gestisce tutto. Per confermare ciò, ho creato un'altra classe principale che fa il minimo assoluto necessario per utilizzare la funzionalità I2C in Pi4J (figura sette). Il fatto che non vengano visualizzati errori significa che la classe TestPi4J viene compilata. Facendo clic su Esegui, vengono compilati e scaricati correttamente; NetBeans scarica la libreria oltre al file jar, quindi il programma verrà eseguito. Per verificare quest'ultimo, puoi usare la tecnica nel passaggio 9 e nel client ssh inserire il seguente comando (dalla directory dist):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

È istruttivo capire come NetBeans gestisce le librerie. Mentre sei nella directory dist del tuo progetto, elenca il contenuto della directory (usa il comando ls) e vedrai una sottodirectory lib. Elenca il contenuto di quella directory e vedrai il file jar identificato nella libreria globale, che nel mio esempio è pi4j-core.jar. Tutte le librerie che aggiungi al progetto appariranno nella directory lib, e quindi sono disponibili per tutti i programmi nel file jar del progetto.

Passaggio 11: divertiti

Ho descritto un approccio per ottenere uno sviluppo Java molto efficiente per Raspberry Pi. Il Raspberry Pi è una tecnologia estremamente popolare per un ampio spettro di progetti. Java è un linguaggio di programmazione di livello professionale che offre vantaggi in termini di prestazioni rispetto a Python e offre vantaggi in termini di sicurezza rispetto a C/C++. NetBeans è un IDE di livello professionale che aumenta notevolmente la produttività dei programmatori.

Penso che la combinazione sia abbastanza avvincente. Ora divertiti a usare la combinazione per i tuoi progetti.