Ubuntu Founder Mark Shuttleworth will talk about how Ubuntu is advancing the user experience both on the desktop and in the cloud.
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 + weather station.
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.
This session explains how to extend DMTCP (Distributed Multi-Threaded CheckPointing) to implement Android checkpointing, which leads to resume to stored state for faster Android boot time and make better product field trial experience. However, it is not straightforward to apply any existing Linux checkpointing mechanism because of the unusual designs of Android. To make it work, Android specific facilities such as logger, ashmem, binder, and thread implementation, have to be manipulated. Expected audience: developers who want to know more techniques to speed up device development and introspect the low-level mechanisms in Android.
Since ARM started to use devicetrees, their impact on various subsystems in the kernel has been increasing significantly. Because they became the de-facto standard, everybody wants them soon. Because they need a ton of conversions and adaptions, a lot of questions are still unresolved. This carries potential for conflicts.Wolfram has dealt with devicetrees already on PowerPC and still does on ARM. Additionally, he co-maintains the I2C subsystem which is affected by devicetree conversions, too. Knowing both sides, as developer and as maintainer, he will talk about stumbling blocks experienced so far, e.g. typical pitfalls when inveting bindings or the high pace. A number of examples will be given with suggestions how to avoid common mistakes as well as confronting the audience with open questions to get a better idea of the underlying problems and what is still needed.
This talk will explain the lessons learned by giving a step-by-step introduction of porting Android to a custom board which was designed for an industrial environment.This includes an introduction to the Android build environment, first board bring-up and peripheral integration.The talk will cover bootloader integration, power management. It will focus on the peculiarities configuring Ethernet and Wi-Fi in Android. Also button and display integration, as well as integration of third-party accelerator support will be explained.
Android devices are getting popular not only in the mobile market but although in the industrial environment. Porting Android to a custom board can be challenging, especially as little information about Android internals are available.The talk is addressed to embedded developer and CTOs who regard the introduction of Android in the industrial field.
The widespread integration of USB into embedded applications presents many developers with the challenge of debugging problems, that are difficult to detect and isolate when a USB device misbehaves. This paper discusses about the various USB debugging techniques which includes debugging at the host PC, at the device and in the cable anddiscuss when each of the above techniques will be handy. This paper will also discuss about the various facilities provided within Linux kernel to aid in USB debugging e.g sysfs, trace points etc. and the various user space tools available to help USB debugging e.g USBMON. This paper also discusses about the profiling techniques at various levels in the usb stack.This paper will be of interest to the Software Developers and Testers who develop and debug USB drivers.
With the rise of the internet of things, low-power wireless devices will become increasingly prevalent. IEEE 802.15.4 is a wireless networking protocol designed for low-power and low-data-rate devices, such as those used in wireless sensor networks. While some higher layer protocols based on 802.15.4 are proprietary, an open standard called 6LoWPAN enables IPv6 traffic over 802.15.4. This presentation will give overviews of 802.15.4, its status in the Linux kernel, hardware support, comparison with other wireless protocols, and a demonstration of a simple 802.15.4/6loWPAN network.
This presentation is targeted toward developers who wish to create low-power, low-data-rate wireless networks for sensors or other applications. Attendees can expect to gain a basic understanding of 802.15.4 and 6loWPAN and also gain some ideas for use in their own systems. Technical expertise required is low.
This presentation will cover a brief introduction on how the Bluetooth LowEnergy technology works. Then it will present the current status of its supporton Linux, presenting the available APIs and how to interact with BluetoothSmart devices. Then we'll present the profiles we're currently working on andwhat support can be expected to be found on Linux and BlueZ this year. Therewill be also a few demos of Bluetooth Smart devices working on Linux. The audience of this talk is application or framework developers that want toadd support for Bluetooth Smart devices to their software, hardware vendors,and technology curious. Basic Bluetooth understanding is recommended but notrequired.
The presentation walks through how to use the OpenOCD open source software to debug embedded systems on the hardware level via JTAG interface, allowing single stepping, setting breakpoints, inspecting register and memory contents and more, starting before the CPU even executes the first instruction. After an introduction to JTAG debugging we look at how to use OpenOCD both standalone for firmware flashing as well as together with the GDB GNU Debugger for convenient debugging of bootloaders or the Linux kernel. These tasks will be demonstrated, and the respective OpenOCD configuration details will be explained.The presentation targets intermediate-level developers who work on bootloaders, BSPs and kernel drivers, deeply embedded systems, and test and production engineers with an interest in using OpenOCD, which can allow unified tooling across all of development, testing and production.
Traditionally, I/O devices have always been abstracted as characterdevices In that context we designed ZIO, an I/O framework capable ofsub-nanosecond time stamps, full meta-data delivery and symmetricalinput and output data flows. PF_ZIO is a new protocol family thatoffers a more flexible I/O framework than char devices, making localand remote devices look alike. PF_ZIO includes SOCK_RAW, SOCK_DGRAMand SOCK_STREAM, and supports sniffing for monitoring purposes. Withit, a single file descriptor can convey data blocks from and to anynumber of peripherals. While ZIO is already in use within some CERNdevices, PF_ZIO is not yet used in production, but the code is verypromising.
The intended audience is developers and researchers in the industrial area,especially those who design the hardware or the drivers. No previousexposure to ZIO is needed.
Recent mobile devices adopt various flash storages as a primary storage. File system support for those flash storages is a must for flash device performance and lifespan.I will present a new file system, called F2FS, designed for mobile flash storages. F2FS is designed considering the characteristics of the underlying flash storage which has flash translation layer (FTL). F2FS outperforms EXT4, which is a popular file system for Android phones, in most of benchmarks. I will describe motivation, design, and implementation of the file system, then show performance comparison data with EXT4. Target audiences are those who are interested in file system support for flash storages such as eMMC and SSD. Kernel and file system expertise helps but is not mandatory to listen to this talk.
A common problem faced when embedding Linux is the long boot time before the system is functional. There are many ways to improve boot up time. For a particular project, we had to answer a CAN message from Linux userspace in less than 420 ms from going out of CPU reset. We will describe our methodology and the techniques we finally chose to implement in that particular use case. We will also detail how we measured the boot time efficiently. A live demo will show the results of our work.
Porting Linux to new ARM based application processors has recently become easier than ever: the kernel gained many new frameworks like common-clock, oftree and pinmux. However, things get complicated when it comes to high end embedded graphics units.Those graphics systems tend to be composed of a multitude of on-SoC functional blocks that can operate on shared graphics buffers and video signals, as well as off-SoC encoder/converter chips that can be mixed and matched with any SoC.The old framebuffer is certainly not enough for today's hardware any more, while modern frameworks like KMS and DRM have their own hassles on non-PC style graphics systems.The talk outlines issues we found while working on graphics and video support for the MX53 and MX6 CPUs and gives suggestions for possible future improvements.This presentation is aimed at developers interested in the linux graphics stack.
Android is a very complex stack comprising several dozens of novel components and moving parts. Still, it's intrinsically a user-centric system and, therefore, its parts which deal with user interface are of special interest for anyone aiming to put Android in a device. This talk will examine the internals of Android's user-facing components. Specifically, we will cover the inner-workings and interactions of the Window Manager, Surface Flinger, Input Method Manager, and the rest of the system. We will also cover key display and input components such as the Status Bar, Soft Keyboard and Notifications.
This talk will be especially useful to developers intending to use Android in user-facing embedded systems, those needing to implement support for their graphics hardware and anyone interested in the internals of Android's graphics and input layers.
Linux recently gained support for NFC (Neard Field Communication), and this presentation will describe the status of the current NFC stack in terms of actual features, hardware support and also distribution availability.After showing how this stack is architectured, we will also explain what our long and short term plans are.
NFC hardware is typically found on mobile devices, many of them running Linux or Android. Up until recently, only Android provided a real and viable software support for those chipsets. During this presentation I will show how the Linux NFC stack is now getting on par with the Android stack features and API wise and how its design allows for an already broader range of supported chipsets.
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.
Abstract coming soon.
The Linux kernel is at the core of any Linux system; the performance and capabilities of the kernel will, in the end, place an upper bound on what the system as a whole can do. This talk will review recent events in the kernel development community, discuss the current state of the kernel and the challenges it faces, and look forward to how the kernel may address those challenges. Attendees of any technical ability should gain a better understanding of how the kernel got to its current state and what can be expected in the near future.
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.
This is a discussion of how to get software started without dependence on hardware. In the world of embedded software, we are very dependent on the hardware whether standard or custom to start low-level and hardware dependent software work. There are a number of emerging technologies that are being used to get this work started in a reliable and controllable way. This BoF is a discussion of simulation and prototyping technologies such as QEMU, Virtual Prototyping and others and the pros and cons of using them. Attendees are invited to share their case studies, what has worked for them and make suggestions on what is needed to make this technology more usable by software developers. The BoFs will start with a short introduction and overview of state-of-the-art simulation/prototyping solutions, followed by an interactive discussion. You're invited to bring and show your favorite simulated embedded system!
Some particular embedded platforms require to boot and be functionnal quickly. One way to achieve that is to spend less time in the bootloader. We started to write some architecture specific bootloaders. We'd like to create a repository for that kind of bootloaders and to start the discussion about what kind of initializations needs to be added to the kernel. Are you ready to jump on board ?
Hear from Matt Locke, the Director of the Linux Developer Center at Texas Instruments (TI) on the future of embedded SoCs.
Booting Linux is still a hot topic on embedded systems. It has been 3years since the last presentation about Barebox at ELC-E, and thebarebox community has grown and developed many new and unique featuresduring 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.
The presentation is for kernel porters who need a robust, flexible,extensible and well structured tool to bring up Linux on embeddedhardware. It is equally suitable for new and experienced barebox users.
Today's talk will introduce Android's networking and connectivty layer and its fundamental changes toward legacy Linux. Through a quick overview of its internals and how wireless connections (Radio, WiFi, Bluetooth, NFC) are handled, the presentation will enlight a particular use case as how to bring support for wired connectivity. Designed for handled devices, Android lacks complete support for proper Ethernet management. Things go even worse when you bring enterprise requirements into play by adding proxy, security and authentication support. Presented as a series of tips and tricks, this presentation will introduce all AOSP hacks that were required to bring such feature to life.
This talk will discuss the experiences of being introduced to open source and Linux, the difficulties that were met when introducing open source to a company and how to apply it to projects. The audience does not need high level of technical expertise. This presentation is aimed at developers generally from the embedded industry to share insights in working with Linux and open source, UI frameworks and community developers in the hope it may help others. Anybody who has interest in open source projects, Linux, UI frameworks or the mobile sector should be interested.
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.
Embedded Linux is at a cross roads where the combination of More'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.
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.
Multi-core processors have become mainstream in mobile devices. However, many multi-core devices are not used to their full capacity, which is probably why so far no vendor is building octa-core cell phones. Creating multithreaded applications from start is hard because updating program state from parallel threads is highly dangerous: race conditions and timing dependencies will prove to be hard-to-find errors. Parallelizing singlethreaded applications is hard, too, because it is often unclear from start whether it can actually succeed and yield the expected speedups.In the Android case, the programmer’s insight is complicated by the dual Java/C language organization.
Klaas will show some example Android code and slowly turn it into a multithreaded application, highlighting most of the issues C or C++ developers will run into along the way, including data and functional partitioning.
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".
Monitoring and controlling charging from software gives more flexibility in battery charging. The battery properties will vary from battery to battery. By using software methods, the charging algorithm can be selected based on the battery properties and the charging phase. The concept of Linux charging subsystem is to enhance the existing Linux Power Supply subsystem to give more flexibility in charging. This framework will introduce features to identify battery, read battery profile, support pluggable charging algorithms and select algorithms based on charger and battery properties. The solution will connect different components in the Linux Subsystem (Power Supply, Extcon, Thermal) to give a generic charging solution. This paper describes the features of the charger framework and how this will improve the existing charging solution.
I present an innovation approach to a RADAR technology without FPGA. Newer ARM microcontrollers and Linux systems have enough powerful computing that allows to gain access to fields of huge processing applications.This presentation is a practical of FMCW RADAR device implemented on standard ARM Cortex-A8 1GHz, SPI ADC and Linux.We have real-time constraints in FFT signal processing speed, so we use Linaro tools to generate better optimized code for ARM and NEON coprocessor.Moreover, we try to use hardware capabilities for parallel processing on DSP core, Linux driver with DMA support and threads.At last, we use HTML5 AJAX real-time data visualization. This way we reduce the payload needed in the embedded RADAR device. It moves that heavy task to remote HTML5 web browser. Presentation includes a brief walk through of the technologies used. It's a big step in terms of energy saving.
This session follows the development of a 6502-based computer implemented as a remote processor to a Linux-based system. The system consists of a complete 6502 microprocessor subsystem which is interfaced with a BeagleBone running Linux. The Linux system implements a standard remoteproc subsystem driver to allow complete control of the 6502 processor from Linux. With this configuration it is possible to host development of applications on the processor running Linux, load them directly on the 6502 coprocessor, and handle messaging between Linux and 6502-based applications.
The target audience is embedded software developers, Linux kernel hackers, and retro-computing hobbyists. Basic knowledge of microprocessor interfacing, C, and Linux kernel fundamentals is necessary to understand the presentation.
Since Linus Torvalds raised warnings about the state of the ARM architecture support in the Linux kernel, a huge amount of effort and reorganization has happened in the way Linux supports ARM SoCs. From the addition of the device tree to the pinctrl subsystem, from the new clock framework to the new rules in code organization and design, the changes have been significant over the last one and half year in theARM Linux kernel world.
Based on the speaker's experience on getting the support for the new Marvell Armada 370 and Armada XP SoC support in the mainline Linux kernel, we will give an overview of those changes and summarize the new rules for ARM Linux support. We aim at helping developers willing to add suppot for new ARM SoCs in the Linux kernel by providing a check-list of things to do.
In such an intensely engineering focused environment, the usual answer is “No, it’s the code value that makes or breaks a project”. And while most open source projects start out with ‘an itch to scratch’ and with great enthusiasm many soon fizzle as no one seems to know about the project, nor get involved. The maintainer bears the burden of contribution, communication, community and fund raising. This session will cover some best practices for marketing, yes marketing open source projects (working with or without corporate backing and community managers), and the key differences between open source marketing and regular corporate product marketing.
No experience necessary. For anyone interested in learning appropriate marketing strategies used by open source projects to attract developers and users.
For well over 10 years, Qt has been used in many types of embedded devices, ranging from high-end medical systems, through mobile phones and smartphones, all the way to simple devices like coffee makers. This presentation will show some of the work that has been put in Qt throughout the years to support embedded devices, some of the challenges that the development team faced in order to bring a fully-featured desktop toolkit to resource-limited devices, along with solutions they came up with. Time permitting, the presenter will also show Qt demos running on an embedded device.
This session is intended for embedded application developers looking to make use of the capabilities of recent hardware, as well as decision makers looking for technology to enable their product solutions. The presenter is the Qt Chief Maintainer, having worked on and off embedded device development for a decade.
Devicetree is marketed as the one ring to rule them all when it comes to non-discoverable hardware for linux on ARM. The problem with devicetree is that the complexity gets removed from the kernel and put into the bootloader.
Android does not only meet the taste of end-users, but also provides a comfortable home for programmers that feels very different to traditional embedded Linux. Unfortunately, the Android stack and app model does not account for real-time requirements, although they are needed in an ever-growing number of scenarios. To combine the benefits of both realms, we have created a real-time capable Android solution (Àndroit). We present the resulting software architecture, and discuss how we augmentedthe Android stack with RT capabilites. We report on our experience with integrating the Android and preempt_rt kernel patches, highlight the benefits for engineers, end users, and in hardware consolidation, and share how the advantages of Android can be extended to scenarios not covered by the standard architecture. A practical demonstration of real-time Android rounds thingsoff.
Eclipse has become the standard base for commercial Embedded Linux IDEs. The key components in these IDEs are the C/C++ Development Tooling (CDT) and Target Management(TM). We will look into new and noteworthy features in the latest 4.2 Eclipse release as well as current limitations for cross development. Using live examples, we will discuss creating a completely open source IDE for embedded Linux development from components and features of the CDT, TM, and Linux Tools projects.
The presentation is aimed at embedded Linux developers who are interested in using Eclipse as their IDE as well as cross tools integrators.
The Yocto Project is a joint project to unify the world's efforts around embedded Linux and to make Linux the best choice for embedded designs. The Yocto Project is an open source starting point for embedded Linux development which contains tools, templates, methods and actual working code to get started with an embedded device project. In addition, the Yocto Project includes Eclipse plug-ins to assist the developer. This talk gives a walk-through of the key parts of the Yocto Project for developing embedded Linux projects. In addition, features will be described from the latest release of the Yocto Project, v1.3. The talk will include demos of some of the key new features such as the Build Appliance and Hob.
At the end of the talk, developers should be able to start their own embedded project using the Yocto Project and use it for developing the next great embedded device.
Linux creator Linus Torvalds will take the stage with Intel’s Chief Linux and Open Source Technologies Dirk Hohndel to discuss the latest technical advancements in the kernel.
The first Linux port for the ARC processor family was done in 2006. From the initial frustrating/fun days of stabilising it (hunting ‘random’ segfaults), it now is a mature solution deployed in many products. System wide improvements over time include software (kernel and uClibc), tool-chain (gcc toggles, new builtins/peepholes), and new hardware features. The current step in evolution is to get it mainlined into kernel.org.
This presentation shares technical challenges and solutions pertaining to ARC kernel Port, and explains the main optimisations that have been done (for ARC, but many can be/are applied to other architectures as well). Finally, we discuss the mainlining effort including the upfront home work and well received assistance of Linux Foundation in the process. The talk will be interesting for any Linux kernel developer who wants to learn about architecture/kernel details.
The Linux kernel offers three APIs to display video and graphics. While DRM/KMS, FB and V4L2 started as solutions to distinct problems, they now largely overlap. Despite several efforts being led to consolidate those interfaces, too many developers are still lost when they need to deal with video and graphics display.
This talk will present the current state of DRM/KMS, FB and V4L2, outline their respective use cases and guide developers in the API selection process. It targets kernel and userspace developers who write drivers and applications dealing with video and graphics in the embedded world.
Visualization can be a valuable tool for analysing and understanding data (and the ""reality"" that we are trying to measure). It can be much richer than numeric metrics, providing valuable insights. It can also distort, camouflage, or hide information. This talk will provide some real-life examples of how to use and mis-use visualization.
This talk is relevant to everyone and does not assume any technical expertise.
The time has come - there is ARM 64-bit architecture right behind a corner. In this talk I will present how OpenEmbedded was used to build root filesystem for fast models simmulating not-yet-existing hardware. Presentation is targeted at developers interested in cross compilation, handling new architectures in existing projects.
Software complexity in CE products increased a lot while time to market becomes shorter. This resulted in more software crashes happening during QA testing and when the product is in the market.The presentation will explain how in TPVision products (Philips TV's) we have addressed this by developing diagnostic tools to enable fast and easy analysis of software crashes. Elements which will be presented:
The presentation will contain both standard linux infrastructure which is used and where we have extended this with proprietary solutions.
Register I/O is a very basic feature which drivers on many OSs, including Linux, have typically implemented without much code or difficulty yet Linux has a relatively large subsystem for register I/O called regmap. This talk covers the evolution of the subsystem and its uses, introducing the subsystem itself and also providing a case study in the process and benefits of abstracting code out and then building on those abstractions to help make development more productive.
This talk is intended for a general programming audience at both engineering and management level. Some familiarity with hardware will be useful but is not required.
Video4Linux is a fast-changing subsystem where a lot of work is done to supportthe complex video hardware of embedded systems. This presentation will give anoverview of the developments in the past year and the work that is planned for the near future.
The complexity of a complete Linux stack has grown to considerabledimensions. Finding and fixing bugs is a most complicated undertaking,especially for system engineers whose focus is not solely on advancingthe Linux kernel. We discuss modern techniques for kernel/systemdebugging and analysis, with a special emphasis on using the benefitsof virtualisation. We introduce all components of a kernel hacker'stoolbox of interest to a wide range of engineers, including effectiveuse of tracing/profiling and revision control. Nifty, but oftenlittle-known system level tools for tracking down issues will behighlighted. Practical real-world examples show patterns for solvingcommonly appearing problems.
Besides system engineers, the tutorial will also be beneficial forprogrammers interacting with the lower Linux layers, and enthusiastsdesiring to understand their systems better.
The Yocto layers for In-Vehicle Infotainment, meta-ivi and meta-systemd, contain specific metadata to define tasks to build a baseline image, an ARMv7a QEMU machine definition, systemd specific distribution data sets, and the packages that make up a GENIVI compliant system.
This presentation gives an overview of the building block used by the GENIVI Alliance to create a software baseline that complies to its latest specification, which role The Yocto Project plays, what that project provides and what it gains.
The targeted audience for this presentations are Linux software developers, with little to no knowledge of The Yocto Project, but are interested in how The Yocto Project can help them and how she or he can contribute to The Yocto Project.
The presentation will talk about debugging various problems a kernel developer can face when working with power management. These include hardware related issues (IC / HW layout bugs, bad documentation) and software related (kernel bugs, driver problems, adding new kernel features, bad userspace behavior.) Along with presenting some of these problems, I will discuss about ways to debug these... power management typically requires specific tools to be used. I will base the discussion on my first hand experience from working with Linux PM. Target audience is (kernel) software developers interested in power management.
Booming usage of Linux in embedded environments is creating an on-going demand to use this general-purpose operating system in industrial control devices and other fields, previously reserved for classic real-time operating systems. Talk covers success story of Linux based embedded ARM system controlling weight dosing in injection-molding process (plastics industry). Practical, universal (applicable to most SoCs), open-source solution is presented: embedded Linux, process control application and responsive, QT based GUI. Emphasis is put on problems occurring and solutions: advantages and disadvantages of RT-PREEMPT and Xenomai from a practical point of view. Presentation includes latency measurement results and techniques.
The talk is intended for all interested in using Linux in in real-time applications. Knowledge of embedded Linux and kernel internals will be helpful.
Powering the DLNA-certified media sharing of the N9, Rygel was already deployed to a wide user base and well received. It has since then evolved from a simple media server into a DLNA framework. But rest is rust, ahead lie the challenges of the special requirements moden consumer electronics, be it TVs or home servers, confront us with. This presentation will show how those special needs have and will be addressed, giving access to this simple, robust and well tested DLNA framework.
Real-time system need to meet deadline. In this point of view, the system is required two functions to have determinism. One is interruptlatency stabilization and the other one is processing time reservation. The SCHED_DEADLINE has a feature to reserve CPU time in advance to ensure predictable behavior. In our evaluation, the granularity of CPU reservation is millisecond order.In this presentation, we show the evaluation results of current implementation to make clear the issue. Then we explain how to overcome this issue and its results.
LTSI (Long-Term Stable Initiative) had been established October 2011 as an activity of CE Working Group of The Linux Foundation. LTSI will maintain Linux kernel for long term and stable for use of Consumer Electronics industry to share common cost and also help industry engineers to merge their patches into upstream. This talk will update latest status of LTSI project and discuss about next step such as how the development process going on and what version of Linux kernel will be maintained for long term and stably use. This talk will be intended to provide information for managers and engineers in the embedded industry and not necessary to have specific knowledge.
UBI is a flash management layer in the Linux kernel designed to handle especially the shortcomings of NAND flash. UBI itself has the requirement to scan the full flash at boot time. With flash sizes becoming larger and larger this can take quite some time. A recent development implemented fast mapping functionality which is designed to put an upper bound on the number of flash eraseblocks to scan. This allows faster boot times without sacrifying the robustness of UBI. This talk gives an overview of the UBI fastmap design and looks at costs and benefits.
This session marks the end of a Linux conference in a city with a huge influence of art history.
Programming is also art, the conference will be full of talented people.
The Linux's got Talent show will be fun. Apart from the fact that we tend to hand out gifts and
thank the organization, we also host a game on stage that involves the audience and is fun
for everyone. You'll see that (Embedded) Linux programmers have many talents!