Build and run Nuttx inside Eclipse

In the previous posts I showed how to get started with Nuttx and set up and test simple network features, here I would like to show how to integrate Nuttx building environment with Eclipse.

First of all we need to download Eclipse and, of course JRE (Java Runtime Environment) that is used to run Eclipse.

Please refer to the following links to download all the necessary:

http://java.com/en/download/

https://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/lunasr2

In the specific I used JRE Version 1.8.0_31 end Eclipse Luna SR2.

In order to install Eclipse we just need to unzip and untar the tarball downloaded.

I did it in my home directory:

#cd

#tar zxvf eclipse-cpp-luna-SR2a-linux-gtk.tar.gz

and install JRE:

#cd eclipse/

#tar zxvf jre-8u31-linux-i586.tar.gz

# mv jre1.8.0_31 jre

Let's now move on the top of the home directory

# cd ..

and let's create a simple and convenient text file to launch Eclipse.

Use your preferred text editor and create a text file starteclipse containing:

PATH=/home/user/nuttx_workdir/nuttx-code/misc/buildroot/build_arm/staging_dir/bin:/home/user/nuttx_workdir/nuttx-stellaris/misc/buildroot/build_arm_nofpu/staging_dir/bin:$PATH ./eclipse/eclipse

give execution permission to the file:

#chmod +x starteclipse

and launch it:

#./starteclipse

If everything went right you should see eclipse appearing on your desktop.

We can now import Nuttx building environment in it:

As showed in the screen-shoot below select File->New->Makefile Project with Existing Code 

A wizard will pop up, be sure to fill it with Project Name ad Existing Code Location and press Finish.

Now in the Project explorer you will see the Nuttx project, right-click it and select Properties from the context menu:

Select Environment on the Properties Windows and add a New Environment Variable as showed in the picture: CROSSDEV= arm-elf-, basically we are setting the same environment as we do from command line (see the previous post).

Press OK on the “New Variable” window and OK on the “Properties” window.

We are now ready, we can build Nuttx within Eclipse, just right click the Build in the context Menu

 

You can now “Clean Project” or modify it and “Rebuild Project” in a easy and handy way.

I also found really handy to launch the simulator inside Eclipse; in order to do it, select Run->External Tools->External Tools Configuration...

Here you can instruct Eclipse, to launch Qemu emulating the Stellaris platform and run Nuttx image.

In the Windows that will appear:

1. select New,
2. give a Name (e.g. start_qemu_stellaris),
3. select the location where Qemu has been installed, if you use Xubuntu 14.04 /usr/bin/qemu-system-arm
4. insert the Qemu parameters we used on the command line in the previous post
5. click Run

You can now run Qemu just selecting it from Run->External Tools.

In case you have a real target you can use External Tools to run OpenOCD.

Getting started with Nuttx Networking

In my previous post I explained how to get started with Nuttx on Qemu emulating Stellaris Soc.

In the following I show how to go further and configure the network in order to perform simple networking operations like ping and telnet.

So first of all let's update the Nuttx version:

$cd nuttx

$export PATH=`pwd`/../misc/buildroot/build_arm_nofpu/staging_dir/bin:$PATH

$export CROSSDEV=arm-elf-

$git pull

As I write the latest commit, the one I use, is d4e59915c6072e917b5017d5fefe2afb840d4097

Now we can configure the Nuttx

$cd tools

$./configure.sh lm3s6965-ek/nsh

$cd ..

$make menuconfig

At this point we should have a menu like the one showed below, here you can configure almost all the features of Nuttx.

Select ARP feature:

Networking Support →ARP Configuration→ ARP send

We must now modify few things in the Nuttx's Ethernet driver of the Stellaris chip.

You can apply the following patch with the command:

$patch -p1 < patch

diff --git a/nuttx/arch/arm/src/tiva/lm3s_ethernet.c b/nuttx/arch/arm/src/tiva/lm3s_ethernet.c

index 87334ab..98e5285 100644

--- a/nuttx/arch/arm/src/tiva/lm3s_ethernet.c

+++ b/nuttx/arch/arm/src/tiva/lm3s_ethernet.c

@@ -368,6 +368,7 @@ static void tiva_ethreset(struct tiva_driver_s *priv)

putreg32(regval, TIVA_SYSCON_RCGC2);

nllvdbg("RCGC2: %08x\n", regval);

+#if 0

/* Put the Ethernet controller into the reset state */

regval = getreg32(TIVA_SYSCON_SRCR2);

@@ -387,7 +388,7 @@ static void tiva_ethreset(struct tiva_driver_s *priv)

/* Wait just a bit, again. If we touch the ethernet too soon, we may busfault. */

up_mdelay(2);

-

+#endif

/* Enable Port F for Ethernet LEDs: LED0=Bit 3; LED1=Bit 2 */

#ifdef CONFIG_TIVA_ETHLEDS

@@ -1198,11 +1199,13 @@ static int tiva_ifup(struct net_driver_s *dev)

*/

nlldbg("Waiting for link\n");

+#if 0

do

{

phyreg = tiva_phyread(priv, MII_MSR);

}

while ((phyreg & MII_MSR_LINKSTATUS) == 0);

+#endif

nlldbg("Link established\n");

/* Reset the receive FIFO */

Actually I am removing some code using the #if 0 preprocessor macro.

The first #if 0 is to avoid to write at offset 0x048 (SRCR2) as you can see from

http://git.qemu.org/?p=qemu.git;a=blob;f=hw/arm/stellaris.c;h=cb515ec76520d3237c793d2ba406d27cd0b392f5;hb=HEAD#l546
Qemu does not implement write on this offset and it will end up in an annoying “Peripheral reset not implemented” log when you start Qemu.

The second #if 0 is to avoid Nuttx waiting for link up forever as the emulator does not seem to report the link status correctly.

Compile the new Nuttx image

$make

We now need to set up a basic virtual network between the host and Qemu, with the real board we would connect the board to a PC throught an ethernet cable.

So let's create a virtual device acting as a tap (tap means it emulate the ethernet)

$sudo ip tap add mode tap

let's give it a ip address:

$sudo ifconfig tap0 10.0.0.1

We are now ready to start our Qemu:

$qemu-system-arm -M lm3s6965evb -kernel nuttx -net nic,model=stellaris -net tap,ifname=tap0,script=no,downscript=no

Basically we are telling Qemu to emulate lm3s6965 evaluation board, using the image we built, a network interface that is the one of the stallaris SOC, and is linked to tap0 of the host and to not run any script associated to that tap.

As Qemu starts we could press CRTL+ALT+3 in order to get the console, we can now configure the Stellaris network interface inside the Qemu console and ping the host:

nsh> ifconfig 10.0.0.2 gw 10.0.0.1

nsh> ping 10.0.0.1

Just to end we could give a try to the telnet server run by Nuttx, from a host console give the command:

# telnet 10.0.0.2

this is what you will get.

user@nuttx-VirtualBox:~/nuttx_workdir/nuttx-stellaris/nuttx$ telnet 10.0.0.2

Trying 10.0.0.2...

Connected to 10.0.0.2.

Escape character is '^]'.

NuttShell (NSH)

nsh> help

help usage: help [-v] [<cmd>]

[ df hexdump mkdir ping sleep

? echo ifconfig mkfatfs ps test

break exec ifdown mkfifo put true

cat exit ifup mkrd pwd umount

cd false kill mh rm unset

cp free losetup mount rmdir usleep

cmp get ls mv set wget

dd help mb mw sh xd

nsh>