Archive

Posts Tagged ‘elce 2012’

BoFs: Developer Tools and Methods: Tips & Tricks – ELCE 2012

January 16th, 2013 No comments

Tim Bird, senior staff software engineer at Sony Network Entertainment, hosts a BoF session about tools & methods for embedded Linux developers at ELCE 2012.

Abstract:

In this Birds-of-a-Feather-session, Tim will share some of his favorite tips for developing embedded Linux software. This will include tips for using ‘git’, how he does multi-platform development, and tips for other tools that other developers might find useful. Prior to the event, Tim will do a survey and solicit ideas from other developers as well. Please come to this BoF prepared to share your own productivity tips for embedded Linux development.

Tim talks is divided into the following key points:

  • Git tips – How to finds info about commits (git log, git show), use aliases (e.g. for colored output), find a commit that caused problem (git bisect), and more
  • Patch management – quilt patch managing tool, diffinfo, and splitpatch (to break patches apart)
  •  Source searching – cgrep, mgrep, confgrep, kgrep, armcgrep, jgrep, git search, and finds (with a “s”)
  • Kernel debugging
    • Use of fs/sync.c:SYSCALL_DEFINE0(sync)
    • qemu for kernel debugging
    • Enable CONFIG_DEBUG_LL and CONFIG_EARLY_PRINTK (on ARM) kernel options.
    • Finding the printk buffer with U-boot
  • Testing – tbtorture.sh – for stress testing (cnxsoft -> can’t find it)
  • Board handling
    • Consistent board setup (including remote access)
    • Connections: serial, network, power (maybe USB)
    • tftp boot kernel, with NFS rootfs
    • Tiny Target Control (ttc) – command line tool for board control (cnxsoft -> can’t find it)
    • Serial TTY tricks & tips
  • Personal productivity – Notes, to do, git branch…
  • Your ideas….

You can also download the slides for this BoF session.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on DotNetKicks.com
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

Barebox Bootloader Status Update – ELCE 2012

January 16th, 2013 No comments

Sascha Hauer, kernel developer at Pengutronix, gives an update about the status of Barebox bootloader at the Embedded Linux Conference 2012 in Barcelona, Spain.

Abstract:

Booting Linux is still a hot topic on embedded systems. It has been 3 years since the last presentation about Barebox at ELC-E, and the barebox community has grown and developed many new and unique features during that time. The talk gives an update on the status of barebox, including MMU support, compressed images, menu system, automouter, tftp, nfs filesystem, USB updating techniques and other goodies.

barebox logoThe presentation is for kernel porters who need a robust, flexible,extensible and well structured tool to bring up Linux on embedded hardware. It is equally suitable for new and experienced barebox users.

Agenda of the talk:

  • Tour through Barebox – Basic hardware initialization (SDRAM, clocks), Startup, User Interface, Start operating system, Update and Initial hardware bring-up.
  • Devicetree support
  • Multi-platform Bootloader
  • Barebox live demo on Freescale i.MX53 LOCO


You can also download the slides for this presentation.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on DotNetKicks.com
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

Upgrading Embedded Linux Without Bricking – ELCE 2012

January 16th, 2013 No comments

Arnout Vandecappelle, senior embedded software architect at Essensium/Mind, talks about ways to greatly decrease the risk of bricking your board/device during upgrade thanks to gubies scripts and tools at the Embedded Linux Conference in Barcelona, Spain, on November 6, 2012.

Abtract:

Embedded systems are often modified remotely, e.g. to upgrade the firmware or change the configuration. This may however break the system and render it inaccessible, which is a major problem if the device is hard to reach physically. Unfortunately, no catch-all failsafe solution exists to make sure that the device stays accessible remotely even if a modification goes wrong. Instead, the possible failures have to be anticipated and covered. This talk discusses some of the frequently occurring failures, how they can be detected and handled. These include power failure, kernel crashes, network failure and data corruption. We include examples of concrete use cases. Finally, there is room for discussion about possible alternative or more generic solutions than the ones proposed.

This talk is geared towards system architects and developers who want to improve the quality of their product.

firmware upgrade flash partitions

  1. Failure mechanisms
    • Power failure during firmware update. Solutions:
      • Add fail-safe firmware
      • Detect failed power
      • Atomic update of firmware images
      • Use journalling filesystem for writable data
    • Bad firmware. Solutions:
      • Fall back on previous (known good) firmware
      • Fail-safe firmware that can do upgrades
      • Upgrade script included in upgrade image
      • Watchdog reboot + boot fail-safe after bad boot
    • Communication errors. Solution: verify data before writing (e.g. GnuGP). If memory is lacking to store the full firmware before upgrade, split in chunks for streaming upgrade
  2. Boot loader upgrade

    • if boot loader is broken, no recovery is possible =>  avoid bugs and features in the bootloader.
    • Upgrade of boot loader with (bootable) backup media
  3. Package-based upgrade

    • Advantage – results in smaller upgrade files
    • Drawbacks – Difficult to predict what is installed exactly, more places where something can go wrong, and no package manager is truly atomic (but nixos package manager comes close).

You can download the slides for this presentation, as well as checkout gupies (Generic UPgrade Infrastructure for Embedded Systems), a set of set of scripts and source code that can be used for upgrading the firmware of embedded systems maintained by Arnout.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on DotNetKicks.com
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

The End of Embedded Linux (As We Know It) – ELCE 2012

January 16th, 2013 5 comments

Chris Simmonds, freelance consultant and trainer (2net ltd), discusses the future of embedded Linux now that storage and processing power are no longer an major issue, and try to find the best Linux platform for embedded systems at ELCE 2012.

Abstract:

Embedded Linux is at a cross roads where the combination of Moore’s law making devices more powerful and the mass production of consumer devices, especially mobile, making them cheaper means that the old ways no longer work. Only a few years ago we though in mega: MHz, MBytes, MBits/s. Now we have to think in giga. The days of the single core CPU are almost over, as are the days of the QVGA display.

All this means that there is a need to re-think how embedded devices are programmed. Two obvious roads lie ahead: Android and Ubuntu (or other desktop operating system of your choice). This talk considers the possibilities and challenges in following either route, and considers how embedded engineers can make the best choices for future projects.

Where is Embedded Linux Headed? Mainstream distro, embedded Linux distro or Android?

Where is Embedded Linux Headed? Mainstream distro, embedded Linux distro, or Android?

Chris talk is structured as follows:

  • Overview
  • Evolution of embedded hardware
    • 10 years ago: 80 MHz MCU, 16 MB RAM, 8 MB NOR flash. Price: $500
    • Today: dual core @ 1.2 GHz, 1GB RAM, 4GB (and more) SD card  (Pandaboard). Price: $160
  • Cost of hardware – The Beagleboard started the low-cost board revolution
  • Embedded Linux past
    • Low RAM, clock speed, and amount of storage.  Headless, or simple user interface from keypad or touch screen.
    • Lots of specific tools – Cross toolchain, uClibc, busbox, read-only file systems, lots of custom BSP…
  • Embedded Linux now and the future
    • Clock speed, RAM and storage no longer an issue (less need for busybox, uClibc and small rootfs)
    • Storage move from flash to eMMC and SD card (reduced need for jffs2)
  • New problems: Complexity, user interface, maintainability and skill level.
  • My ideal embedded Linux OS – Multi-platform fully open source OS with good board support, minimal rootfs availability, reduce writes to storage, proper logging, remote upgrade,  good debugging tools and long term support.
  • Options – Choice between Mainstream Distro (e.g. Ubuntu, Debian, Fedora), Embedded Linux (e.g. Open Embedded, Yocto) and Android. He compares those 3 choices according to the criteria mentioned above.
  • Android is the winner? – Android barely won the contest, but it is monolithic, inflexible,  not a community project, and only good for devices that look like smartphones and tablets.
  • Conclusion – Future devices will take more from mainstream distros, but there’s more work to do, and there is always Android for some kind of devices

The presentation slides are available for download.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on DotNetKicks.com
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

FFSB and IOzone: File System Benchmarking Tools, Features and Internals – ELCE 2012

January 16th, 2013 No comments

Keshava Munegowda and Sourav Poddar, software engineers at Texas Instruments, give a presentation about 2 relatively new file system benchmarks: The Flexible Filesystem Benchmark (FFSB ) and IOzone at the Embedded Linux Conference Europe 2012.

Abstract:

The IOzone is widely used File System Bench-marking tool in both linux and windows systems. The Flexible Filesystem Benchmark (FFSB) is a new cross-platform file-system performance measurement tool. It uses custom profiles as input to measure multiple file systems read/write performances. This paper identifies and compares these file system benchmarking tools in terms of the optimal usage techniques such as buffer size, number of threads, number of write blocks etc. Internals and features of these tools , and the necessary steps involved in the porting of benchmarking tools to different platforms are also discussed. The depicted file system benchmarking performance numbers, in this paper, are measured in both x86 PCs and ARM based SOC platforms.The audience for this presentation are the System Architects and Software Developers working on file systems,storage device drivers and Bench-marking tools.

IOzone and FFSB Benchmark Results on Intel Core i7 PC running Linux 3.2

IOzone and FFSB Benchnmark Results on Intel Core i7 PC running Linux 3.2

Agenda of the talk:

  • FFSB overview
  • FFSB profile files
  • FFSB internals
  • IOzone overview
  • IOzone internals
  • Porting of FFSB to ARM based platforms
  • Porting of IOzone to ARM based platforms
  • Example Results
  • FFSB v/s Iozone Summary
  • References

You can download the slides for this presentation, and download IOZone and/or FFSB to give it a try.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on DotNetKicks.com
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

Understanding PREEMPT_RT (The Real-Time Patch) – ELCE 2012

January 16th, 2013 No comments

Steven Rostedt, working at Red Hat, talks about Real-Time Linux at the Embedded Linux Conference Europe, in Spain on November 6, 2012.

Abstract:

The real-time patch (which provides CONFIG_PREEMPT_RT), has been around since 2005. Started by Ingo Molnar and maintained by Thomas Gleixner and several others, it has grown from a hobby RTOS into a very serious contender. Several distributions (Red Hat, SuSE, Debian, Ubuntu) supply a kernel version that includes this patch. The embedded world has started adding the -rt patch to their own devices that they ship. But do the embedded developers understand what the -rt patch supplies? Programming for real time, and especially when writing kernel code requires special knowledge to avoid real time traps. This talk will explain what the real time patch provides and special programming tips that will ensure embedded developers will get the best from their devices.

Real-Time Linux Option in Make menuconfig: "Fully Preempt Linux Kernel (RT)"

Real-Time Linux Option in Make menuconfig: “Fully Preemptible Kernel (RT)”

He goes through the following key points during the presentation:

  • Real-time OS definition – Deterministic, does not mean fast (but still nice), meet deadlines.
  • Goal of PREEMP_RT – 100% Preemptible kernel and quick reaction
  • Different levels of preemption in Linux:
    • No preemption – Do as most possible with as little scheduling overhead. Use for server in Linux 2.4
    • Voluntary preemption – Schedule only at “preemption points”
    • Preemptible Kernel – CONFIG_PREEMPT. Preempt anywhere except within spin_locks
    • Preemptible Kernel (Basic RT) – For debugging, it will most probably go away…
    • Fully Preemptible Kernel – PREEMPT_RT_FULL. Preempts everywhere except from preempt_disable and interrupts disabled.
  • Details of PREEMPT_RT in the Linux kernel – priorities, spin_locks, interrupts, threaded interrupts, etc…

You can also download the slides for this tutorial/presentation. You may also want to access the source code via the Git repo, or get the PREEMPT_RT patches at http://www.kernel.org/pub/linux/kernel/projects/rt/. Full details cane be found on the Real-Time Linux Wiki.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on DotNetKicks.com
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter

Board Bringup: You, Me, and I2C – ELCE 2012

January 16th, 2013 No comments

David Anders, embedded systems developer at Texas Instruments, explains how to work with I2C in Linux based embedded systems at ELCE 2012.

Abstract:

Board bring up is one of the most under documented aspects of embedded development. I2C is such a powerful, low-cost, and ubiquitous method of communication, that a basic understanding of it’s usage is essential to the embedded linux developer to quickly bring up and debug embedded designs. This presentation will look at the various software and hardware aspects of working with I2C using simple case studies highlighting the implementation of an EEPROM and a GPIO Expander. Most embedded Linux developers at some point in their career will be handed a piece of hardware that is untested. This presentation intends to provide some information about core tools and methods for bring up of I2C interfaces and assorted I2C based peripheral devices. David Anders has previously presented at Embedded Linux Conference 2012 with “Board Bringup: LCD and Display Interfaces“.

I2C_Connection_Example

The talk is divided into 3 main parts:

  • Communication Principles – Asynchronous (e.g. RS232) and Synchronous (e.g. I2C) communication
  • Drivers and Software Tools – Bootloaders & Linux kernel  GPIO bit-bang & I2C chardev, and I2C tools (i2cdetect, i2cdump,. i2cget, i2cset)
  • Board Bringup Use Cases:
    • I2C GPIO expanders
    • I2C EEPROMs

You can also download the slides for this presentation.

Digg This
Reddit This
Stumble Now!
Buzz This
Vote on DZone
Share on Facebook
Bookmark this on Delicious
Kick It on DotNetKicks.com
Share on LinkedIn
Bookmark this on Technorati
Post on Twitter