Embedded Linux Conference 2013

Decades of innovation have given us faster, safer, and more robust cars, but the most unreliable component sits behind the steering wheel. Across the world, over a million people lose their lives to traffic fatalities each year, with human error as the main culprit. Thanks to recent advances in processing, sensors, and digital maps, our cars will soon handle the driving for us. Building off of earlier research, Google has developed a fleet of self-driving vehicles which have driven themselves more than 400,000 miles in complex, real-world conditions. This technology gives us a driver who never gets tired or distracted and whose reflexes and memory surpass those of the average human driver, with more improvements to come. This talk will discuss the technology behind Google's self-driving cars, their capabilities, and the challenges ahead.

Embedded silicon options have become quite robust. 32-bit network-enabled “intelligent” systems are now the norm. This opens up countless opportunities for cool, new embedded devices, which are powerful and connected. But the state-of-the-art in embedded software development still emphasizes quick time-to-market versus elegance.  What keeps me awake at night are the risks introduced by mixing rushed programmers and powerful processors embedded everywhere. This talk will introduce some of the issues, and the Yocto Project tools that address them.

The author will discuss his ongoing and other team members efforts to develop hardware and software that reports sensor data to the community. This talk will be split into several parts a) types of useful sensors b) hardware design of Beaglebone capes c) and telemetry reports to Pachube/Cosm. Demonstrating that in the new world of cheap prototyping boards with I2C, GPIO, and SPI that anyone can setup a decent monitoring system for home security, automation, and weather reporting. There will be a live demo of prototype geiger counter + nixie display prototype. Also touched on will be how you can too produce a cape and write a Capebus driver for it.

The audience targeted is the professional hobbyist who likes to hack on microcontrollers in their spare time. It will take little to medium knowledge of electrical engineering to follow this talk

Cyclictest results are probably the most frequently cited Real-time Linux metric. The core concept of Cyclictest is very simple. However the test options are very extensive and complex. Also, the meaning of Cyclictest results are not simple. This talk will explore the complexities of Cyclictest.

This session is intended to sum up the last say 24 months of changes with the creation of the pin control system and the changes related to GPIO as well as changes to the GPIO subsystem per se. We will know about the systems migrated to pin control, how device tree is used, pin to GPIO range mappings from either end, block GPIO control and how we try to move forward.

BeagleBone, the newest tool in the BeagleBoard platform, is a low-cost credit-card-sized computer with plenty of I/O and processing power for real-time analysis provided by the TI Sitara(tm) AM335x ARM(r) Cortex(tm)-A8 processor. BeagleBone can be complemented with a wide range of "cape" plug-in boards which augment BeagleBone's functionality, as well as an experienced 5,000+ member community on BeagleBoard.org which provides projects, examples and support. Each of the four 50-minute hands-on tutorials with the BeagleBone will provide an introduction to the BeagleBone with emphasis on how to use the expansion header interfaces. The tutorials will include instruction on how to "breadboard" a LED, push button, and i2c based EEPROM along with and interact with them from Linux. Attendees will need to bring a laptop with a terminal application such as minicom(Linux) or teraterm(Windows).

The Yocto Project combines several, powerful tools and build metadata together to enable developers to create a custom Linux distribution from scratch. Additionally, it makes it easy for developers to carry customization work forward over time and makes it easier to port across architectures. In this presentation, we will take a look at how to use the Yocto Project to put together a customized distribution for your target of choice. Along the way, we will cover several common tasks and provide pointers about where to get more help. 

This talk is geared for individuals that are new to the Yocto Project, but not necessarily new to Linux.

The common clock framework, which was included in the 3.4 kernel in
the beginning of 2012, is now mandatory to support all new ARM
SoCs. It is also part of the "one zImage to run them all" big plan
of the ARM architecture in the Linux kernel.

After an introduction on why we needed this framework and on the
problems it solves, we will go through the implementation details of
this framework. Then, with real examples, we will focus on how to
use this framework to add clock support to a new ARM SoC. We will
also show how the device tree is used in this process.

The last part of the talk will review how device drivers use this
framework, using examples taken from various parts of the kernel.

This presentation will provide engineers with recommended strategies for gaining senior management approval of mainline Linux development. Often engineers struggle to clearly outline the advantages of mainline Linux development and to quantify the financial benefits to their organization’s bottom line while making the Linux mainline offering better and improving their respective projects. This presentation will help engineers more effectively communicate with less technical management and convey compelling arguments for mainline Linux development initiatives.
The target audience is any engineer seeking to begin mainline development within their organization. Kevin Chalmers has successfully used these strategies within TI to create a mainline development organization focused on upstream support for TI devices. He can share best practices and pitfalls in soliciting management approval.

BeagleBone, the newest tool in the BeagleBoard platform, is a low-cost credit-card-sized computer with plenty of I/O and processing power for real-time analysis provided by the TI Sitara(tm) AM335x ARM(r) Cortex(tm)-A8 processor. BeagleBone can be complemented with a wide range of "cape" plug-in boards which augment BeagleBone's functionality, as well as an experienced 5,000+ member community on BeagleBoard.org which provides projects, examples and support. Each of the four 50-minute hands-on tutorials with the BeagleBone will provide an introduction to the BeagleBone with emphasis on how to use the expansion header interfaces. The tutorials will include instruction on how to "breadboard" a LED, push button, and i2c based EEPROM along with and interact with them from Linux. Attendees will need to bring a laptop with a terminal application such as minicom(Linux) or teraterm(Windows).

As costs have come down and the power of embedded platforms has increased, the hacker/maker community is playing an increasingly critical role in the creation of disruptive technologies. The "Next Big Thing" will likely start out as a hacker project using a commodity embedded hardware platform. Intel's Atom-based offerings continue to grow while targeting new niches in embedded applications. This talk will outline exciting new developments with Atom processors in the embedded space, and how hackers can make best use of these advantages.

This talk will be relevant to hackers, hobbyists, and people interested in developing embedded products based on Atom, and is open to all technical experience levels.

BeagleBone, the newest tool in the BeagleBoard platform, is a low-cost credit-card-sized computer with plenty of I/O and processing power for real-time analysis provided by the TI Sitara(tm) AM335x ARM(r) Cortex(tm)-A8 processor. BeagleBone can be complemented with a wide range of "cape" plug-in boards which augment BeagleBone's functionality, as well as an experienced 5,000+ member community on BeagleBoard.org which provides projects, examples and support. Each of the four 50-minute hands-on tutorials with the BeagleBone will provide an introduction to the BeagleBone with emphasis on how to use the expansion header interfaces. The tutorials will include instruction on how to "breadboard" a LED, push button, and i2c based EEPROM along with and interact with them from Linux. Attendees will need to bring a laptop with a terminal application such as minicom(Linux) or teraterm(Windows).

There are huge number of embedded devices running Linux in the market and expanding rapidly. Industry is trying to provide latest and greatest products with rapid release cycles by using Linux. Using Linux means anyone can pick any kernel version but is that the best choice? Value of Open Source is not just free of choice but using common code can be able to share information and experience.
This talk will discuss about how to decide the kernel version and keep it maintain the Linux kernel by the view point of industry initiative LTSI (Long Term Support Initiative). Also, this talk will discuss about the common issue of the industry such as joining the community and how to solve it.
This talk will be intended to disucuss common issue of the embedded industry with managers and engineers and not necessary to have specific knowledge.

BeagleBone, the newest tool in the BeagleBoard platform, is a low-cost credit-card-sized computer with plenty of I/O and processing power for real-time analysis provided by the TI Sitara(tm) AM335x ARM(r) Cortex(tm)-A8 processor. BeagleBone can be complemented with a wide range of "cape" plug-in boards which augment BeagleBone's functionality, as well as an experienced 5,000+ member community on BeagleBoard.org which provides projects, examples and support. Each of the four 50-minute hands-on tutorials with the BeagleBone will provide an introduction to the BeagleBone with emphasis on how to use the expansion header interfaces. The tutorials will include instruction on how to "breadboard" a LED, push button, and i2c based EEPROM along with and interact with them from Linux. Attendees will need to bring a laptop with a terminal application such as minicom(Linux) or teraterm(Windows).

This BoF is an opportunity for LinuxCon attendees to meet and converse with developers working on the Yocto Project and OpenEmbedded. All are welcome, from newcomers to experienced developers with problems that need to be solved.

Developing software for launch vehicles and spacecraft presents some unique challenges, but it's not all rocket science.  This presentation will summarize some lessons we've learned developing software for space vehicles.

The legacy U-boot image format is quickly becoming outdated as multi-component images are quickly becoming necessary. Images now not only carry a kernel, but also a device tree blob, ramdisk image etc for instance. With the increasing importance of security, storing multiple signatures and certificates structures in an image are also becoming common. The struct image_header in the legacy U-boot image format is not flexible enough to cover all multi image formats. Components of a kernel boot image might have to be loaded into different parts of memory before booting. A new image format (Flattened Image tree) similar to FDT solves some these problems.

Audience is U-boot and Kernel developers who work on kernel boot and security boot. They can expect an introduction to FIT, its motivation, advantages with an example. Technical Expertise required is familiarity with kernel boot mechanisms.

Talk about existing available support for using external pre-built binary toolchains in the Yocto Project. What is provided and how to use it. What are the limitations - uncover and explain ways of overcoming those. Overview examples of existing implementations for using toolchains from CodeSourcery and Linaro, as well as adding support for new toolchains, such as from the Arago Project.

Provide the guideline for rolling own pre-built binary toolchain from the Yocto Project and tips for making it usable inside of the Yocto for building filesystem images and SDKs. As well as what's missing and how to enable re-packaging it in the resulting SDK, that can be fed back into the Yocto Project again, completing the circle.

Delve into Canadian-cross, associated pros and cons - benefits of self-contained binaries, "relocatability" issues and mixing canadian with regular cross binaries.

The LLVM project is an extensive compiler technology suite which is becoming commonplace in many industries. Technology built with LLVM is already shipped in millions of Linux devices as a part of Android/Renderscript. Increasingly it is becoming a big part of the development process for embedded projects, all the way up through to high performance computing clusters. This session will provide an update on the status of the LLVMLinux project; a project which is cooperating with both the Linux kernel and LLVM communities to build the Linux kernel with Clang/LLVM.

This talk is for experienced developers who are interested in toolchain technology and Linux Kernel programming.

Todayâ€'s small form factor devices are facing challenges on thermal dissipation aspect. In extreme use cases which stress the system, despite a good hardware design, ergonomic thermal limits are breached. Since in such devices active cooling (e.g., fan) is not feasible, we must look for passive thermal solution. The thermal solution needs to work beyond just CPU frequency throttling owing to the growing usecases which stress components like GPU, Modem etc. We are enhancing the existing Linux thermal framework, to achieve these. Apart from these aspects this talk will also cover the concept of "zones as virtual sensors"€™, differentiating trip points and thresholds, thermal governors, the need and modality to customize platform data etc. The target audience would be OEMs/developers who are trying to address thermal issues.

The yocto-autobuilder has been a critical part of the yocto projects ability to deliver predictable releases. However the ability for others to leverage this success has been difficult at times. This talk will introduce the new yocto-autobuilder architecture, the reasons behind the effort and introduce the new features (mix and match layer support, custom build steps, custom properties) and the projects plans for implementation.

The display subsystem of an SoC is really an (potentially) elaborate network of buses, devices, bridges, transmitters, and other entities. These entities are also potentially in use by both video and graphics output, making a framework to share them between the larger subsystems of the Linux kernel crucial both for keeping the lower layer drivers sane and maintainable and for making them useful to the higher layers. This Common Display Framework has already gone through a couple of revisions, as well as discussions at Linaro Connect and FOSDEM. We will continue this discussion at a birds-of-a-feather at ELC.

Performance is an important aspect when developing mobile applications as it affects both the interactive user experience and the device battery life. This presentation will introduce techniques and tools (e.g. profilers) useful for creating high-perfomance code starting at the high-level design stage (code organisation, data layout, etc.) and following through to implementation considerations. Specific instruction sets (e.g. NEON) will not be a primary focus, the goal rather being to enable efficient use of these without delving into details, thus giving the presentation a broader applicability.

The target audience is developers of compute-intensive (native) applications or libraries who need to achieve the best possible performance. No special expertise beyond general familiarity with userspace Linux programming is assumed.

The display subsystem of an SoC is really an (potentially) elaborate network of buses, devices, bridges, transmitters, and other entities. These entities are also potentially in use by both video and graphics output, making a framework to share them between the larger subsystems of the Linux kernel crucial both for keeping the lower layer drivers sane and maintainable and for making them useful to the higher layers. This Common Display Framework has already gone through a couple of revisions, as well as discussions at Linaro Connect and FOSDEM. We will continue this discussion at a birds-of-a-feather at ELC.

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".

The 'In Kernel Switcher' (IKS) is a solution developed by Linaro and ARM to support ARM’s new big.LITTLE implementation. It is pairing together an A7 (LITTLE) and an A15 (big) processor into a logical entity that is then presented to the kernel as one CPU. From there the solution is seeking to achieve optimal performance and power consumption by switching
between the big or the LITTLE core based on system usage.

This session will present the IKS solution. After giving an overview of the big.LITTLE processor we will present the solution itself, how frequencies are masqueraded to the cpufreq core, the steps involved in doing a “switch” between cores and some of the optimisation made to the interactive governor.

The session will conclude by presenting the results that we obtained as well as a brief overview of Linaro's upstreaming plan.

Enea has initiated and is co-maintaining a “Linux meta virtualization layer” within the Yocto environment. See http://git.yoctoproject.org/cgit/cgit.cgi/meta-virtualization/tree/README. The goal is to create a long/medium-term production ready layer for embedded virtualization. Specifically the program is: a) to collaboratively research/benchmark LxC/KVM virtualization combined with advanced core isolation techniques, and additionally b) for Enea  to integrate and contribute OpenFlow, OpenvSwitch, LxC, CRIU, dmtcp along with incremental contributions of OpenStack components. This presentation provides an overview of this exciting new Yocto project: goals, technical approach, and current status.

While Android has been created for mobile devices -- phones first and now tablets -- it can, nonetheless, be used as the basis of any touch-screen system, whether it be mobile or not. Essentially, Android is a custom-built embedded Linux distribution with a very elaborate and rich set of user-space abstractions, APIs, services and virtual machine. This one-day workshop is aimed at embedded developers wanting to build touch-based embedded systems using Android. It will cover Android from the ground up, enabling developers to get a firm hold on the components that make up Android and how they need to be adapted to an embedded system. Specifically, we will start by introducing Android's overall architecture and then proceed to peel Android's layer one-by-one. First, we will cover the Android Open Source Project (AOSP), the open source project under which Android's source code is released. We will then dig into the native Android user-space, Android's power tools, and cover how hardware support is implemented in Android. Given that Android is built on top of Linux, we will also go over some embedded Linux tricks and see how the kernel is modified to support the Android user-space. In addition, we will look at the System Server, the Android Framework and core Android applications, and how to customize them.

Always Innovating has announced a new product, the MeCam (www.alwaysinnovating.com/products/mecam.htm), a self video nano copter to point-and-shoot yourself. The MeCam launches from the palm of a hand and hovers instantly. This talk will review the lessons learned during the design of this product:
* hardware – CPU: the choice and the different trade-offs involved with this selection.
* hardware – sensors: the complete list of the 14 sensors, their advantages and drawbacks.
* software – core: the architecture of the Linux based system and the key challenges.
* software – stabilization algorithm: the experience during the tuning of the different algorithms
participating to the self hovering.
This talk targets developer with good expertise in both hardware and software. No deep knowledge in a specific field is mandatory but serious understanding of ARM and the Linux kernel is a plus.

Coverage is the standard measure for validation effectiveness. Although it has extensively been used in simulation, there is little data evaluating the on-chip coverage. This presentation will address this knowledge-gap. We employ code coverage, which is one of the most frequently used coverage technique in simulation, and apply it on-chip. Leveraging Linux, we instrument the code coverage over each of the IP cores. We can compare coverages between simulation directed tests and the on-chip Linux boot. The results in this work are valuable data for guidance to future research in coverage on-chip.
Target audience is firmware engineers and Linux developers who are interested in learning new and effective test techniques. Audience can expect to learn our technique and be a able to apply to their own design development kit. Level of technical expertise is medium (2-3 years of experience).

Asymmetric processing, spearheaded by ARM's big.LITTLE architecture, has been touted as a method for solving both the power & performance problem of mobile devices. This architecture requires changes to core scheduling concepts, which are extremely difficult to debug and diagnose, especially since existing tools do not capture useful data for evaluating such a system. A brief overview of the proposed scheduling changes will be presented, with major focus on Paul Turner's load average patches. Methods of simulating an asymmetric system will be described. Additionally a portable process workload capturing method, based on perf, will be presented, i.e. one can capture traces from an Android based system and run it on a standard Linux box.

The audience will comprise of kernel scheduler hackers, mobile device developers, and anyone interested in the challenges such a paradigm shift brings.

Summary of the proposal:
This talk describes the presenter's experience with using the Yocto Project, along with various open source layers, to build a digital signage solution from scratch. The presenter covers how various components are used from the oe-core, meta-web-kiosk, meta-security, meta-virtualization, and meta-nuc layers to get a working solution for digital signage. The talk provides a live demo of the solution, along with access to the source code & build environment.

Targeted Audience:
This talk is targeted to the open source development community. The audience can expect to get more knowledge about how they can build their own digital signage solution with the help of the Yocto Project and various open source layers.

The Linux Foundation's Yocto Project is a leading edge effort to greatly facilitate the creation of architecture independent embedded Linux distributions. The Foundation’s SPDX project is collaborative effort to define a standard format to describe and facilitate the exchange of key licensing information within a software supply chain. The union of these efforts delivers a level of license compliance support never available before for embedded Linux distributions and the devices they enable. We present our experience of integrating SPDX license information within the Yocto Project build system to illustrate some of the core benefits of both endeavors.

Computer security concepts are well known, there are many known exploits and ways to counter them, but most of the focus has been on IT systems (servers).
Computer security in consumer products is often left to the last minute, if it is implemented at all. In today's increasingly connected world, embedded systems can provide high value targets for hackers, criminal enterprises, and terrorists. Security for embedded computer systems can no longer be left to chance.

This talk starts with an overview of security concepts and terms, describes security modules available for Linux, provides some example exploits to provide context, and establishes best practices to ensure that security is built into your product from the start. The talk is appropriate for developers and managers interested in security, but no security experience is assumed.

While recent advances in SoCs have allowed for extremely small and low power mobile Linux devices, many of these advances are economically inaccessible for low volume devices. uCLinux provides a path for customized low volume devices while at the same time allowing reuse of IP in a full Linux device for future potential volume growth. This session will compare and contrast implementations of a uCLinux device with a Linux device from both software and hardware prospectives, including brief consideration of manufacturing consequences. Features, production volume, physical size, limitations of uCLinux and economy of the hardware will be looked at.

This session is for people looking to build or prototype a low volume custom mobile device. The take away from this is the economic viability of uCLinux as an alternative to full Linux. A basic understanding of embedded Linux is needed.

In parallel with Android Builders Summit we are offering special short course training. These courses are prepared by well-known Linux developers and provide a unique opportunity for colleagues to train together while attending the conference, in particular those developers and systems administrators who work with teammates located in different cities.

Building Embedded Linux with the Yocto Project Crash Course (LF404)

This two-day course is a condensed version of our full five-day class, LF405: Building Embedded Linux with Yocto. In order to save time, some sections of the full five-day course are abbreviated or skipped, depending on the needs and interests of the audience.

The Yocto Project is an open source collaboration project that provides templates, tools and methods to help you create custom Linux-based systems for embedded products regardless of the hardware architecture. The Yocto Project includes the Poky Build System as one of its components, which is a derivative of and is compatible with the OpenEmbedded Build System.

This course is designed to jump-start embedded development projects using the Yocto Project and to give software engineers a solid understanding of the build process from compilation over packaging to creating a bootable image. Upon mastering you will have a solid understanding of:

• The Poky and Bitbake build process with its recipies and layers to customize Linux kernel and packages for a custom embedded application
• Building Linux images for different profiles and across multiple architectures
• the use of emulators for verification
• the creation of board support packages (BSP) for their target hardware

You will step through all phases of embedded Linux development using the Yocto Project with laboratory exercises on an embedded target device to provide hands-on practice you can take directly to your projects.

For more details view the Course Outline.

To include Building Embedded Linux with the Yocto Project Crash Course (LF404) in your conference registration, select it as an add-on when you register.

In parallel with Android Builders Summit we are offering special short course training. These courses are prepared by well-known Linux developers and provide a unique opportunity for colleagues to train together while attending the conference, in particular those developers and systems administrators who work with teammates located in different cities.

Building Embedded Linux with the Yocto Project Crash Course (LF404)

 This two-day course is a condensed version of our full five-day class, LF405: Building Embedded Linux with Yocto. In order to save time, some sections of the full five-day course are abbreviated or skipped, depending on the needs and interests of the audience.

The Yocto Project is an open source collaboration project that provides templates, tools and methods to help you create custom Linux-based systems for embedded products regardless of the hardware architecture. The Yocto Project includes the Poky Build System as one of its components, which is a derivative of and is compatible with the OpenEmbedded Build System.

This course is designed to jump-start embedded development projects using the Yocto Project and to give software engineers a solid understanding of the build process from compilation over packaging to creating a bootable image. Upon mastering you will have a solid understanding of:

• The Poky and Bitbake build process with its recipies and layers to customize Linux kernel and packages for a custom embedded application
• Building Linux images for different profiles and across multiple architectures
• the use of emulators for verification
• the creation of board support packages (BSP) for their target hardware

You will step through all phases of embedded Linux development using the Yocto Project with laboratory exercises on an embedded target device to provide hands-on practice you can take directly to your projects.

For more details view the Course Outline.

To include Building Embedded Linux with the Yocto Project Crash Course (LF404) in your conference registration, select it as an add-on when you register.