Getting started

This is preliminary documentation. It will be updated in the near future

To try the OpenEmbedded based root file system, it is best to install it on an external storage media such as an MMC/SD-Card or an USB drive.


You first have to choose the right rootfs and kernel image according to your system:





Important: You cannot use your old kernel images, as the openembedded based system uses a different ABI than the old rootfs and toolchain.

Unpacking the root filesystem

The next steps should be done with root privileges. Before unpacking the file system onto the memory card or USB drive, it must be formatted with the ext2 file system. You can do this on either on a normal Linux-PC or on the target device with following command:

mke2fs $device

where $device has to be replaced with the device you want to format (e.g. /dev/mmcblk0p1 for MMC/SD-Cards or /dev/sda1 for USB drives on the taskit products)

Mount the device:

mount $device $mountpoint


mount /dev/sda1 /data

Unpack the archive:

tar -xvf $archive -C $mountpoint


tar -xvf taskit-base-image-panelcard.tar -C /data

Unmount the device:

umount $mountpoint

Flashing the kernel image

To flash the kernel follow the instructions in the Linux Guide or the Upgrade Guide:

Updating U-Boot variables

To boot from the external storage enter one of the following U-Boot commands:

Panel-Card, Stamp9261

setenv sdboot run \$(ramsize)\;run setbasicargs\;setenv bootargs \$(basicargs) \$(mtdparts) root=/dev/mmcblk0p1 rootdelay=1 ro\;bootm \$(kerneladdr)
setenv usbboot run \$(ramsize)\;run setbasicargs\;setenv bootargs \$(basicargs) \$(mtdparts) root=/dev/sda1 rootdelay=5 ro\;bootm \$(kerneladdr)

Portux920T, Portux Panel-PC

setenv sdboot setenv bootargs \$(basicargs) \$(mtdparts) root=/dev/mmcblk0p1 rootdelay=1 ro\;bootm \$(kerneladdr)
setenv usbboot setenv bootargs \$(basicargs) \$(mtdparts) root=/dev/sda1 rootdelay=5 ro\;bootm \$(kerneladdr)

Save these variables with saveenv. You are now able to boot the system with with run usbboot or run sdboot.

If you want to automatically boot this system, set the boot command to either run usbboot or run sdboot before running saveenv, e.g.:

setenv bootcmd run sdboot

Using the new system

Differences to the old file system

  • It is mounted writeable directly from the device (no RAM disc), it is therefore advised to remount the device read-only (mount / -o remount,ro) or shut the system down (halt) before switching it off.
  • It contains a package manager (ipkg) to install additional software.

Using the package manager
To use the package manager you have to create the file /etc/ipkg.conf with the following content:


src all
src armv5te
src panelcard


src all
src armv5te
src stamp9261


src all
src armv4t
src portux920t

Portux Panel-PC:

src all
src armv4t
src portux-panelpc

If you are not able to download the packages directly from the internet to the device, you can mirror the needed files locally. Use this command to get all the files:

wget -r -np

Now make the files available to the device by either copying them directly to the device if it has enough memory or mount the directory via nfs.

Example: If the contents of the downloaded directory are mounted or copied to /ipk and you have a Panel-Card, then you have to change the /etc/ipkg.conf to contain the following lines:

src all file:/ipk/all
src armv5te file:/ipk/armv5te
src panelcard file:/ipk/panelcard

You are now able to pull the list of packages with ipkg update.

To install additional packages, use the command ipkg install $package. For further instruction to use ipkg see Using the package manager.

Interesting packages might be xserver-kdrive-fbdev (needed for graphical applications), jamvm (Java virtual machine), classpath-gtk (to start awt/swing applications) and python, perl and ruby as additonal scripting languages.

Compiling programs

You have two choices when compiling software with the OpenEmbedded based system:

  • native toolchain
  • cross toolchain

Using the native toolchain means to compile your program on the target itself. To do that install the package task-native-sdk. You can now copy your source code to the target (or make it available via nfs) and compile it with make or directly with the C compiller (gcc).

To use the cross toolchain, you have to download it first from taskit-0.1-arm-linux-gnueabi-taskit.tar.bz2. You now have to unpack it to your development machine into the root directory:

tar -xvjf taskit-0.1-arm-linux-gnueabi-taskit.tar.bz2 -C /

After that, you have a new folder /usr/local/taskit containing the new toolchain. Finally you need to adapt the makefile of your program to use the prefix /usr/local/taskit/arm/bin/arm-linux-gnueabi-

Compiling the kernel

We will use the cross toolchain here. To compile the kernel follow the instructions in the Linux 2.6.22 install guide 2.6.22-install.pdf. You only have to change two things:

First, you should use

export CROSS_COMPILE=/usr/local/taskit/arm/bin/arm-linux-gnueabi-

instead of

export CROSS_COMPILE=arm-linux-3.4.2-

Second, before compiling the kernel with make zImage you have to enable EABI support in the kernel config. Therefore enter make menuconfig and enable Kernel Features --> Use the ARM EABI to compile the kernel. Now save the config and continue as described in the install guide.

Using the package manager

The OpenEmbedded based system uses a package manager (ipkg) for installing, updating and removing software packages. This chapter contains information on common tasks when using ipkg.

Get the list of available packages

Before you can install additional packages or update them you have to get the current list of available packages. To do this use this command:

ipkg update

Upgrade all installed packages to the latest version

From time to time, there might be updates to some packages, mostly because of bugfixes. To get these updated packages run following command after getting the current list of available packages.

ipkg upgrade

Installing new software

If you need a package, that is currently not installed, just use this command (where $package has to be replaced with the name of the package):

ipkg install $package

Remove a package

If you do not need a package (anymore) and want to get rid of it, run:

ipkg remove $package

There are cases where you might be trying to remove packages that are needed by other packages. If this happens ipkg will list all packages that depend on the package to be removed. You now have three choices:

  1. Leave the package in the system
  2. Remove the package and all packages depending on this package
  3. Remove only the package

Choice 1 might be your only choice if you depend on the other packages. If you don't need the other packages, you can of course go with Choice 2 and remove all packages. This can be achieved with the following command:

ipkg remove -recursive $package

Choice 3 is not advised because it is very likely that the dependent packages are broken afterwards, but if you really want to do that, use the following command:

ipkg remove -force-depends $package

List all available packages

Before installing a package you certainly want to know, which packages are available. Just enter

ipkg list

to do this.

Search for a package in the package list

As ipkg has no native ability to search in the package list you have to use tools like grep to search the package list, e.g.

ipkg list|grep mysql

to find all packages containing mysql in their package name oder description.

List all installed packages

If you want to know, which packages are currently installed, run

ipkg list_installed

Using packages


If you want to run graphical applications using Gtk+, Java AWT or other X11 dependent libraries, you need to start an X-Server beforehand. The X-Server used is a minimal version called KDrive. We need the one compiled with Linux frame buffer support.

It is contained in the package xserver-kdrive-fbdev. Install it with

ipkg install xserver-kdrive-fbdev

Starting the X-Server

Now you are able to start the X-Server with the command

Xfbdev &

There are some options that might be interesting:

Option Function
-mouse tslib Touch panel support
-mouse mouse,/dev/input/mice General mouse support
-noreset Do not stop the X-Server, when the last client disconnects
-s $nr Set the screensaver timeout to $nr minutes, use 0 for no screensaver
-screen Set the screen resolution, color depth and rotation, e.g. -screen 320x240@90x16 for a landscape display with the resolution 320x240 in portrait mode and a color depth of 16 bits per pixel.

Starting the application

The last thing you have to do before you can run your application is to set the DISPLAY environment variable, so that the X-Clients know, which X-Server they should connect. Normally the X-Server is runnung on display :0 so set the variable accordingly:

export DISPLAY=:0

You should now be able to run your application.

Using the touchscreen

If you are using the touchscreen via tslib, you have to calibrate it first. To do that, install the xtscal:

ipkg install xtscal

Then, after the X-Server is started, execute it:


Follow the onscreen instructions. After that, the touchscreen should be calibrated.

Starting a window manager

Additionally, you might be interested in a window manager. It is recommend to use the matchbox window manager as it is design for fullscreen applications on small screen, but there are other window managers in the repository if you have other preferences. Install it with:

ipkg install matchbox-wm

You can now start it with:

matchbox-window-manager &

You can ignore the warnings from matchbox.