Desarrollo eficiente de Java para Raspberry Pi: 11 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

Este Instructable describe un enfoque muy eficiente para desarrollar programas Java para Raspberry Pi. He utilizado el enfoque para desarrollar capacidades de Java que van desde la compatibilidad con dispositivos de bajo nivel hasta programas de múltiples subprocesos y basados en la red. El enfoque no solo es eficiente, ¡es gratis!

Fundamentalmente, el enfoque es el desarrollo remoto utilizando NetBeans. NetBeans se ejecuta en una estación de trabajo (una computadora de escritorio o portátil, no la Raspberry Pi) conectada a través de Wifi a la Raspberry Pi. Una vez que todo está configurado correctamente, puede escribir un programa Java en NetBeans y luego con un solo clic compila y construye el programa en la estación de trabajo, descarga el programa en el Pi, ejecuta el programa en el Pi y entrega la salida a la consola NetBeans.. ¡Magia! Incluso puede depurar el programa en ejecución, establecer puntos de interrupción y examinar los valores de las variables. ¡Más magia!

El resto de esta introducción describe la motivación para usar Java y para el desarrollo remoto usando NetBeans. Si te importa la motivación, sigue leyendo. Si no le importa, vaya al paso 1.

¿Por qué usar Java en la Raspberry Pi?

Hay muchos lenguajes de programación disponibles para Raspberry Pi, pero limitaré la discusión a lenguajes de programación de "grado profesional" que se dirigen a programas independientes, admiten multitarea, permiten acceso a hardware y red, etc. Eso significa Java, Python o C / C ++. Las versiones más recientes de Raspbian incluyen soporte de desarrollo y tiempo de ejecución para todos estos lenguajes.

De hecho, Python se "promueve" para su uso en Pi, al menos en parte por su facilidad de aprendizaje para los nuevos programadores. Soy un programador experimentado y no me gusta Python debido a una aversión subjetiva por algunas de sus características, por ejemplo, la escritura dinámica. Hay una característica de Python por la que mi disgusto es el objetivo: el rendimiento. Esta fuente muestra que Java es siempre más rápido que Python 3 y, de hecho, puede ejecutarse cientos de veces más rápido, según la tarea.

C en mi opinión, es un "lenguaje de máquina de alto nivel", es decir, algo que está muy cerca del hardware del sistema, o al menos del sistema operativo. Puede hacer prácticamente cualquier cosa y puede hacerlo lo más rápido posible; de hecho, esta fuente sugiere que C puede ejecutarse hasta 7 veces más rápido que Java. Tampoco me gusta C ya que (subjetivamente) no me gustan algunas de sus características que encuentro arcanas, arcaicas o ambas; por ejemplo, punteros explícitos. Objetivamente, el hecho de que pueda hacer cualquier cosa significa que solo es un error oscuro (por ejemplo, una mala aritmética de puntero o una memoria errante) lejos de sobrescribir la memoria y potencialmente bloquear el programa o incluso todo el sistema. Java evita estos peligros, por lo que Java es más seguro. Siento que la seguridad también mejora la productividad del programador. Considero que C ++ es un "contenedor" orientado a objetos alrededor de C que no hace nada para eliminar los peligros de C.

La conclusión: Java es más rápido que Python. Java es más seguro que C.

¿Existen limitaciones al usar Java?

Hasta ahora, he podido hacer todo en Java que puedo hacer en Python. Hay cosas que se pueden hacer en C que no se pueden hacer en Java, pero nuevamente, hasta ahora todo lo que quería hacer ha sido abordado por los fanáticos de Java en la comunidad Pi. Ofreceré un ejemplo en un paso posterior. Dicho esto, he comprado sensores de proveedores que suministraron "controladores" para los sensores solo en Python (o C / C ++ para Arduino), así que tuve que escribir el equivalente en Java; el esfuerzo adicional no es necesariamente productivo, pero puede resultar en una mayor comprensión del funcionamiento de un sensor.

¿Por qué el desarrollo remoto basado en NetBeans?

Descubrí que el desarrollo remoto basado en NetBeans aumenta enormemente la productividad cuando se usa Java para Raspberry Pi. Estoy seguro de que puede usar el enfoque para crear programas rápidos y seguros, debido a las características inherentes de Java, mientras los escribe, construye y depura mucho más rápidamente que otros enfoques que he encontrado, debido al desarrollo remoto usando el "professional grado "Entorno de desarrollo integrado NetBeans (IDE).

Podría ser útil discutir brevemente esos "otros enfoques". Todos cumplen con los criterios básicos de que la Raspberry Pi no tiene un teclado, mouse o pantalla conectados. Hay muchas razones para este criterio, pero mi razón principal es que desarrollo robots móviles y no quiero que el Pi esté conectado a ningún periférico excepto a subsistemas robóticos, incluso durante el desarrollo.

El servidor VNC incluido en Raspbian proporciona una interfaz gráfica de usuario (GUI) remota que permite una forma de desarrollo remoto, donde solo la GUI remota se ejecuta en la estación de trabajo y todo lo demás, escritura, compilación y construcción, tiene lugar en la Pi. Con VNC, es fácil usar las herramientas de desarrollo compatibles con Java que se incluyen en Raspbian, como BlueJ, Geany y Greenfoot. Algunos de estos pueden considerarse un IDE; sin embargo, los encuentro lejos del grado profesional.

Es técnicamente posible instalar un IDE de Java de grado profesional como Eclipse o NetBeans en la Raspberry Pi y usarlo de forma remota a través de VNC. Los informes, y el sentido común, sugieren que los resultados serían decepcionantes, debido a la gran huella de memoria y la potencia de la CPU que requieren tales IDE, así como la latencia de red introducida por una GUI remota.

Tanto Eclipse como NetBeans se ejecutan muy bien en una estación de trabajo. Con Eclipse, escribir código es una experiencia agradable, sin embargo, construir el programa no lo es; la descarga del programa debe realizarse fuera de Eclipse; La ejecución del programa en la Pi es completamente independiente de Eclipse. El resultado general es un proceso de varios pasos, casi doloroso, que no admite la depuración remota. NetBeans tiene una función de compilación, construcción, descarga, ejecución remota y depuración remota, lo que lo convierte en un enfoque superior.

Paso 1: configura la Raspberry Pi

Para utilizar el enfoque de desarrollo remoto, debe comenzar configurando la Raspberry Pi de destino. Hay muchos recursos, incluidos Instructables, disponibles para ayudar a configurar una Raspberry Pi. Vea esto para conocer los conceptos básicos de la configuración del Pi (y más).

Este Instructable asume que

• instale la última Raspbian; asegúrese de registrar el ID de usuario y la contraseña de Pi
• configure Wifi y conéctese a su enrutador (vea esto); asegúrese de registrar la dirección IP de Pi
• habilitar SSH (ver esto) para permitir el acceso remoto al Pi desde la estación de trabajo

Una vez que haya completado la configuración, puede apagar y desconectar la pantalla, el teclado y el mouse del Pi. Ésta es una de las ventajas clave del desarrollo remoto. Debe dejar cualquier dongle Wifi conectado (no es necesario, por supuesto, para un modelo Pi 3 o Pi Zero W), y luego puede encender el Pi.

Para probar, abra un cliente ssh en su estación de trabajo, por ejemplo, Terminal en MacOS o putty en Windows. Luego ingrese el comando ssh (shell seguro) con el siguiente formulario:

ssh the_pi_ip_address -l the_pi_user_id

Debería recibir un mensaje para ingresar la contraseña de su ID de usuario de Pi. Si no aparece ningún mensaje, verifique que haya ingresado la dirección IP correcta en el comando ssh. Ingrese su contraseña (estará oculta) y luego debería ver el indicador de shell de Pi que aparece algo como esto:

pi @ raspberrypi: ~ $

Si no ve el mensaje, verifique el ID de usuario y la contraseña que utilizó.

Ahora debe encontrar la ruta al tiempo de ejecución de Java y confirmar que la versión predeterminada es Java 8 (debería ser cierta para la última Raspbian). Para encontrar la ruta de tiempo de ejecución de Java, en el cliente ssh ingrese el comando

sudo update-alternativas --display java

Debería ver una respuesta con las dos primeras líneas que se parecen a lo siguiente:

java - modo automático

La mejor versión del enlace es / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java

El "-8-" en la segunda línea confirma que el tiempo de ejecución predeterminado es Java 8. Registre la ruta en la segunda línea, ya que la necesitará para configurar NetBeans para el desarrollo remoto en un paso posterior.

Si el tiempo de ejecución predeterminado no es Java 8, en el cliente ssh ingrese el siguiente comando para cambiar a Java 8 (suponiendo que esté instalado)

sudo update-alternativas --config java

Paso 2: instale NetBeans en la estación de trabajo

Ahora necesita instalar NetBeans en su estación de trabajo. Apunte el navegador de su estación de trabajo a la página de descarga de NetBeans. Verá varios paquetes posibles que admiten las dos ediciones de Java y otros lenguajes. Todo lo que necesita para el desarrollo de Java para Raspberry Pi es Java SE, pero puede obtener el paquete Java EE o el paquete All. Una vez que decida qué paquete desea, haga clic en el botón Descargar correspondiente. Puede encontrar instrucciones de instalación adicionales para el sistema operativo de su estación de trabajo aquí.

Una vez que haya instalado NetBeans, inícielo (puede hacerlo automáticamente después de la instalación). Debería ver la ventana principal de NetBeans como se muestra en la imagen. La foto se tomó en una Mac y la ventana principal puede verse un poco diferente en Windows.

Una vez que haya instalado e iniciado correctamente NetBeans, continúe con el siguiente paso.

Paso 3: Configure la Raspberry Pi como una plataforma remota en NetBeans

Las siguientes acciones configuran la Raspberry Pi como una plataforma Java SE remota para NetBeans. Esto permite a NetBeans descargar y ejecutar programas Java en la Pi. Puede encontrar una descripción algo genérica aquí.

NOTA: En este y los siguientes pasos, muestro valores específicos de mi entorno para varios aspectos de configuración y codificación; el tuyo obviamente será diferente.

Para configurar el Pi como plataforma remota:

1. En la barra de menú principal de NetBeans, seleccione Herramientas -> Plataformas Java. Verá la ventana emergente de Java Platform Manager (imagen uno).
2. Haga clic en Agregar plataforma en la parte inferior izquierda. Verá la ventana emergente Agregar plataforma Java [tipo de plataforma] (imagen dos).
3. Elija Remote Java Standard Edition. Haga clic en Siguiente. Verá la ventana emergente Agregar plataforma Java [configurar plataforma remota] (la imagen tres muestra la ventana emergente después de ingresar los valores adecuados para mi entorno en los campos).
4. En el campo Nombre de la plataforma, ingrese un nombre para el Pi. Puedes usar prácticamente cualquier cosa, pero debe ser única.
5. En el campo Host ingrese la dirección IP para el Pi que se encuentra en el paso 1.
6. En el campo Nombre de usuario, ingrese el nombre de usuario que utilizó en el paso 1.
7. Deje la opción Usar autenticación de contraseña seleccionada y en el campo Contraseña ingrese la contraseña que creó en el paso 1.
8. En el campo Ruta remota de JRE debe ingresar la mayor parte de la ruta al tiempo de ejecución de Java en la Pi. En el paso 1, era / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java. Sin embargo, debe dejar / bin / java en el valor del campo.
9. NetBeans descarga el programa ejecutable a un directorio de trabajo en la Pi, identificado en el campo Working Dir. El valor predeterminado es / the_Pi_user_ID / NetBeansProjects / y es perfectamente aceptable. Puede usar algo diferente si lo desea, aunque debe estar disponible para el ID_usuario_Pi (imagen tres).
10. Haga clic en Finalizar en la parte inferior derecha de la ventana emergente. Después del procesamiento, debería volver a ver la ventana emergente Java Platform Manager. Ahora debería ver su Pi remoto (bajo el nombre que utilizó en la acción 4 anterior) en la categoría Remote Java SE (imagen cuatro).
11. Haga clic en Probar plataforma en la parte inferior izquierda para probar la conexión entre NetBeans y su Pi. Primero verá una ventana emergente que dice Verificando plataforma remota. Si tiene éxito, aparecerá una segunda ventana emergente que indica que la conexión … se estableció correctamente. De lo contrario, debe verificar y corregir la información que ingresó en la ventana emergente Agregar plataforma Java [configurar plataforma remota] en las acciones 5-9 anteriores. Puede hacerlo desde la ventana emergente Java Platform Manager; simplemente seleccione su plataforma Pi y luego edite los campos en el lado derecho de la ventana emergente.
12. Después de una conexión exitosa, haga clic en Cerrar en la ventana emergente de Java Platform Manager. Ahora verá la ventana principal de NetBeans.

¡Ahora puede comenzar la verdadera diversión!

Paso 4: cree un proyecto Java en la estación de trabajo

Esto no pretende ser una explicación completa de cómo usar NetBeans o Java, pero describiré las acciones mínimas para escribir un programa en NetBeans en la estación de trabajo y, eventualmente, ejecutar el programa de forma remota en la Raspberry Pi.

En NetBeans, primero debe crear un proyecto que contenga la (s) clase (s) Java para el programa. Además, en Java, las clases residen en paquetes para respaldar la organización y la seguridad. Para crear el proyecto y, opcionalmente, crear un paquete y un archivo de clase:

1. En la ventana principal de NetBeans, haga clic en el icono de nuevo proyecto (segundo desde la izquierda). Verá la ventana emergente Nuevo proyecto [elegir proyecto] (imagen uno).
2. Los valores predeterminados (Categoría: Java, Proyecto: Aplicación Java) son correctos para este ejemplo, así que simplemente haga clic en Siguiente. Verá la ventana emergente Nueva aplicación Java [nombre y ubicación] (la imagen dos muestra los valores de mi ejemplo). NOTA: He redactado mi información de usuario usando los rectángulos de colores.
3. En el campo Nombre del proyecto, ingrese un nombre de proyecto Java válido de su elección. El nombre debe comenzar con una letra mayúscula, y la convención sugiere mayúsculas y minúsculas al concatenar palabras.
4. El campo Ubicación del proyecto controla dónde reside el proyecto en su sistema de archivos. El valor predeterminado varía según el sistema operativo, pero es seguro aceptarlo.
5. El campo Carpeta del proyecto le permite controlar el nombre de la carpeta del proyecto. Creo que es mejor usar el valor predeterminado, que es una concatenación del campo Ubicación y el campo Nombre.
6. Cuando la casilla de verificación Crear clase principal está marcada, NetBeans crea automáticamente un paquete y un archivo de clase principal (un programa que se puede ejecutar desde la línea de comandos) con el mismo nombre que el proyecto. Creo que normalmente debería estar desmarcado, pero en este caso, lo dejaré marcado, lo que elimina las acciones explícitas necesarias para hacerlo (imagen dos).
7. Haga clic en Finalizar para crear el proyecto, un paquete y un archivo de clase principal. Ahora, el panel superior izquierdo de la ventana principal de NetBeans muestra su proyecto, que contiene un solo paquete, que a su vez contiene un solo archivo de clase con un método main (). El panel superior derecho contiene el código fuente predeterminado para la clase principal (el programa) generado automáticamente por NetBeans (imagen tres).

En este punto, puede escribir código en el método principal y ejecutarlo en la estación de trabajo. Eso puede ser deseable a veces, pero no es necesario para este Instructable, así que continúe con el siguiente paso.

Paso 5: Configure el proyecto NetBeans para que se ejecute de forma remota en Raspberry Pi

Para configurar el proyecto NetBeans, y un programa que contiene, para que se ejecute de forma remota en la Raspberry Pi, haga lo siguiente:

1. Haga clic con el botón derecho o con 2 dedos (depende del sistema operativo de la estación de trabajo) en el proyecto en el panel Proyectos de la ventana principal de NetBeans para abrir el menú del proyecto y haga clic en Propiedades. Verá la ventana emergente Propiedades del proyecto (la imagen muestra la ventana emergente con los valores adecuados para mi ejemplo).
2. En Categorías a la izquierda, seleccione Ejecutar.
3. Haga clic en Nuevo a la derecha del campo Configuración. En la ventana emergente Crear nueva configuración resultante, ingrese un nombre para la configuración y haga clic en Aceptar. El nombre puede ser cualquier cosa; Acabo de reutilizar el nombre de la plataforma ("Mi Pi"). Una vez más, verá la ventana emergente Propiedades del proyecto.
4. Haga clic en el icono desplegable a la derecha del campo Runtime Platform. De la lista en la ventana emergente, seleccione la plataforma remota que creó anteriormente (en mi entorno, "Mi Pi").
5. Haga clic en Aceptar para configurar la plataforma remota para el proyecto. Volverá a ver la ventana principal.

Ahora está listo para escribir código y ejecutar el programa de forma remota.

Paso 6: escriba un programa Java en la estación de trabajo y ejecútelo en la Raspberry Pi

El panel derecho en la ventana principal de NetBeans muestra el archivo de clase principal generado por NetBeans. Escriba una declaración de impresión simple en el método principal del archivo de clase (imagen uno). Ahora es un programa Java completo que hace algo, aunque algo muy simple.

Para ejecutar el programa en la Pi, haga clic en el icono Ejecutar (la flecha verde que apunta a la izquierda) en la ventana principal. NetBeans compila el código, crea un archivo jar, descarga el archivo jar a la Raspberry Pi identificada por la plataforma remota, ejecuta el programa en la Pi, captura la salida (System.out) del programa y hace eco de esa salida en NetBeans. Panel de salida en la parte inferior derecha de la ventana principal (imagen dos).

¡Ahora ha ampliado significativamente su conjunto de habilidades para desarrollar proyectos en Raspberry Pi! Pero espera…. ¡Hay más!

Paso 7: depurar el programa Java con NetBeans

Una de las características más poderosas de un entorno de desarrollo integrado de fuerza industrial como NetBeans es la capacidad de depurar el programa mientras se ejecuta. NetBeans le permite aprovechar el conjunto completo de herramientas de depuración mientras se ejecuta de forma remota. Esto incluye establecer puntos de interrupción en ubicaciones "importantes" o "problemáticas" en el programa y examinar el valor de las variables en el estado de ejecución actual.

El programa simple en el último paso es demasiado simple para demostrar la depuración, así que agregué código adicional al programa. El código adicional agrega dos variables.

Para aprovechar las herramientas de depuración, primero debe establecer uno o más puntos de interrupción. Para establecer un punto de interrupción, haga clic en el número de línea donde desea suspender la ejecución; Aparece un icono de rectángulo rojo y toda la línea adquiere un fondo rojo (imagen uno).

Para depurar el programa que se ejecuta en la Pi, haga clic en el icono Depurar (inmediatamente a la derecha del icono Ejecutar) en la ventana principal de NetBeans. Al igual que con la ejecución normal, NetBeans compila, construye, descarga, ejecuta, captura la salida y se hace eco de esa salida. Pero con la depuración, NetBeans detiene la ejecución en los puntos de interrupción y le permite examinar el estado de ejecución (imagen dos, que muestra el panel Variables en la parte inferior derecha).

La ejecución se detiene en el punto de interrupción antes de ejecutar la instrucción en la línea con el punto de interrupción. El fondo verde indica la siguiente instrucción que se ejecutará. Por lo tanto, en mi ejemplo, con un punto de interrupción en la línea 9, la variable a aún no existe, y mucho menos tiene un valor.

Ahora pase el cursor sobre el ícono del menú de depuración en la ventana principal (el primer ícono de doble flecha hacia abajo a la derecha del ícono de Depuración) y haga clic en el ícono Pasar por alto (tiene un documento azul en el fondo y una flecha verde en sentido antihorario en primer plano). [NOTA: si amplía lo suficiente la ventana principal de NetBeans, el menú de depuración se expande y los iconos de acción de depuración aparecen a la derecha del icono de depuración]. NetBeans ejecuta la instrucción en el punto de interrupción y detiene la ejecución antes de la siguiente instrucción. Ahora verá que la variable a existe y tiene el valor esperado (imagen tres).

Haga clic en el icono Paso a paso dos veces. Verá que las tres variables tienen valores; tenga en cuenta que c sigue siendo cero (imagen cuatro).

Haga clic una vez en el icono Paso a paso. Verá que la variable c ahora tiene el valor adecuado, es decir, la suma de las variables ayb (imagen cinco).

Finalmente, en el menú de depuración, haga clic en el icono Ejecutar (un círculo verde con una flecha blanca). Eso hace que la ejecución continúe hasta el siguiente punto de interrupción o hasta el final del programa, lo que ocurra primero. Ahora aparece el panel Salida y muestra la misma salida que con la ejecución normal, en este caso el texto en la declaración de impresión.

Paso 8: Ejecute el programa independientemente de NetBeans

Puede llegar el momento en que desee ejecutar su programa en la Raspberry Pi, sin "ayuda" o "interferencia" de NetBeans. Es muy simple. Primero, abra un cliente ssh a su Pi.

Recuerde del paso 3 que NetBeans coloca el jar de su proyecto en un directorio de trabajo en la Pi. La base predeterminada es / home / pi / NetBeansProjects para el usuario pi. El directorio específico tiene el mismo nombre que su proyecto. NetBeans coloca el jar en un subdirectorio llamado dist. Para mi ejemplo, la ruta completa es / home / pi / NetBeansProjects / MyRemoteProg / dist. En el cliente ssh en la Pi, para ejecutar el programa puede usar el comando java con la opción 'jar':

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

Verá los resultados de la ejecución en el cliente ssh; en mi ejemplo, la salida será

¡Hola desde Raspberry Pi!

Esto funciona porque la información del archivo jar identifica qué clase principal del jar se debe ejecutar.

También puede cambiar el directorio de trabajo (a través de cd) a la ubicación del archivo jar y luego emitir un comando más corto para producir los mismos resultados.

java -jar MyRemoteProg.jar

Paso 9: compile y descargue, pero no ejecute el programa a través de NetBeans

Hay situaciones en las que desea que NetBeans compile y descargue su programa, pero no lo ejecute. Una de esas situaciones ocurre cuando su programa necesita entrada de teclado. Si este es el caso, usando la técnica del paso anterior, una vez que construya y descargue, el programa se ejecuta en la Raspberry Pi y, por lo tanto, espera la entrada del teclado de la Pi, pero por supuesto, no hay un teclado conectado a la Pi, por lo que el programa se cuelga, no es bueno.

Tienes que usar una técnica algo diferente para ejecutar el programa. Básicamente, crea un archivo de clase principal "ficticio" que esencialmente no hace nada y lo identifica como el programa que se ejecutará después de la descarga. En este caso, se ejecuta el "ficticio" y, a continuación, puede ejecutar su programa "real" directamente en el Pi.

Para usar esta técnica, primero cree una nueva clase principal:

1. Abra el menú del proyecto como en el paso 5 y haga clic en Nuevo-> Clase principal de Java. Verá la ventana emergente New Java Main Class.
2. En el campo Nombre de la clase, ingrese un nombre. El nombre puede ser el que desee; Usé "Dummy". El campo Paquete le permite identificar el paquete de la clase; selecciona el paquete usando el menú desplegable a la derecha del campo. La clase puede estar en el mismo paquete que su programa "real" o en un paquete diferente; Pongo la nueva clase en el mismo paquete. Haga clic en Finalizar. Ahora verá la ventana principal de NetBeans con el nuevo archivo en el panel superior derecho (imagen uno). Agregué una declaración de impresión simple sobre la ejecución en el Pi, pero en realidad no se necesita nada.

Para ejecutar "Dummy" después de la descarga, debe convertirla en la "clase principal a ejecutar por defecto" para el proyecto:

1. Abra las Propiedades del proyecto como en el paso 5. Seleccione la categoría Ejecutar. Haga clic en Examinar a la derecha del campo Clase principal. Verá la ventana emergente Examinar clases principales (imagen dos).
2. Seleccione la clase "Dummy". Haga clic en Seleccionar clase principal. Volverá a ver las Propiedades del proyecto.
3. Haga clic en Aceptar. Volverá a la ventana principal.

Ahora, cuando hace clic en el icono Ejecutar, NetBeans cumple / construye todo el proyecto, descarga el jar que contiene todos los archivos de clase al Pi y ejecuta la clase "Dummy" (imagen tres).

Para ejecutar su programa real en la Pi, ahora debe usar el comando java con la opción 'classpath', que requiere que identifique explícitamente la clase principal a ejecutar. Desde un cliente ssh, vaya al directorio dist de su proyecto. El comando adecuado tiene la forma:

java -cp nombre_proyecto.jar nombre_paquete.nombre_clase

El project_name obviamente se refiere al proyecto; eso cambia solo cuando se trata de un nuevo proyecto. El nombre_paquete, por supuesto, se refiere al paquete, y el nombre_clase se refiere a la clase principal a ejecutar. Como se dijo anteriormente, un proyecto puede contener muchos paquetes. De manera similar, un paquete puede contener muchas clases y todas podrían ser clases principales o programas que se pueden ejecutar desde la línea de comandos. Por lo tanto, la técnica 'classpath' es bastante útil para desarrollar programas sofisticados con muchas clases, algunas de las cuales son clases principales solo para ayudar a las pruebas unitarias.

El siguiente comando ejecuta mi programa de ejemplo:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Paso 10: Aproveche la gestión de bibliotecas de NetBeans

Uno de los aspectos más difíciles pero más importantes de los programas sofisticados es el manejo de bibliotecas, es decir, el código que alguien más ya ha escrito. NetBeans hace un trabajo admirable al eliminar la mayor parte del dolor de la administración de bibliotecas.

Usaré como ejemplo Pi4J, que brinda a los programas Java acceso a Raspberry Pi GPIO, bus I2C y otras E / S de hardware. Pi4J es solo un ejemplo de soporte para hacer muchas cosas divertidas en Pi con Java.

Primero debe descargar la biblioteca a su estación de trabajo. Consulte la página de descarga de Pi4J. Como no está instalando Pi4J en Pi, descargue el zip en su estación de trabajo. Es posible que tenga que descomprimir explícitamente o no una vez que se descargue el zip.

Ahora debe crear una "biblioteca global" en NetBeans:

1. En el menú principal de NetBeans, haga clic en Herramientas -> Bibliotecas. Verá la ventana emergente Ant Library Manager (imagen uno).
2. Haga clic en Nueva biblioteca en la parte inferior izquierda. Verá la ventana emergente Nueva biblioteca (imagen dos).
3. Escriba un nombre significativo que desee utilizar y haga clic en Aceptar. Una vez más, verá la ventana emergente Ant Library Manager. Ahora muestra la nueva biblioteca que creó (imagen tres).
4. Haga clic en Agregar JAR / Carpeta a la derecha. Verá la ventana emergente Examinar JAR / Carpeta (imagen cuatro).
5. Navegue y seleccione pi4j-core.jar. Luego haga clic en Agregar JAR / Carpeta. Volverá a la ventana emergente Ant Library Manager.
6. En la ventana emergente Ant Library Manager, haga clic en Aceptar. Volverá a la ventana principal de NetBeans.

Ha agregado la biblioteca para que pueda usarse en cualquier proyecto. Ahora debes agregar la biblioteca a tu proyecto:

1. Abra la ventana emergente Propiedades del proyecto (consulte el paso 5) y seleccione la categoría Bibliotecas (imagen cinco).
2. Haga clic en Agregar biblioteca en el lado derecho de la ventana emergente. Verá la ventana emergente Agregar biblioteca (imagen seis).
3. Navegue a la biblioteca y selecciónela. Luego haga clic en Agregar biblioteca. Verá nuevamente la ventana emergente Propiedades del proyecto. La biblioteca ahora aparece en la lista de Bibliotecas en tiempo de compilación en la ventana emergente.
4. En la ventana emergente Propiedades del proyecto, haga clic en Aceptar. Volverá a la ventana principal.

Ha agregado la biblioteca a su proyecto para que su programa pueda usarla. Puede realizar la misma secuencia de acciones para cualquier biblioteca que necesite para un programa.

Hay tres ocasiones en las que necesita la biblioteca: compilación, compilación y ejecución. Afortunadamente, con NetBeans, agregar la biblioteca como se muestra arriba maneja todo. Para confirmar esto, he creado otra clase principal que hace el mínimo absoluto necesario para usar la capacidad I2C en Pi4J (imagen siete). El hecho de que no se muestren errores significa que la clase TestPi4J se compila. Hacer clic en Ejecutar construye y descarga correctamente; NetBeans descarga la biblioteca además del archivo jar, por lo que el programa se ejecutará. Para verificar esto último, puede usar la técnica en el paso 9 y en el cliente ssh ingrese el siguiente comando (desde el directorio dist):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Es instructivo comprender cómo NetBeans maneja las bibliotecas. Mientras esté en el directorio dist de su proyecto, enumere el contenido del directorio (use el comando ls) y verá un subdirectorio lib. Enumere el contenido de ese directorio y verá el archivo jar identificado en la biblioteca global, que en mi ejemplo es pi4j-core.jar. Todas las bibliotecas que agregue al proyecto aparecerán en el directorio lib y, por lo tanto, estarán disponibles para todos los programas en el archivo jar del proyecto.

Paso 11: ¡Diviértete

He descrito un enfoque para lograr un desarrollo de Java muy eficiente para Raspberry Pi. Raspberry Pi es una tecnología muy popular para un amplio espectro de proyectos. Java es un lenguaje de programación de nivel profesional que ofrece ventajas de rendimiento sobre Python y ofrece ventajas de seguridad sobre C / C ++. NetBeans es un IDE de nivel profesional que aumenta enormemente la productividad del programador.

Creo que la combinación es bastante convincente. Ahora, diviértete usando la combinación para tus proyectos.