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

Working with the GNU build system

A Makefile is a good solution when you are always going to build and run your software on the same system and things like glibc and gcc versions and the available library versions are known. However, most software needs to be built and run in a variety of systems.

Getting ready

The GNU build system, or autotools, is a set of tools whose aim is to create a Makefile for your software in a variety of systems. It's made up of three main tools:

  • Autoconf: This parses the contents of a configure.ac file that describes the source code to be built and creates a configure script. This script will then be used to generate the final Makefile.
  • Automake: This parses the contents of a Makefile.am file and converts it into a Makefile.in file. This is then used by the configure script generated earlier to obtain a config.status script that gets automatically executed to obtain the final Makefile.
  • Libtools: This manages the creation of both static and dynamic libraries.

Before...

End of Section 17
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