Raspberry Pi IDE Java Development
The Raspberry Pi is an
incredible device for building embedded
Java
applications but, despite being able to run an IDE on the Pi it really
pushes things to the limit. It's much better to use a PC or
laptop to develop the code
and then deploy
and test on the Pi.
What I thought I'd do in this blog entry was to run through the steps
necessary to set up NetBeans on a
PC for Java code development, with automatic deployment to the
Raspberry Pi as part of the build
process.
I will assume that your starting point is a Raspberry Pi with an SD
card that has one of the latest Raspbian
images on it. This is good because this now includes the JDK 7 as
part of the distro, so no need to download
and install a separate
JDK. I will also assume that you have installed the JDK
and
NetBeans on your PC. These can be downloaded here.
There are numerous approaches you can take to this including mounting
the file system from the Raspberry Pi remotely on your development
machine. I tried this
and I found that NetBeans got rather upset
if the file system disappeared either through network interruption or
the Raspberry Pi being turned off. The following method uses
copying over SSH, which will fail more gracefully if the Pi is not
responding.
Step 1: Enable SSH on the Raspberry Pi
To run the Java applications you create you will need to start Java on
the Raspberry Pi with the appropriate class name, classpath
and
parameters. For non-JavaFX applications you can either do this
from the Raspberry Pi desktop or, if you do not have a monitor
connected through a remote command line. To execute the remote
command line you need to enable SSH (a secure shell login over the
network)
and connect using an application like PuTTY.
You can enable SSH when you first boot the Raspberry Pi, as the
raspi-config program runs automatically. You can also run it at
any time afterwards by running the command: sudo
raspi-config
This will bring up a menu of options. Select '8 Advanced Options'
and on the next screen select 'A$ SSH'. Select 'Enable'
and the
task is complete.
Step 2: Configure Raspberry Pi Networking
By default, the Raspbian distribution configures the ethernet
connection to use DHCP rather than a static IP address. You can
continue to use DHCP if you want, but to avoid having to potentially
change settings whenever you reboot the Pi using a static IP address is
simpler.
To configure this on the Pi you need to edit the /etc/network/interfaces
file. You will need to do this as root using the sudo command, so
something like sudo
vi /etc/network/interfaces. In this file you will see this
line: iface eth0
inet dhcp
This needs to be changed to the following: iface eth0
inet static
address 10.0.0.2
gateway 10.0.0.254
netmask 255.255.255.0
You will need to change the values in red to an appropriate IP address
and to match the address of your gateway.
Step 3: Create a Public-Private Key Pair On Your Development Machine
How you do this will depend on which Operating system you are using:
Mac OSX or Linux
Run the command: ssh-keygen -t
rsa
Press ENTER/RETURN to accept the default destination for saving the
key. We do not need a passphrase so simply press ENTER/RETURN for
an empty one
and once more to confirm.
The key will be created in the file .ssh/id_rsa.pub
in your home directory.
Display the contents of this file using the cat command: cat
~/.ssh/id_rsa.pub
Open a window, SSH to the Raspberry Pi
and login. Change
directory to .ssh
and edit the authorized_keys
file (don't worry if the file does not exist). Copy
and paste the
contents of the id_rsa.pub
file to the authorized_keys
file
and save it.
Windows
Since Windows is not a UNIX derivative operating system it does not
include the necessary key generating software by default. To
generate the key I used puttygen.exe
which is available from the same site that provides the PuTTY
application, here.
Download this
and run it on your Windows machine. Follow the
instructions to generate a key. I remove the key comment, but you
can leave that if you want.
Click "Save private key", confirm that you don't want to use a
passphrase
and select a filename
and location for the key.
Copy the public key from the part of the window marked, "Public key for
pasting into OpenSSH authorized_keys file". Use PuTTY to connect
to the Raspberry Pi
and login. Change directory to .ssh
and
edit the authorized_keys
file (don't worry if this does not exist). Paste the key
information at the end of this file
and save it.
Logout
and then start PuTTY again. This time we need to create a
saved session using the private key. Type in the IP address of
the Raspberry Pi in the "Hostname (or IP address)" field
and expand
"SSH" under the "Connection" category. Select "Auth" (see the
screen shot below).
Click the "Browse" button under "Private key file for authentication"
and select the file you saved from puttygen.
Go back to the "Session" category
and enter a short name in the saved
sessions field, as shown below. Click "Save" to save the session.
Step 4: Test The Configuration
You should now have the ability to use scp
(Mac/Linux) or pscp.exe
(Windows) to copy files from your development machine to the Raspberry
Pi without needing to authenticate by typing in a password (so we can
automate the
process in NetBeans). It's a good idea to test this
using something like: scp /tmp/foo
[email protected]:/tmp
on Linux or Mac or pscp.exe foo
pi@raspi:/tmp
on Windows (Note that we use the saved configuration name instead of
the IP address or hostname so the public key is picked up). pscp.exe is another tool available from the creators of PuTTY.
Step 5: Configure the NetBeans Build Script
Start NetBeans
and create a new project (or open an existing one that
you want to deploy automatically to the Raspberry Pi).
Select the Files tab in the explorer window
and expand your
project. You will see a build.xml
file. Double click this
to edit it.
This file will mostly be comments. At the end (but within the </project>
tag) add the XML for <target
name="-post-jar">, shown below
Here's the code again in case you want to use cut-and-paste: <target name="-post-jar">
<echo level="info" message="Copying dist
directory to remote Pi"/>
<exec executable="scp" dir="${basedir}">
<arg line="-r"/>
<arg value="dist"/>
<arg
value="
[email protected]:NetBeans/CopyTest"/>
</exec>
</target>
For Windows it will be slightly different: <target name="-post-jar">
<echo level="info" message="Copying dist
directory to remote Pi"/>
<exec executable="C:\pi\putty\pscp.exe" dir="${basedir}">
<arg line="-r"/>
<arg value="dist"/>
<arg
value="pi@raspi:NetBeans/CopyTest"/>
</exec>
</target>
You will also need to ensure that pscp.exe is
in your PATH
(or specify
a fully qualified pathname).
From now on when you clean
and build the project the dist
directory will automatically be copied to the Raspberry Pi ready for
testing.
