Sign In Start Free Trial

Embedded Linux Development Using Yocto Project Cookbook

By : Alex Gonzalez

3.8 (8)

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.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

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

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

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

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

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

Customer Reviews

3.8 (8)

5 star

50%

4 star

12.5%

3 star

12.5%

2 star

12.5%

1 star

12.5%

Developing GTK+ applications

This recipe will show how to build, run, and debug a graphical GTK+ application using the Eclipse IDE.

Getting ready

Add the eclipse-debug feature to your project's conf/local.conf file, as follows:

EXTRA_IMAGE_FEATURES += "eclipse-debug"

Build a core-image-sato target image, as follows:

$ cd /opt/yocto/fsl-community-bsp/
$ source setup-environment wandboard
$ bitbake core-image-sato

Build a core-image-sato toolchain with the following command:

$ bitbake -c populate_sdk core-image-sato

Install the toolchain by running the installer, as follows:

$ cd tmp/deploy/sdk
$ ./poky-glibc-x86_64-core-image-sato-cortexa9hf-neon-toolchain-2.4.sh

Before launching the Eclipse IDE, we can check whether we are able to build and launch a GTK application manually. We will build the following GTK+ hello world application source. The following is the code in gtk_hello_world.c:

#include <gtk/gtk.h> 
 
int main(int argc, char *argv[]) 
{ 
  GtkWidget *window; 
  gtk_init (&argc, ...

Search

Your notes and bookmarks