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 Linux framebuffer

The Linux kernel provides an abstraction for the graphical hardware in the form of framebuffer devices. These allow applications to access graphics hardware through a well-defined API. The framebuffer is also used to provide a graphical console to the Linux kernel, so that it can, for example, display colors and a logo. In this recipe, we will explore how applications can use the Linux framebuffer to display graphics and video.

Getting ready

Some applications, especially in embedded devices, are able to access the framebuffer by mapping memory and accessing it directly. For example, the gstreamer framework is able to work directly over the framebuffer, as is the Qt graphical framework. Some applications, like the Qt framework, also include support for hardware acceleration-not only video but also 2D and 3D graphical acceleration provided through the OpenGL and OpenVG APIs.

How to do it...

The FSL community BSP layer provides a fsl-image-multimedia target image...

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