E-ALE talk proposals

We have 2 upcoming LF Embedded Linux conferences at which we will be running an E-ALE track (though possibly under a different name, it will be the same format as always).

  • ELC (CFP closes Apr 2)
  • ELCE (CFP closes July 1)

We will be using the LF “Call For Papers”, so we ideally need you all to submit 1-3 proposals for both conferences (or whichever conference you plan to attend) so that we have lots to choose from. This allows you to have more control over your own headshots, bios, and such, and allows for us to more directly integrate into the wider conference.

     You can choose how you want to propose topics:

    1. You may propose your own beginner/apprentice level talk which covers one simple topic which you feel will add to the ALE curriculum and work within the ALE format of 30-45 mins of lecture and the remaining time in the 90 min slot spent on hands-on labs.
    2. You can pick from one or more of the topics below. You can choose to update the existing talk and give it again (please allow the original authors first right of refusal to do so, however)

    We are happy for you to propose the same talk at both conferences. Our attendees typically are new every year so repeating a talk isn’t an issue.

    We’re also happy for people to build upon the work of others. All the material is CC-BY-SA4 in order that everyone may do so. Please acknowledge the people who have come before you in giving the talk.

    We will be using a slightly different HW kit using the TechLab instead of the BaconBits board. The TechLab is mostly a superset of the BaconBits functionality so many things will remain the same. Certainly the TechLab acknowledges that it is a follow-on design to the BaconBits.

    Please Note that the first CFP deadline is Apr 2 for ELC!

    You can make CFP submissions for both conferences here.

    Proposed talks and abstracts

    Title Abstract
    Building an SPI Driver

    A tour of the Linux SPI subsystem. Provides a brief overview of the SPI protocol and examples of devices that use it. The Linux SPI driver subsystem will then we explored explaining the various pieces including host controller and device drivers as well as the devicetree bindings and various userspace interfaces.

    Building Real-Time Applications for Linux

    When building real-time applications, it is critical that latency is controlled. On a general purpose operating system such as Linux, there are many things happening “under the hood” that can dramatically affect latencies within applications. However, Linux does provide interfaces to control and monitor the latencies of an application. In this session, John Ogness will cover the various sources of latency, show which APIs a real-time developer can (and should!) use to avoid them, and present mechanisms to verify the controlled latencies of an application.

    Debugging embedded devices using GDB

    Bugs happen. Identifying and fixing them is part of the development process. This tutorial demonstrates one of the key tools in the embedded Linux developer’s toolbox: the GNU Debugger, GDB.

    You will begin by using GDB to debug a program running on a target device. You will learn about debug symbols, how to launch a program on the target using the GDB proxy agent, gdbserver, and how to set up communication between GDB and gdbserver. Then, you will be able to perform basic debugging tasks, including setting breakpoints, stepping through code, examining variables and modifying variables. After that, you will learn about GDB command files and how they can help you by automating certain tasks. You will receive a handy GDB cribsheet to help you with all of this. If time allows, we will discuss how to use GDB to analyze core dumps so that you can perform a post-mortem on a crashed program.

    Everything you ever wanted to know about libusb

    The Linux kernel contains a complete subsystem for creating the device end of a USB connection. This means a capable embedded Linux system can look like a thumb drive, HID device, serial device, video device, audio device, or another type of device using a range of built-in drivers. It’s also possible to create custom drivers for moving data to and from custom devices. This presentation and hands-on lab will describe some of the basics of USB and then describe how to create USB devices using the Linux gadget subsystem and communicate with them from a host using libusb.

    GDB Debugging in Both User and Kernel Space

    Most developers know a little about the GDB debugger, but the majority do not understand all of GDB’s capabilities to help shorten the debug process. In this session, I’m hoping to highlight many of the capabilities of GDB that many developers have not used in the past.

    Getting Started with Buildroot

    Need to create simple and optimized Linux systems for your embedded devices? Tired of complicated tools? You should try Buildroot!

    In this tutorial, we will first introduce Buildroot, a popular embedded Linux build system, that allows you to build your own cross-compilation toolchain, Linux kernel and bootloader images, as well as root filesystem with your selection of user-space libraries and applications, all from an easy-to-use “menuconfig” interface.

    Introduction to GPIOs and libgpio

    A GPIO, or “General Purpose Input/Output” is a programmable digital pin which allows you to implement either input or output. They have no default behaviour but can be configured in a number of ways. They are often shared with other embedded buses which further requires you to choose how you want to use the pin at any particular time. This class will cover using libgpio and using GPIOs from userspace.

    Introduction to I2C and I2Cdev

    I2C was initially invented by Philips as a simple 2-wire low-speed communications interface between CPUs and simple peripherals. Used primarily in embedded systems to connect things like I/O devices, it is now used, under various names, by most IC manufacturers on many System-on-chips. This seminar will introduce I2C and the I2Cdev API which allows you to write I2C drivers from userspace in Linux.

    Introduction to IIO and Input Drivers

    This tutorial will briefly introduce the Linux IIO and Input subsystems to students. The focus of the tutorial will be a guided hands-on lab where the students write a new driver that leverages the IIO and Input kernel subsystems. The lab will be conducted using the E-ALE hardware kit.

    Introduction to IIO and Input Drivers

    This tutorial will briefly introduce the Linux IIO and Input subsystems to students. The focus of the tutorial will be a guided hands-on lab where the students write a new driver that leverages the IIO and Input kernel subsystems. The lab will be conducted using the E-ALE hardware kit.

    Introduction to Kernel Modules and Kbuild

    Many people find the Linux kernel overwhelming place, and don’t know where to start. This seminar will introduce the kernel Kbuild system, one which has been copied into most other Embedded code bases in order to handle the configuration of features in the code. We will also cover how to build and install code as module into a running kernel.

    Introduction to Linux Kernel Driver Programming

    This tutorial will explain the Device Model, the mechanism that the Linux kernel offers to bind drivers to devices and to expose each device to userspace. Even though the way to detect or describe devices can depend on the bus or CPU architecture, the infrastructure binding devices with drivers are universal and therefore applies to all types of device drivers in the Linux kernel. Similarly, exposing devices to user space always follows the same philosophy.

    This tutorial won’t have practical labs but will be illustrated by studying several types of drivers, showing various ways of managing multiple devices in the same driver, and implementing the references between devices managed by a bus and devices that userspace sees.

    Introduction to Linux kernel driver programming: i2c drivers

    For people new to Linux kernel driver programming, writing a driver for an I2C device is a relatively easy way to start.

    This presentation will start by explaining the Device Model, the mechanism that the Linux kernel offers to bind drivers to devices. Even though the way to detect or describe devices can depend on the bus or CPU architecture, the infrastructure binding devices with drivers is universal and therefore applies to all types of device drivers in the Linux kernel.

    You will see how the driver uses one of the frameworks offered by the Linux kernel to expose device data to user space in a generic way. Once again, this type of mechanism is used everywhere in the Linux kernel.

    Introduction to SPI and SPIdev

    The SPI, or Serial Peripheral Interface is a protocol developed by Motorola which has become a defacto standard for short distance communication between CPU and peripherals. Although it can be called by several different names, it is a very common bus on embedded devices. This seminar will introduce SPI generally and SPIdev which is a Linux userspace API to write simple SPI drivers without having to write kernel code.

    Introduction to the U-Boot bootloader

    U-Boot is the universal bootloader used on a vast majority of embedded systems, development kits, products and so on. This session is an introduction into the U-Boot bootloader, including a hands-on part, and covers practical topics like identifying that the board is running U-Boot, accessing and exploring the U-Boot shell, including advanced scripting techniques to make life easier, obtaining information about the current hardware, accessing buses and storage and finally booting the kernel. Furthermore, since every embedded project has it’s unique set of requirements, U-Boot customization topics are briefly touched at the end of the session.