jump to navigation

Mini6410 – Getting started with Free Software September 22, 2010

Posted by Florian in Devices, GPE, Linux, OpenEmbedded.

FriendlyARM is shipping the new Mini6410 for a little while now.  It is based on a 533MHz clocked Samsung S3C6410. I do not want  to repeat all the technical details here, an English description can be found here. Lets summarize the features in a simple sentence: It is fast enough for Qt and offers lots of ports for connectivity.

Mini6410 running an OpenEmbedded built GPE Image

Mini6410 running an OpenEmbedded built GPE Image

The image pretty much illustrates what we are up to do now – but lets take a look at the software shipped with the board first. Compared to the older Mini2440 the devices official support DVD offers several more options: We have pre-compiled images based on Android, XUbuntu and Qtopia and an advanced U-Boot which comes with a kind of menu for the basic tasks.  One major problem is that currently the documentation is available in Chinese only which makes it a little bit hard to handle. But translating single paragraphs of the more than 300 pages long PDF manual using Google Translator worked pretty well. The DVD contains important sources for Android, U-Boot and Linux. The Kernel is based on 2.6.28 for the SMDK 6410 reference design and heavily patched. Some parts are quite far from mainline Linux and should be updated to latest standards – apart from the fact the whole Linux support might want some rebase on 2.6.35.

Now we have a big pile eh… DVD with stuff that runs on the board already – what does OpenEmbedded help us with here? Well all the binary stuff serves some purpose but nothing is perfect – OE helps us with to become more flexible and consistent at the same time. XUbuntu is great with its large package repository to try out things – but it has quite some requirements about flash storage, RAM and screen size. With OE you have the choice to create a full featured desktop image or to build something that fits your particular need.

So lets take a brief look into OE setup for the Mini6410 and how to install an image built with OE.

If you are new to this topic you should get familiar with OpenEmbedded first. The official getting started document is a good thing to read first. The following section assumes you have your OE set up and cares about the Mini6410 specific bits only. Make sure to use a recent org.openembedded.dev or testing branch.

First set up your local.conf to build for the Mini6410 – if you are using multiple configuration files then make sure to distribute these bits over the files correctly:

MACHINE = "mini6410"
DISTRO = "angstrom-2008.1"
LIBC = "eglibc"

This will select the Mini6410 as a target device, Ångström distribution and eglibc – this is the combination I tested. The last line defines a limited set of libc locales to be generated.

Now let’s build a filesystem image. I built a simple GPE based filesystem image first:

bitbake x11-gpe-image

If everything is configured correctly, your harddisk is large enough and your Internet connection ok you should get filesystem and kernel image in $TMPDIR/deploy/eglibc/images/mini6410. For the impatient of you or the ones who get bored during a build (no I don not suffer from this) I have uploaded my results here.

Finally lets go ahead an install these files into the internal NAND flash. I’m using U-Boot on the boards – we want to stay open and do not rely on propitiatory software. Keep this in mind if you intend to make a product: Any component you are not able to influence has potential to cause trouble and in most cases it will do this – sooner or later.

There are several ways to install files and to configure U-Boot. Here we use a quite generic solution using TFTP to transfer the images and fixed addresses. Not the best solution but the simplest. First if you do not have a DHCP server you have to configure networking:

setenv ipaddr <some IP for the board>
setenv serverip <your server's IP>

If you have a DHCP server you can skip this step and write “dhcp” instead of “tftp” in the commands below. These will download the files and install them into the internal NAND flash:

tftp 0xc0008000 uImage-mini6410.ubi
nand erase 0x80000 0x500000
nand write 0xc0008000 0x80000 0x500000

tftp 0xc0008000 x11-gpe-image-mini6410.ubi
nand erase 0x580000
nand write 0xc0008000 0x580000 ${filesize}

Finally we configure the boot parameters to match the installed kernel + filesystem and save these:

setenv bootargs console=ttySAC0,115200 ubi.mtd=2
   root=ubi0:rootfs-mini6410 rootfstype=ubifs

(note that the first command needs to be entered in a single line)

We do not have to pass information about the MTD partition layout to the kernel since we follow the kernel’s built-in default in this configuration. Just reset your board and check if it boots into your shiny new filesystem. If something is wrong then please drop me a mail providing information (e.g. bootlog, screenshot, configuration files…). This could help to improve this little text and OpenEmbedded support for the Mini6410.

What now?

Try more useful targets with OpenEmbedded. If you like to build an installable cross toolchain matching your filesystem you could build the meta-toolchain-gpe target for example.


LinuxTag, GSoC and some progress… June 3, 2009

Posted by Florian in Devices, GPE, kernel concepts, Linux, Maemo, OpenEmbedded.
Tags: , , , , , , , ,

Its time to make announcements… I should have done this earlier, but like always it takes me a while to find a free minute to write things down.

First is about OpenEmbedded: We will be present at LinuxTag from 24th to 27th of June in Berlin/Germany. I just hope they have a little bit more space for us at the Embedded Area compared to last year. We usually have a lot of interesting devices running OE built Linux we can show. I’m really looking forward to LinuxTag – I haven’t missed one for many years and its always a nice event with a good mixture of community members, business people and users.



Google Summer of Code is in progress for some weeks now and I’m in the great position to mentor a very interesting Maemo project… something I always wanted to see but noone found time to do it properly so far: Integrate the Maemo software framework into OpenEmbedded. The benefits are quite obvious – Maemo software will gain compatibility and quality by running on (and if necessary adapting to) various devices. Apart from the fact that Maemo is a pretty good open source framework attracting quite a lot of developers. This is something other devices can and should gain advantage from. Well rkirti made a pretty good description of the project which can be found here.

It would be pretty cool to see Maemo running on this nice device I received a few days ago…


Micro2440 running gpe-mini-browser2

Its a FriendlyARM Micro2440 from Watterott Electronic – this one is equipped with the 7 inch display which gives some more “freedom” to the applications :-) Apart from this the hardware is the same I described in my previous post.

The screen geometry would match the one used by all Maemo devices so far, so it would not mess up all the graphical user interfaces. But there is still some work to do till the boards become a really good development platform. We can build useful filesystem images for them but the installation is still split up into too many steps and the up to date kernels still lack proper support for the camera and the wifi module.

I have made a toolchain to build software for both these devices and the Topas910. Together with an updated install instruction it can be found here at labs.kernelconcepts.de.  Now I’m investigating ways to integrate the toolchains with IDEs in order to simplify application development for mobile and embedded devices.

Micro2440 with Ultimate++ demo application

Micro2440 with Ultimate++ demo application

Here the device runs one of the Ultimate++ demo applications built with its IDE and the GPE-flavour cross toolchain built with OpenEmbedded. A friendly colleague found out what needs to be done to use it for ARM targets… it still needs a little help since Ultimate++ doesn’t seem to have an idea about pkgconfig and I’m not really happy with the size of the resulting binaries. But more about IDEs later…

Have a good time… and see you in Berlin!

A friendly Development Board May 26, 2009

Posted by Florian in Devices, GPE, kernel concepts, Linux, OpenEmbedded.
Tags: , , , , ,

While we are at the topic ‘evaluation and development hardware’… here here a few lines about a similar piece of hardware. I promised to do something with a FriendlyARM board already – so I did. I choosed the Micro2440 because the board itself is very small and can be used for own design easily. The very similar Mini2440 has a lot of ports on board in contrast to the 2mm headers of the Micro2440. Both boards are available through local distributors in Europe and the US now so that its not necessary to place orders in China any more. Watterott Electronic was so kind to send me a Micro2440 board and the SDK baseboard for evaluation.

Micro2440 SDK

If you want to get started with embedded Linux the board might be exactly what you want: A 400MHz ARM9 based Samsung S3C2440A CPU which is pretty well supported by Linux. 64MB od RAM and the same amount of NAND flash and 2MB of NOR flash for a backup bootloader. The baseboard has the connectors for the serial ports, USB host and client, display, expansion and SD and adds an audio codec and an Ethernet chip. There are two variants available: One with a 3.5″ QVGA TFT (pictured) and one with a 7″ 800×480 TFT.  Both displays come with a touchscreen and in addition to this the board has a few buttons that can be used for a human interface. The whole SDK kit including Micro2440, SDK board, 3.5″ display cables and JTAG doesn’t cost more than 125 EUR incl. VAT which makes it even more appealing.

The ‘softer’ part of the SDK quite appealing too: The hardware is pretty well documented, even the schematics are available to the public. FriendlyARM released some demo images and Linux sources that are useful (but not perfect). The ‘Vivi’ bootloader used by the boards can be replaced with u-boot easily so that you get a 100% Open Source embedded development environment.

Thanks to the OpenMoko community the S3C is pretty well supported in Linux and u-boot. There is a public project providing up to date Linux, u-boot and QEmu supoort for these boards that can be found here. Like I usually do for a new piece of embedded or mobile hardware I used OpenEmbedded to built a GPE based filesystem image for it. Like you can see in the picture it works pretty well. For people interested in this I put together some notes I took and the binary images at KC Labs. Feel free to contact me about this… I plan to extend support for it a little bit and provide a toolchain and additional information.

Have a nice time!

PS: Sorry for the bad image this time, I had to use the webcam to capture it.

Linux Support for a Gem April 22, 2009

Posted by Florian in Devices, GPE, kernel concepts, Linux, OpenEmbedded.
Tags: , , , ,

Some time ago I got a nice looking and interesting TOPAS910 evaluation board for the ARM based Toshiba TMPA910 series of SoCs. With its black PCB and golden labels for the expansion ports it is definitely the best looking evaluation board I have seen so far. But its interesting from a technical point of view as well and of course you can run Linux on it.

Topas 910 Board

Topas 910 Board

The TMPA910CRAXBG SoC on the board is based of an ARM9 core clocked with 200MHz and a pile of external interfaces such as:

  • TFT controller
  • USB client
  • NAND and NOR flash
  • SPI
  • Touchscreen
  • ADC
  • SD / MMC
  • UART

The board can be powered from the USB port, has Ethernet, a QVGA TFT display and all necessary interfaces to get started with the SoC.  Some details can be found here.

Board Details

Expansion Connectors

The initial Linux port was made by a company called BPlan known for their Amiga projects. They provide two ports: A real port to the hardware platform and one making use of some proprietary OpenFirmware-like bootloader. The latter is quite useless because it depends on calling its firmware for every hardware access but the 2.6.26 patch, bootloader and documentation they provide on their website are a good start. After a deeper look into the kernel patch it was clear that they left a lot of things to do: Only half of the TFT, NOR flash, USB, Ethernet anf the serial port are supported. It among other lacks a driver for SD, NAND, audio, the joypad and all the GPIO ports.

I wasn’t able to resist and started a small project to improve support for it. I have updated the kernel to 2.6.29, added gpiolib support and drivers for joypad and the small LED display which helped testing the GPIO drivers. Of course I have OpenEmbedded support for it ready and pushed upstream today – even if this still uses the old kernel it is useful to build a tiny userland that is able to live in NOR flash. Now I need to get some storage facility sich as SD or NAND flash working in order to deploy a proper filesystem image.

The TMPA910 is the chip in the BGA case in the center of the image.

The TMPA910 is the BGA case in the center of the image

I would be interested in getting to know any hardware that is using this TMPA910. The results of my work: Sources and a small demo image can be found at KC Labs. We haven’t announced it yet, but its there already: KC Labs is the new Open Source projects website at kernel concepts.


A smart BeagleBrick March 29, 2009

Posted by Florian in Devices, GPE, Linux, OpenEmbedded.
Tags: , , , , ,

Some time ago I wrote some lines about the nice combination of projected human interfaces such like the TI PICO projector for visual output and the ‘laser keyboard’ for input. The innovation you can gain from such a combination is a device whose interfaces dimensions can can differ from the dimension of the device quite a lot. After playing around and having an interesting time watching people using these technologies (e.g. at FOSDEM) I finally manged to create a device study combining the components into a single case. It turned out to be more complicated than I thought and the way to a ‘production ready’ device would involve a lot of research and improvement.The main idea was to have something you can touch and try if it can be useful.

But let’s take a look at it first – for now its just a kind of brick with a BeagleBoard and some more components inside.

"The Device" in action

"The Device" in action

From a technical point of view the contruction is quite simple – its just a collection of easy to get components:

  • TI BeagleBoard (Rev. B4 in this case)
  • Celluon CL850 “Laser Keyboard”
  • A tiny USB hub
  • TI PICO projector
  • Some custom USB cables
  • Huawei UMTS modem
  • One Bopla BOS 800 case
  • A small RS-MMC card for the root filesystem

The batteries didn’t fit into the case – the same problem like my GSM evaluation platform I intended to use for connectivity. Instead of this I had to use the Huawei modem but lost an easy to use audio part (I still would like to see these interfaces in some kind of smartphone) and the charger for Li-Ion batteries. The USB connected UMTS modem is advertized to have audio capabilities but there is no Linux support for this feature yet. Another component that caused some headaches is the HDMI cable for the PICO projector: It is thick and its big plugs waste a lot of space in the small case.

I removed the cases of USB hub and keyboard to make them fit into the case. From the BeagleBoard I had to remove the S-Video connector in order to reduce its height.

The current software is way less spectacular than you might think. Its a simple Ångström distribution GPE image built with OpenEmbedded. I had to replace Xorg with Kdrive in order to get the Xrandr extensions working and added some more software for testing such as an additional browser. This is not really the software you wold expect for a modern smart phone but its a good environment to test an uncommon mobile computer.

So what did I find out in the initial tests?

  • It looks very very geek!
  • Its useful to some extend but you need an even surface.
  • The mechanical design needs improvement. This ‘brick’ case is not really flexible and even a better arrangement of components (e.g. projector and keyboard side by side) would save a lot of space on the table.
  • It would be necessary to have a different lense for the projector: You want a wide angle lens to get a large projection area in a short distance drom the device. As you can see in the image the desk space you need is quite high but the image is still small.
  • The power consumption of the projector is a major problem. It is hard to power with batteries and in a plastic case it gets very hot.
  • Someone needs to come up with a clever holder for a sheet of paper to make it a useful screen. Suggestions welcome!
  • If I have the chance to do so I would like to try an improved prototype with a small secondary display, batteries and a keypad.
Typing on the table

Typing on the table

A device I could imagine would be a kind of a stand for a smartphone with built-in projector module. The next generation of projector modules should be small enough for this and comsule less power. The stand would allow the phone to stand upright on the table and provide the keyboard functionality. The advantage of this solution would be that you would not have to carry around the keyboard engine all the time. And because of the orientation of the phone you can get larger ‘screens’ if the projector is in the top end of the phones case. Maybe I should sketch this for the next blog entry… :)

Have a nice time!

Fun with BeagleBoard and projector devices January 19, 2009

Posted by Florian in Devices, GPE, kernel concepts, Linux, OpenEmbedded.

A PICO projector is a nice thing: An interesting toy, useful tool or whatever you might call it. I got one of these from Textas Instruments in order to prepare small demonstration of an idea… but more about this in a later article. The most intersting question about these PICO projector engines is what they mean for the design of future devices.

From a mechanical point of view they offer a very important improvement: It offers display sizes that are not limited to physical size of a device. This is an interesting perspective for mobile devices. Will we finally get smartphones that provide a display which is useful for office work and internet browsing and still small enough to fit in a pocket. (I have to admit that I carry a quite modern/big smartphone – a Nokia E90 – in my pocket: It fits, but I have to say that there is some room for improvement. :-)

When I read the announcement of the PICO projector at the BeagleBoard mailinglist another device I read about some time ago came to my mind: A projection keyboard.

Keyboard projection on desk

Keyboard projection on desk

Even if it takes a little bit of time to get used to the projection keyboard it is an interesting alternative for mobile use. If its well calibrated for the surface it is a quite usable replacement for a real keyboard and still fits in a pocket. But more important for me: After a closer look at the construction I am convinced that it would be possible to reduce the size quite a lot. You see, I have mobile devices in mind all the time :-)

BeagleBoard with Projector and Keyboard

BeagleBoard with Projector and Keyboard

The BeagleBoard is a nice platform because its performance and interfaces are similar to what we will have in quite some mobile devices soon. Its based on an OMAP3 SoC which is designed for powerful mobile devices and offers all sorts of peripheral controllers like USB host and OTG, TFT controller, SD interface and SPI. Several companies announced OMAP3 based devices already.

For my initial experiments I used the devices you can see in the image above. Apart from the BeagleBoard, a small USB HUB, the projection keyboard and the PICO projector there is a cheap USB Wifi adapter, a serial cable and a sheet of paper. Think about adding a powerful battery (power consumption is a very important topic, especially regarding the projector and the keyboard) – you would end up in a quite small device already. Not too bad, compared to the popular Netbooks but still with some drawbacks and a good mechanical design might be a challenge.

The BeagleBoard here runs a custom Linux filesystem with some GPE and other GTK+ based software built with OpenEmbedded. The latest 2.6.28 kernel OE builds seems to work pretty good, one major improvement seems to be the reliability of the USB OTG port which caused a lot of trouble in my previous tests.

Now I’ll add additional componets to get a more complex environment for playing with components and software I assume to be relevant in near future…

Devices July 28, 2008

Posted by Florian in Devices, GPE, kernel concepts, OpenEmbedded.
Tags: ,

I spend quite some time with Linux on all sorts of interesting devices. There are several ones not yet covered by my blog, so I decided to start a series of postings about devices running Linux. I introduce a new ‘Devices’ category in my blog to cover these hardware related topics.

Currently I am building a GPE filesystem image for the BeagleBoard I won at LinuxTag. They just announced that the board is on sale now.

For the friends of old Geode based web terminals such as the IBM Netvista J320/8365 I have an updated Angstrom based CF card image. It fits on a small 128MB card and comes with GPE and several browsers (gpe-mini-browser, midori and netsurf) to play with. In addition to this external USB touchscreens are supported. The CF image can be found here – if you want to build it yourself you can get kernel and filesystem seperately.

Another new ‘victim’ is the Neon board by Boundary Devices…. but more about these later.

Neon Board

Neon Board

Maemo Summit July 22, 2008

Posted by Florian in GPE, kernel concepts, Linux, Maemo, Source.
1 comment so far

Good news for me… after missing GUADEC and other interesting events it looks like I’ll make it to the first Maemo Summit in Berlin. The list of participants is quite impressive – I guess this will be a really interesting event. Just join us there :-)

I read a few lines about odeviced… anyone else who thinks that using something like this for Maemo might be a goo idea?

I do not have much time left for blogging and coding currently – family and work keep me busy these times. But a few good things are in prgress – OpenSync’s roadmap indicates that they are close to a new release. This will be a much better base for MaemoSync than current SVN trunk. Even GPE makes a little bit of progress. Graham continues fixing various PIM bugs and gpe-memo is close to become ready for its first release.

Have a nice time…

LinuxTag 2008 summary May 31, 2008

Posted by Florian in GPE, Linux, Maemo, OpenEmbedded.

Linke every year we had a really good time at LinuxTag! It is always a great event talking to interested users, business people and other developers. For the projects sharing this booth such as MyStep, Jalimo, GPE and OpenEmbedded it was a great success. For me it was the first time representing OpenEmbedded at a fair like this – with good results: We had quite some people who knew OE and asked specific questions and many developers with interest in using it.

LinuxTag always gives a lot of inspiration for new things to do and projects to check out. I know about some interesting software we need in OE soon – things like the Sugar framework for the OLPC and x2go. Other important tasks are to publish a list of evices that are defined in OE metadata and pushing the mobile-linux project forward.

In the Maemo track I had a short talk about GPE applications for Maemo – the slides of my talk can be found here. Unluckily I was not able to attend more of the interesting talks in this track. But I found out that the Mamona people seem to like OpenEmbedded at least :-)


The Tarent and Mobile booth right after opening in the morning… it was way more crowded a short time later.


Many thanks to all the people organizing LinuxTag and Tarent for booth and the big red sofa for sitting down to write my blog.

Maemo Sync packages April 2, 2008

Posted by Florian in GPE, Maemo, Source.

I have made an installable package for Maemo Sync, but do not expect too much. Its a basic port of the current Multisync-gui to Maemo. It is only tested to so far that the GUI starts up and registeres correctly. The fact that I had to use cmake for building Maemo software caused some headaches here… the quality of the source distribution package is still quite bad.

I also did not decide if I want it to become a project forked from Multisync-gui or to maintained with Multisync-gui adding optional support for Maemo environment. The always changing OpenSync API would be a reason to stay with Multisync-gui, but the fact that I have different opinions about UI design, Glade is involved and cmake are reasons for making it a separate project.

Binary package and sources are located here. You also need the OpenSync packages from Graham’s daily repository.

Another minor improvement of the GPE application packages in this repository is that latest Starling supports OGG playback. You only need to have an OGG plugin for GStreamer installed. The mogg package provides this for example.

Any feedback is welcome – if you manage to sync data with either the command line tool msynctool or using Maemo Sync please drop me a line. I would like to collect information which sync peers work with latest OpenSync and how to set up these.