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.
