C and assembly development introduction

Setting up a development environment

• Get Ndless which contains an SDK for C and assembly development on TI-Nspire. This article is written for Ndless v1.7 and higher.
• Add the sdk/bin/ directory to your PATH environment variable (on Windows XP, Windows Vista or on Linux).
• Choose an emulator that will ease the development of programs

The following OS-specific additional steps are also required.

On Windows

• Install MSYS, the lightweight Unix-like shell environment. The automated installation has been discontinued since MSYS 1.0.11, so you may prefer to use this old version for an easier installation. Then you may optionally download the individual component upgrades (MSYS sub-folder) and unpack them in MSYS's installation directory using 7-zip.
  MinGW is not required.
• Install the YAGARTO GNU ARM toolchain (minimum version required: v4.6.0). Request YAGARTO's installer to add YAGARTO's bin/ directory to your PATH environment variable.

On Ubuntu

• Install the package gcc-4.5-arm-linux-gnueabi >= 4.5.1-10

If you don't have this package version in your synaptic manager, you can add natty package support in the package repository (/etc/apt/source.list) by copying each line specific to the Ubuntu version and by replacing your version with natty. For example:

Copy this:

deb http://archive.ubuntu.com/ubuntu/ maverick main restricted
deb-src http://archive.ubuntu.com/ubuntu/ maverick main restricted

Paste and replace maverick with natty:

deb http://archive.ubuntu.com/ubuntu/ natty main restricted
deb-src http://archive.ubuntu.com/ubuntu/ natty main restricted

On other Linux distributions

• Install a GNU ARM toolchain. You can use the following script:

#!/bin/sh
# Written by Uwe Hermann <uwe@hermann-uwe.de>, released as public domain.
# Edited by Travis Wiens ( http://blog.nutaksas.com/2009/05/installing-gnuarm-arm-toolchain-on.html )
# Edited by Lionel Debroux for newer gcc/binutils/newlib/gdb versions and nspire-gcc.

TARGET=arm-none-eabi
PREFIX=$HOME
PARALLEL="" # or "-j<number of build jobs>"

BINUTILS=binutils-2.22 # http://www.gnu.org/software/binutils/
GCC=gcc-4.6.2 # http://gcc.gnu.org/
NEWLIB=newlib-1.19.0 # http://sourceware.org/newlib/
GDB=gdb-7.3.1 # http://www.gnu.org/software/gdb/

mkdir build

# IMPORTANT NOTE: in order to compile GCC 4.5, you need the GMP, MPFR and MPC development libraries.
# For example, if you have installed them yourself in $PREFIX, you'll have to add --with-gmp=$PREFIX --with-mpfr=$PREFIX --with-mpc=$PREFIX .

# NOTE: the second rm -rf is commented, because it's not strictly necessary.

# Section 1: binutils.
(wget -c http://ftp.gnu.org/gnu/binutils/$BINUTILS.tar.bz2 && tar xvjf $BINUTILS.tar.bz2 && cd build && ../$BINUTILS/configure --target=$TARGET --prefix=$PREFIX --enable-interwork --enable-multilib --with-gnu-as --with-gnu-ld --disable-nls --with-float=soft --disable-werror && make $PARALLEL all && make install && cd .. && rm -rf build/*) || exit 1;
##rm -rf $BINUTILS $BINUTILS.tar.bz2

# Section 2: GCC, step 1.
(wget -c ftp://ftp.gnu.org/gnu/gcc/$GCC/$GCC.tar.bz2 && tar xvjf $GCC.tar.bz2 && cd build && ../$GCC/configure --target=$TARGET --prefix=$PREFIX --enable-interwork --enable-multilib --enable-languages="c,c++" --with-newlib --without-headers --disable-shared --with-gnu-as --with-gnu-ld --with-float=soft --disable-werror && make $PARALLEL all-gcc && make install-gcc && cd .. && rm -rf build/*) || exit 1;
##rm -rf $GCC.tar.bz2

# Section 3: newlib.
(wget -c ftp://sources.redhat.com/pub/newlib/$NEWLIB.tar.gz && tar xvzf $NEWLIB.tar.gz && cd build && ../$NEWLIB/configure --target=$TARGET --prefix=$PREFIX --enable-interwork --enable-multilib --with-gnu-as --with-gnu-ld --disable-nls --with-float=soft --disable-werror && make $PARALLEL && make install && cd .. && rm -rf build/*) || exit 1;
##rm -rf $NEWLIB $NEWLIB.tar.gz

# Section 4: GCC, step 2. Yes, this is necessary.
(cd build && ../$GCC/configure --target=$TARGET --prefix=$PREFIX --enable-interwork --enable-multilib --enable-languages="c,c++" --with-newlib --disable-shared --with-gnu-as --with-gnu-ld --with-float=soft --disable-werror && make $PARALLEL && make install && cd .. && rm -rf build/*) || exit 1
##rm -rf $GCC

# Section 5: GDB.
(wget -c ftp://ftp.gnu.org/gnu/gdb/$GDB.tar.bz2 && tar xvjf $GDB.tar.bz2 && cd build && ../$GDB/configure --target=$TARGET --prefix=$PREFIX --enable-interwork --enable-multilib --disable-werror && make $PARALLEL && make install && cd .. && rm -rf build/*) || exit 1;
##rm -rf $GDB $GDB.tar.bz2

Verifying the installation

• Open a console. On Windows the MSYS console must be used: open MSYS (rxvt) from the Windows Start menu.
• Type after the prompt (which is $ in rxvt):

$ nspire-gcc

If everything has been correctly set up you should see something similar to:

arm-none-eabi-gcc: no input files

As a convention for the next chapters, lines starting with $ are commands you should type in the console. Other lines are commands output. On Windows, all commands must be type in the rxvt console. The commands used are Unix/Linux commands which can be interpreted and run by MSYS. You may pick up a tutorial to learn the basic Unix commands before we continue.

5-minute tutorial

Your first build

Ndless v1.7 and higher comes with sample programs in the src/samples directory. We will try to build the C Hello World. Change the current directory of the console (still rxvt on Windows):

$ cd "<my_ndless_copy>/src/samples/hello"

Check the content of the directory:

$ ls
Makefile  hello.c

A Makefile is a script which describes how to build the program. It is interpreted by GNU Make, which is run with the command make. So let's make the program:

$ make
nspire-gcc -Os -Wall -W -c hello.c
nspire-ld -nostdlib hello.o -o hello.elf
mkdir -p ../../calcbin/samples

make tells us the different commands used during the building process.

arm-none-eabi-objcopy -O binary hello.elf ../../calcbin/samples/hello.tns

nspire-gcc is Ndless's wrapper for the GNU C Compiler GCC, which compiles C and assembly source files to object files (here hello.o).

nspire-ld is the wrapper for the GNU linker ld, which combines object files to produce an executable in the ELF format (here hello.elf).

arm-none-eabi-objcopy is a GNU utility used to convert the ELF file to an Ndless-compatible executable directly runnable on a TI-Nspire. The file hello.tns can be found in src/calcbin/samples.

A C program

Let's have a look at the Hello World source code hello.c. It follows the C conventions.

It has an entry point:

int main(void) {

and a return code (required but currently ignored by Ndless and the OS):

  return 0;
}

Ndless currently requires only one standard include file, os.h:

#include <os.h>

It allows to call syscalls provided by the Operating System of the TI-Nspire. Some syscalls are functions from the C standard library, others are part of the C POSIX library. There are also functions of Nucleus RTOS on which is based the TI-Nspire OS.

Currently only a few syscalls are defined in Ndless, but any help to search and declare missing syscalls is greatly welcome.

unsigned intmask = TCT_Local_Control_Interrupts(0);

We are here calling the (Nucleus) syscall TCT_Local_Control_Interrupts, which disable the interrupts. This is required to be able to call C standard functions such as puts or printf which write to the RS232 console.

puts("hello world!");

The "hello world" message is written to the console. You can view it in nspire_emu's console, but you will need an RS232 adapter when running the program on a real calculator.

At the end of the program, the interrupt mask is restored:

TCT_Local_Control_Interrupts(intmask);

Your first program

You can copy the hello directory and start to adapt the Makefile and the source code.

The hello Makefile can be reused as a template for simple builds:

• Change the value of the variable EXE to the name of the TI-Nspire executable
• Change OBJS to the list of the object files of your program (programs are often split into several modules, one in each .c file)
• Change DISTDIR to the directory to which you want the .tns file to be built. It may be '.' for the directory containing the source code.

Going further

• Pick up a good C tutorial before writing your own programs
• Learn the syntax of GNU Make's Makefiles to adapt them to your own build requirements
• Learn to use GNU GCC features and extensions