And yet another AllWinner A20 development platform shows up in my news stream in about 24 hours. Merrii Technology, a Shenzhen based electronics design house, has showed off their Hummingbird Development Kit to ARMDevices.net. The development board comes with 1GB RAM, 4GB NAND Flash, Gigabit Ethernet, SATA, HDMI output, and more. There’s also an optional 7″ capacitive touch screen display for the board. The company explains the kit can be used to develop application such as media players, game consoles, IPTV, automotive products (GPS & IVI), robots, servers, surveillance products, and home automation systems.
Here are the board specifications:
SoC – AllWinner A20 dual ARM Cortex-A7 core @ 1 GHz with ARM Mali400-MP2 GPU
System Memory – 1GB DDR3 (2x 4Gb 16bits DDR3)
Storage – 4GB MLC 64bit ECC NAND Flash (Hynix H27UBG8T2A), SATA II connectors, and micro SD card slot (Up to 32GB)
Video I/O – HDMI out, CVBS out, and YPbPr input. Display connector for LVDS and RGB displays. VGA is apparently available via the expansion headers.
Touch Panel – Support quad-line resistive touch screen and capacitive touch screen with TWI interface
Audio I/O – Headphone jack, Line-in
Expansion – 2x 50-pin headers at the back of the board. For detailed pin assignments, please refer to the board product brief.
Debugging – UART connector
Misc – Reset and power on keys, IR sensor
Power – 5V/2A DC. PMIC: AXP209. Battery slot (for RTC?)
Dimensions – 105 x 70 mm
Although Merrii Technology is supposed to be a design house, the PCB design seem to have been outsourced to WITS as the marking at the center bottom part of the PCB implies. It’s also possible the two companies have the same owner(s), and WITS / Merrii products are jointly promoted.
The company provides support for Android 4.2, and Linux 3.4 (sunxi). They can also provide a graphical interface based on Qt for Linux. Hummingbird Android SDK is available publicly, and support and Linux images will be available via the company’s BBS.
Charbax video starts with an introduction of the Hummingbird development system, followed by a visit of the company mostly with hardware, software development, and SW QA departments. At the end of the video, they also show WITS A31 development platform ($1300), as well as several AllWinner core boards.
Hummingbird development system is available now for 299 CNY (~$50) for the board only, and 499 CNY (~$82) with the 7″ touchscreen display (800×600). At least that’s the price shown on Merrii’s Hummingbird page, as the company has also setup an Aliexpress store where these are sold for respectively $80 and $108 sometimes including shipping, sometimes excluding shipping. The board is said to come with a power adapter,a USB cable, and a SATA Cable.
I’ve just received an email from the Linux Foundation saying the schedule for LinuxCon and CloudOpen Europe 2013 had been made available. The conference will take place for 3 days (October 21-23, 2013) in the Edinburgh International Conference Center, Edinburgh, United Kingdom. There will be over 100 conference sessions, and several co-located events including: Automotive Linux Summit, the Embedded Linux Conference, Gluster Workshop, KVM Forum, Tizen Summit, Xen Project Developer Summit.
This presentation will cover a brief introduction on how the Bluetooth Low Energy technology works. Then it will present the current status of its support on Linux, including the profiles we’re currently working on what can be expected to be finished on the near future. The currently available APIs and how to interact with Bluetooth Smart devices will be shown and there will be a few demos of Bluetooth Smart devices working with Linux.
The many tracing tools available on Linux today provide a wide array of choices for the users. Deciding which of them to use to diagnose system problems on production systems can prove challenging. Various tools have various states of integration within the Linux kernel, and also within different Linux distributions. Bleeding edge features are often just being merged into the upstream Linux kernel. It takes often a long time for such features to be incorporated in commercial distributions. The required set up for the tools and their level of usability also vary significantly. This talk will cover the more popular and actively developed tracing areas focusing on their latest updates and will describe the infrastructure they rely on. An overview of the tracing tools (ftrace, perf, systemtap, DTrace for Linux, etc) will be included with some examples of usage of each.
HTML5 is going to be used widely because of its powerful specification. A lot of browsers are now supporting HTML5. It is a new technology, so that currently only few engineers can use this technology. Needs of such skillful engineers are urgent and necessary from the point of Industry, such as automotive and others. We started the development of the certification program of HTML5 skill set. The purpose of this program is to encourage engineers to learn and and improve their skill set, and increase number of skillful engineers. In this presentation, I will provide why we started this program, how we develop, and time-frame.
Being one of the most successful open source projects to date, WebKit development process consists of a series of protocols and strict policies in order to obtain committer and reviewer status. Blink follows a similar approach with committers and scoped code owners, in a similar fashion as Linux Kernel does with its subsystem maintainers. Their open source success is due to not only solid support from major technology companies, but also to the high quality and automated testing performed on patches before submission. In this presentation, Bruno explains how the development process of both WebKit and Blink projects are – from submitting well-tested patches with strict policies to check, get review from community, and commit upstream via commit-queue system (including early warning system bots). This is a very practical talk with live demonstrations of patch submissions on both projects.
Most of the kernel messages would be intended to know developers what’s going on in the kernel, and they tend to be not friendly to users and machines. To improve this, Hidehiro Kawai is trying to add hash value for each kernel message to identify them easily. If this feature becomes available, users can consult external manuals by feeding the hash and know detailed information. Or a monitor tool can identify specific message in low overhead and trigger a fail-over or collect related information automatically. In this presentation, he explains the implementation of the first RFC patch set, on-going discussions (if there are), and how utilizing the feature in user space, while introducing a similar challenge 5 years ago and how addressed its objections.
The Wayland project is growing fast, as well as its adoption by several toolkits. EFL (Enlightenment Foundation Libraries) specifically has a Wayland backend being actively developed over the last 2 years, with its latest features being already incorporated. EFL developers are also contributing back to the Wayland project itself, helping to improve the protocol and implementation, from a toolkit point of view. This talk will present the current development state of the Wayland backend of EFL, describing the latest incorporated features. It will also present the changes that this port has passed since the beginning of its development, and its improvements so far. A comparison to the other EFL backends will be done, as well as future plans for Wayland on EFL and the Enlightenment Window Manager.
Window managers and desktop environments in the Open Source community number in the dozens, but only a small number of those include compositors; fewer still can boast that they run seamlessly on embedded devices or in Wayland. Enlightenment is so flexible that it was chosen by Samsung to be to window manager for their new Linux-based mobile operating system, Tizen, in addition to being used by tens of thousands of users worldwide for over a decade. With the current development of E19, it’s time to take a step back and look at the main feature: compositor design. This presentation will give a brief introduction to compositing and window management before jumping directly into the history of Enlightenment’s compositor architecture and its progression to the current state of full Wayland and X support.
The 2013 version of this popular talk describing the current state of kernel development and where it can be expected to go in the near future. There will be some technical content, but this talk is highly accessible to non-technical participants as well.
Concurrency issues in the software, and data races in particular, may have devastating effects but are often quite hard to reveal. Hunting down such problems is especially important for the Linux kernel, which is inherently concurrent. Although there is a variety of tools to help reveal data races in the user-space code (Helgrind, DRD, ThreadSanitizer, etc.), there are only a few that can be applied to the kernel. In his presentation, Eugene Shatokhin will give an overview of such tools and the techniques they rely upon. Among other things, he will present KernelStrider, a component of KEDR Framework that collects data about the operation of the kernel modules in runtime. The data are then analyzed by an “offline” detector in the user-space to actually reveal the races. The results obtained so far as well as possible directions of future development will also be discussed.
“git bisect” is a command that is part of the Git distributed version control system. This command enables software users, developers and testers to easily find the commit that introduced a regression. This is done by performing a kind of binary search between a known good and a known bad commit. git bisect supports both a manual and an automated mode. The automated mode uses a test script or command.People are very happy with automated bisection, because it saves them a lot of time, it makes it easy and worthwhile for them to improve their test suite, and overall it efficiently improves software quality.
The GFS2 cluster filesystem has been under development for a number of years, however there has been no up-to-date presentation covering all of the latest features since OLS 2007. The intent of this talk is to provide an overview of the current feature set, noting recent significant developments, as well as an introduction into the major algorithms of GFS2 for those less familiar with its capabilities. During the development process, many lessons were learned which would apply equally to any open source project, and these will be discussed too.
October 21, 2013 marks the Qt Project’s second anniversary. Launched in 2011 to be the home of the Qt libraries and frameworks under Open Source Governance, the Qt Project has seen quite a lot of change in these 2 years., good and bad. It lost its main sponsor and many doubted the project would continue, but it did, and it managed to release the first major release in 7 years (5.0), one more feature release and half a dozen patch releases. This presentation will review the principles of the project’s governance, who the contributors are and how they work, the major changes that happened in the past two years and how they’ve influenced the project. It will explore the development process from patch to release and to maintenance / bug fixing, and will also show how non-code contributors participate.
As the number of cores in systems steadily increases, you may find that the good old mutual exclusion synchronization is not sufficient to let your application use more cores not only for heat generation, but primarily for effective computing. The Userspace RCU library implements Read-Copy Update (RCU) synchronization and various lock-free data structures that allow user-space applications to leverage very lightweight synchronization across cores. It allows a broad range of demanding applications to scale to large numbers of cores. This library is released under LGPL v2.1, so it can be used by all applications. This tutorial will walk the audience through the basics of Read-Copy Update, and then through the synchronization and data structure APIs exposed by Userspace RCU.
Digia has recently announced Boot to Qt Technology Preview, a commercial offering that provides a solution for the creation of user interfaces on embedded systems. For the first version, they stripped out Android of Java, or other unnecessary parts (Zygote, SurfaceFlinger), added Qt/QML, and tested it on on ARM and x86 hardware.
Boot to Qt includes the following main features:
A light-weight UI stack for embedded Linux, based on the Qt Framework - Boot to Qt is built on an Android kernel/baselayer and offers an elegant means of developing beautiful and performant embedded devices.
Ready-made images – We have images for several different devices which include the Boot to Qt software stack, making it possible to get up and running with minimal effort from day one.
Full Qt Creator Integration – One-click deploy and run on hardware and a fully featured development environment.
Simulator – A VirtualBox based simulator which allows device development without hardware and opens up for simulating hardware input, such as GPS and connectivity.
The software stack includes most of the Qt Framework:
Qt Core, Qt Gui, Qt Network, Qt Widgets, Qt Xml
Qt QML and Qt Quick
Qt Quick Controls
Qt Graphical Effects
Boot to Qt specific additions, including virtual keyboard, brightness control and power off/reboot functionality
However, it currently excludes Qt multimedia and webkit.
The demo below shows Boot to Qt running on Nexus 7, Beagleboard-XM, and Boundary device SABRE Lite showing Qt Quick 2.0 apps, including Qt Cinematic Experience rendered at 55 to 60fps on all three platforms.
The application launcher uses 2% CPU on Freescale i.MX6, 15% of Beagleboard-XM on a 1280×800 screen, most of which is animated. On Tegra 3, CPU usage was 50%, the reason behind it was CPU frequency scaling, as the Tegra 3 just needs to run one core @ 102 Mhz to achieve 60fps in the Qt launcher.
Digia also published a diagram comparing boot times of Boot to Qt (to B2Qt Launcher) and Android (to Home Screen) showing considerable improvement. The company acknowledges Android adds lots of additional stuff, but for embedded systems you don’t need those, and you can optimize boot time.
They still expect to improve boot time, as for example, Qt 5 on Raspberry Pi can start rendering after as little as 3 seconds.
They used Android kernel and baselayer in this preview because of better drivers support, but they are also working on ready-made images and IDE integration for traditional embedded Linux, possibly with a preview coming some time this summer. The official release is expected for the end of the year.
You can find more information and/or request an evaluation on Digia’s Boot to Qt page.
CoAction Hero is a tiny board based on an ARM Cortex-M3 micro-controller (NXP LPC1759), that makes use of CoActionOS ecosystem that includes the hardware, but also an open source RTOS allowing multiple app to run concurrently, and a graphical interface to communicate with the board.
First, let’s have a look at the hardware specs:
Micro-controller – NXP LPC1759 ARM Cortex-M3 processor @ 120MHz with 64kB RAM and 512kB Flash ROM.
Storage – 1MB serial flash chip (pre-loaded with CoActionOS)
micro USB connector.
40 I/O pins are available on both sides of the board, and the board can be inserted in a breadboard.
You can currently connect 2 modules to the board: Bluetooth and LCD device boards.
CoActionOS RTOS will come pre-loaded on the board, and if you don’t want to, you don’t even need to know it’s there, and it’s use will be transparent. But let’s have a quick look at this real-time OS, which allows multitasking on Cortex M3 MCU, supports an unnamed filesystem, and they also provide a C/C++ library to help with hardware peripherals (GPIO, ADC, SPI, UART,…) programming.
The desktop development environment, based on Qt 4.8 and GCC, currently runs on Windows and MacOS, with Android and iOS support coming once Qt 5.x is available for those mobile OS. Linux may also be supported at a later stage. The board connects to your computer via its micro USB port, and CoActionOS Link software allows you to browse the board’s filesystem, provides terminal access, install programs, re-flash the kernel, and monitor running processes. They recommend using Eclipse for compiling programs.
Several example projects are showcased on their kickstarter page such as driving a 1.8″ LCD, a DC Motor with PWM and PID, and an LED strip.
You can pledge as low as $29 to get the CoAction Hero board with a USB cable, and with a $99 pledge, you can add the Bluetooth and LCD expansion boards. Devkits should ship to backers in July 2013.
threewater, a Chinese developer, has just posted a very interesting demo on linux-sunxi mailing list showing a device based on AllWinner A10 boot linux within 0.85s, and if you add a Qt app, the total time is just about 1.2s.
This appears to be a custom hardware (EM6000), but we do know it’s based on AllWinner A10, comes with 512 MB RAM, and 4GB NAND Flash. On the software side, the device runs kernel 3.4 from linux-sunxi, with a customized version of uboot, a squashfs rootfs, and a Qt 4.7.4 app showing a gauge. Both the rootfs (7MB) and the kernel (2MB) have been compressed with LZO. All that boots from NAND flash for optimal speed.
The 1.2 second time includes kernel + rootfs + app time, and the total time is a bit longer, but this is still impressive. Here’s the boot log:
[1.690000 1.690000] U-Boot SPL 2013.01-05984-g2120a27-dirty (Apr 17 2013 - 14:22:02)
[0.009000 0.009000] Board: EM6000
[0.012000 0.003000] DRAM: 512MB
[1.014000 1.002000] init startup v1.1
[1.016000 0.002000] mount usr data error 2
[1.158000 0.142000] Could not read calibration: "/data/etc/pointercal"
[1.166000 0.008000] Couldnt open tslib config file: No such file or directory
[1.175000 0.009000] QWSTslibMouseHandlerPrivate: ts_config() failed with error: 'No such file or directory'
[1.187000 0.012000] Please check your tslib installation!
[1.200000 0.013000] qt show
If you just boot to the command line, it’s even faster:
[1.770000 1.770000] U-Boot SPL 2013.01-g8a69ff9-dirty (Apr 22 2013 - 13:05:36)
[0.007000 0.007000] Board: EM6000
[0.009000 0.002000] DRAM: 512MB
[0.810000 0.801000] /etc/init.d/rcS: line 6: /data/run.sh: not found
[0.843000 0.008000] login: root login on 'ttyS0'
[0.851000 0.008000] [root@(none) /root]#
This is not the first time, people have implemented ultra fast boot on ARM hardware, an example is a ~400ms boot on the Beagleboard, but it’s still nice to see what can be achieved thanks to developers’ communities such as linux-sunxi.
The complete details and/or binary files are not available at this time, but if you are interested in Linux fast boot, you may considering checking Adeneo Embedded presentation at ELCE 2012 who did something very similar on Freescale i.MX51 & i.MX 6Q hardware.
You may have heard about libhybris, a library that cleverly loads Android HW adaptations and convert calls from bionic to glibc. One of the greatest achievement of this library is to allow Android GPU drivers to be used with Linux, and is notably used by Canonical, although they did not write it, for Ubuntu 14.04 which will be compatible with any recent Android smartphones or tablets.
One way to get started with libhybris is to port a device to Ubuntu Touch, but this may take a while. However, I’ve found a faster and easier way to play with libhybris thanks to Martin Brook (vgrade) who wrote a tutorial on how to use libhybris with Mer on the Cubieboard. Mer is an open source mobile Linux distribution powered by Qt/QML and HTML5, that’s born from the ashes of Meego, and is now used in the upcoming Sailfish OS.
Qt5 Cinematic Experienced Rendered at 25 fps in Cubieboard via Android GPU Drivers in Linux Thanks to libhybris
You’ll need to follow 4 main steps:
Build a minimal Mer image
I’ll skip the Mer image build since Martin has provided a binary image. I’ll use a build machine running Ubuntu 12.04.2 LTS. You should make sure the build environment is setup correctly, you’ve installed repo, and that it’s in your path. I’ll use the Cubieboard (1GB RAM), but you may want to try other hardware platform, or Linux distribution as the instructions should be similar.
Build Android for the Cubieboard
This is basically following the instructions provided here. First let’s code Android Jelly Bean (CyanogenMod) source code:
repo sync may take quite a while depending on your Internet connection. It took 10 hours, after several attempts over three days… Once this is done, we’ll need to configure the build for the Cubieboard:
Select Cubieboard (#4), and start the build:
The build initially failed with this error:
You have tried to change the API from what has been previously approved.
To make these errors go away, you have two choices:
1) You can add "@hide" javadoc comments to the methods, etc. listed in the
2) You can update current.txt by executing the following command:
NO. NO. STOP BEING LAZY. SERIOUSLY.
DO NOT DO THIS in CM. THIS IS A LIE. IF YOU DO THIS I WILL HATE YOU.
USE OPTION #1.
To submit the revised current.txt to the main Android repository,
you will need approval.
So I shamelessly typed “make update-api” to automatically update current.txt, and continued the build with “make -j10″. The build may also take quite a while depending on your computer performance and available RAM. This step was much faster than repo sync in my case, as it just took about 45 minutes in total.
The Android build is now completed, but we need still to patch Bionic library, and rebuild:
wget http://pastie.org/pastes/7649385/download -O bionic_libhybris.patch
patch -p1 < bionic_libhybris.patch
Now let’s tar Android’s system directory as we’ll need to copy the will have the patched bionic library plus all the android libs (EGL, GLESv2, RIL etc):
tar cjvf ../../../../../cubie_android_system.tar.bz2 .
Installing and Running Mer
Since we don’t build the image ourself, this step is rather easy, as we just need to download the image, and dump it to a micro SD card.
Where you need to replace <sd_device> by your actual SD card device such as “sdc”.
My 4GB microSD is slightly smaller than the image provided, so dd failed at the very end. But you can usually run the following 2 commands on the last partition (in this case ext4) in order to resize the partition, and fix any potential boot problems:
e2fsck -y /dev/sdc2
resize2fs /dev/sdc2 +3300K
Interestingly, this time those commands failed, but I still inserted the microSD in my Cubieboard, and I was able to login successfully into Mer via the serial console as root (password: mer). You should also have access a terminal on the HDMI monitor.
We don’t want X to start anymore, so let’s disable it and restart the Cubieboard:
zypper rm uxlauncher
If you’re using HDMI console, switch to VT2 (Ctrl+Alt+F2) before running the command.
Installing libhybris and Android system folder
Let’s log-in again via the serial console, or via VT2 on the HDMI monitor if this works for you, and install libhybris:
zypper ar http://repo.merproject.org/obs/home:/sage:/libhybris/latest_armv7hl/home:sage:libhybris.repo
zypper in libhybris
zypper in libhybris-tests
You may want to enlarge your terminal for the steps above, as the text goes over the window, and you have to answer some questions for the installation. The next step is to install Android’s system files to /system in the Cubieboard. Copy the files from the Linux PC to the Cubieboard:
After a reboot, Cubieboard decided to boot Android from flash, so I tried to remove and re-insert the micro SD, and noooooooooo! The micro SD socket let me down and refuses to lock the card in place, so I’ll have to replace the slot which will take me few weeks since I have to order the thing.
So I count on you to let me know what has gone wrong. Thanks
Let’s carry on as if everything worked just fine, and run the next demo:
This should display a white diamond shape filled with an animated Catherine wheel.
Martin also has instructions for several other demos, but the most interesting one (we have a video), is Qt5 Cinematic Experience that you can install in the board as follows:
zypper in qt5-plugin-imageformat-jpeg
zypper in qt5-plugin-platform-eglfs
zypper in qt5-qtdeclarative-qmlscene
zypper in qt5-qtdeclarative-import-qtquick2plugin
zypper in qt5-qtdeclarative-import-window2
zypper in qt5-plugin-generic-evdev
zypper in vim
zypper in qt5-qtdeclarative-import-particles2
zypper in qt5-qtquick*
curl -O http://quitcoding.com/download/Qt5_CinematicExperience_rpi_1.0.tgz
tar -xf Qt5_CinematicExperience_rpi_1.0.tgz
Now edit content/Mainview.qml with vim, and comment out the PathAnimation part.
The X server is getting old, and many developers complain it’s not an optimal solution anymore due to its (over) complexity, which was why Wayland was developed. However, it turns out Ubuntu will not use Wayland, but instead their own display server called Mir which will be used in all form factors from phones to desktops.
Mir on Android Drivers (Now and in May 2013)
Phoronix has provided a quick summary about the key aspects of Mir:
Mir is a new display server being developed at Canonical and it is not based on X.Org or Wayland.
Android graphics drivers will be supported.
Existing DRM/KMS/Mesa/GBM (the open-source Linux graphics drivers) will work. Canonical is pressuring the binary blob vendors to make their drivers compatible.
There will be support for legacy X11 applications through an integrated root-less X.Org Server.
Canonical will natively support GTK3 and Qt/QML toolkits with Mir.
Mir will be used for all form factors from Ubuntu Phones to the Ubuntu Linux desktop.
Mir should be ready for Ubuntu Phone OS by this October while it should come to other form factors (and the desktop) within one year.
Canonical has not chose Wayland because it could not fulfill their requirements completely, but due to their design, it would still be possible to add Wayland support by implementing a Wayland-specific frontend for the Mir server or by providing a client-side implementation of libwayland that talks to Mir.
Mir will also run on the free drivers software stack, but it does not run on closed source drivers now, and Phoronix reports that Canonical is in talks with closed-source vendors (NVIDIA and AMD) about supporting Mir and a unified EGL-centric driver model. From the look of it, it seems only desktop platforms will support the free Linux graphics drivers, which means other platforms such as smartphones and tablets may have to rely exclusively on the Android drivers (TBC).
There are three milestones for Mir development:
May 2013 - Finish the first step towards integrating Unity Next with Mir and provide enough facility to start iterating the actual shell development.
October 2013 – Unity Next & Mir window management are completely integrated with the rest of the system to support an Ubuntu Phone product. Desktops and laptops will have access to a legacy mode that allows to run legacy X clients against an on-demand rootless X server.
April 2014 – Complete convergence across the form factors is achieved, with Mir serving as the carrier across form factors.
That means Ubuntu 14.04 LTS will be the first release to fully take advantage of the new display server.