This site is operated by a business or businesses owned by Informa PLC and all copyright resides with them. Informa PLC's registered office is 5 Howick Place, London SW1P 1WG. Registered in England and Wales. Number 8860726.

Java Meets The Cortex-M3 With New Development Kit

Mention Java to embedded developers and most will think of the desktop, the enterprise and embedded applications running on platforms like Android.
Few will talk about Java applications running on embedded platforms as native code.
C and C++ are the tend to be the languages of choice for native code applications in this realm.

Figure 2. The STM32F207IGH6 has 1 Mbyte of flash, 132 Kbytes of RAM and a host of peripheral interfaces.

Still, the Cortex-M3 is ideal for a range of embedded applications and sips power compared to the Cortex-A8.
The STM F2 runs at 120 MHz.
It has a meg of flash. A bit small for Linux but more than enough for a wide range of embedded applications including ones based on Java.
It also has 132 Kbytes of RAM and a range of peripheral interfaces.
These include CAN, Ethernet, I2C, IrDA, LIN, MMC, SPI, UART/USART, and USB OTG.

The board addes a 3.2-in, 240x320 TFT color LCD with touch screen support.
The software includes support for MicroUI and the Micro Widget Toolkit.
It also has an LIS302DL MEMS accelerometer.
Peripheral interfaces are connected to a potentiometer, a joystick with 4-direction control and a selector wakeup, tamper and user buttons.
The reset button is not placed well as it is inline with the other buttons and joystick.

There are USB and serial ports.
The Ethernet port includes an integrated TCP/IP stack.
There is even a SmartCard interface in addition to the SD card interface.

The board comes with a demo app to show off the capability of the system (Fig. 3).
The main interface provided access to half a dozen applications.
They highlight the GUI widgets as well as the performance of the system and its peripherals.
For example, there is a game that uses the accelerometer to simulate rolling a ball around a maze.

Figure 3. The sample Java application has half a dozen applets with real time graphics.

Installing the tools was the next step once I found the board working correctly.
The MicroEJ is based on the Eclispe IDE.
The IDE is open source but the compiler and other tools are not.
The limitations are based on the the latter.

Installation was uneventful and the USB connection to the board as simple as expected.
It utilizes ST's STLink debug interface.
The board can also be used without Java using this interface and even the IDE.
It just takes more configuration.

The initial screen (Fig. 4) with the IDE gets one started quickly.
It would be nice if all the docs were available before installation but this works well enough.
The basic Hello World style app is not as impressive as the demo app but enough to get any programmer working.

Figure 4. The first IDE presentation provides the initial steps to building an application.

I have had plenty of experience with Eclipse, Java and embedded development so this was not new but I did not find any issues that would cause a new embedded developer problems.
The MicroEJ IDE (Fig. 5) is the typical Eclipse interface so no major surprises.

Figure 5. The Eclipse-based MicroEJ IDE will be familiar to many.

Still, Java developers that typically utilize desktop or enterprise platforms will notice a bit of a difference because MicroEJ has an
ahead-of-time (AOT) compiler like C and C++ in addition to a just-in-time (JIT) compiler. The latter is for dynamic loading of classes.
The AOT compiler is what most embedded applications will use and the JIT is only needed if dynamic loading is required.
Compiler efficiency is very good making Java a suitable alternative to C and C++.
The AOT approach essentially eliminates the JIT start up that is typically hidden on high performance
platforms because of computational horsepower but very apparent on smaller platforms like the Cortex-M3.
Likewise, it makes handling of interrupts and near real time chores easier.

Exploring the GUI and hardware classes takes a bit of time but is typically of learning any platform.
The tools address the range of interfaces but they are not required by all applications.
This means a Java application could be used on anything from a headless robotic controller to a dedicated network media player.
The limitations of the Cortex-M3 are known but migration to higher end Cortex platforms should be a trivial exercise for Java apps.
Likewise, choosing a micro with less memory within the STM family is possible once application requirements are set although it might be a tight fit on the smallest of the STM platforms.

While I like the hardware and software there are caveats.
Out of the box the software will run for 3 months and apps run for only an hour.
I find the latter the most annoying but it may provide sufficient time to evaluate the tools.

Overall, the package demonstrates the viability and desirability of using Java on a Cortex-M3.
IS2T makes some nice software and ST Microelectronics has the hardware to match it.