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.
