Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Embedded Linux Development Using Yocto Project Cookbook
  • Toc
  • feedback
Embedded Linux Development Using Yocto Project Cookbook

Embedded Linux Development Using Yocto Project Cookbook

By : Alex Gonzalez
3.8 (8)
close
Embedded Linux Development Using Yocto Project Cookbook

Embedded Linux Development Using Yocto Project Cookbook

3.8 (8)
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.
Table of Contents (7 chapters)
close
close
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
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
chevron up
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
6
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Preparing an SDK

The Yocto build system can be used to generate a cross-compilation toolchain with a matching sysroot for a target system, as well as a sysroot with native applications. This is referred to as a standard Yocto Project SDK. The Yocto Project can also build an extensible SDK that extends the standard SDK by adding tools to facilitate adding new applications and libraries. This recipe will show how to build both types of SDK.

Getting ready

The standard SDK contains the cross-compilation toolchain, including the debugger as well as target and host sysroots. Its size depends on the image it is built to match, but is usually hundreds of MB. The extensible SDK comes in two flavors, full (the default) and minimal, and it allows for a certain degree of customization as well as being updatable.

  • The full extensible SDK includes the following:
    • Toolchain
    • Complete shared state cache artifacts and everything needed to recreate the images it is built against
    • The devtool command-line application...
End of Section 9
Next Section
bookmark search playlist font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete