Book Image

Embedded Linux Development Using Yocto Project Cookbook - Second Edition

By : Alex Gonzalez
Book Image

Embedded Linux Development Using Yocto Project Cookbook - Second Edition

By: Alex Gonzalez

Overview of this book

The Yocto Project has become the de facto distribution build framework for reliable and robust embedded systems with a reduced time to market.You'll get started by working on a build system where you set up Yocto, create a build directory, and learn how to debug it. Then, you'll explore everything about the BSP layer, from creating a custom layer to debugging device tree issues. In addition to this, you’ll learn how to add a new software layer, packages, data, scripts, and configuration files to your system. You will then cover topics based on application development, such as using the Software Development Kit and how to use the Yocto project in various development environments. Toward the end, you will learn how to debug, trace, and profile a running system. This second edition has been updated to include new content based on the latest Yocto release.

Related Content you might be interested in

Current Title:

Small book image
Embedded Linux Development Using Yocto Project Cookbook - Second Edition
Alex Gonzalez
Jan, 2018 | 456 pages
Small book image
Embedded Linux Development using Yocto Projects
Otavio Salvador | Daiane Angolini
Nov, 2017 | 162 pages
Small book image
Embedded Linux Development Using Yocto Project
Otavio Salvador | Daiane Angolini
Apr, 2023 | 196 pages
Small book image
Mastering Embedded Linux Programming
Frank Vasquez | Chris Simmonds
May, 2021 | 758 pages
Table of Contents (13 chapters)
Title Page
Title Page
Dedication
Dedication
Packt Upsell
Packt Upsell
Foreword
Foreword
Contributors
Contributors
Preface
Preface
Free Chapter
1
The Build System
The Build System
Introduction
Setting up the host system
Installing Poky
Creating a build directory
Building your first image
Explaining the NXP Yocto ecosystem
Installing support for NXP hardware
Building Wandboard images
Using the Toaster web interface
Running a Toaster Docker container
Configuring network booting for a development setup
Using Docker as a Yocto build system container
Sharing downloads
Sharing the shared state cache
Setting up a package feed
Using build history
Working with build statistics
Debugging the build system
2
The BSP Layer
The BSP Layer
Introduction
Creating a custom BSP layer
Adding a custom kernel and bootloader
Building the U-Boot bootloader
Describing Linux's build system
Configuring the Linux kernel
Building the Linux kernel
Building external kernel modules
Debugging the Linux kernel and modules
Debugging the Linux kernel booting process
Using the kernel function tracing system
Managing the device tree
Debugging device tree issues
3
The Software Layer
The Software Layer
Introduction
Exploring an image's contents
Adding a new software layer
Selecting a specific package version and provider
Adding supported packages
Adding new packages
Adding data, scripts, or configuration files
Managing users and groups
Using the sysvinit initialization manager
Using the systemd initialization manager
Installing package installation scripts
Reducing the Linux kernel image size
Reducing the root filesystem size
Memory-based root filesystems
Securing the root filesystem
Releasing software
Analyzing your system for compliance
Working with open source and proprietary code
4
Application Development
Application Development
Introduction
Introducing toolchains
Preparing an SDK
Using the extensible SDK
Using the Eclipse IDE
Developing GTK+ applications
Using the Qt Creator IDE
Developing Qt applications
Describing workflows for application development
Working with GNU make
Working with the GNU build system
Working with the CMake build system
Working with the SCons builder
Developing with libraries
Working with the Linux framebuffer
Using the X Windows system
Using Wayland
Adding a web browser application
Adding Python applications
Integrating the Open Java Development Kit
Integrating Java applications
Integrating Node.js applications
Running Docker application containers
5
Debugging, Tracing, and Profiling
Debugging, Tracing, and Profiling
Introduction
Analyzing core dumps
Native GDB debugging
Cross GDB debugging
Using strace for application debugging
Using the kernel's performance counters
Using static kernel tracing
Using dynamic kernel tracing
Using dynamic kernel events
Exploring Yocto's tracing and profiling tools
Tracing and profiling with perf
Using SystemTap
Using LTTng
Using blktrace
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think
Index
Index

Using Wayland

Wayland is a display server protocol that is intended to replace the X Window system and it is licensed under the MIT license. This recipe will provide an overview of Wayland, including some key differences with the X Window system, and will show how to make use of it in Yocto.

Getting ready

The Wayland protocol follows a client/server model in which clients are the graphical applications requesting the display of pixel buffers on the screen, and the server, or compositor, is the service provider that controls the display of these buffers.

The Wayland compositor can be a Linux display server, an X application, or a special Wayland client. Weston is the reference Wayland compositor in the Wayland project. It is written in C and works with the Linux kernel APIs. It relies on evdev for the handling of input events.

Wayland uses Direct Rendering Manager (DRM) in the Linux kernel and does not need something like an X server. The client renders the window contents to a buffer shared...

Previous Section
End of Section 18
Next Section