11. Creating Custom Layers | Embedded Linux Development with Yocto Project

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Embedded Linux Development with Yocto Project

By : Otavio Salvador

3.9 (20)

Embedded Linux Development with Yocto Project

3.9 (20)

By: Otavio Salvador

Overview of this book

A practical tutorial guide which introduces you to the basics of Yocto Project, and also helps you with its real hardware use to boost your Embedded Linux-based project. If you are an embedded systems enthusiast and willing to learn about compelling features offered by the Yocto Project, then this book is for you. With prior experience in the embedded Linux domain, you can make the most of this book to efficiently create custom Linux-based systems.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Meeting the Yocto Project

1. Meeting the Yocto Project

What is the Yocto Project?

Delineating the Yocto Project

Understanding Poky

The alliance of OpenEmbedded Project and Yocto Project

Summary

2. Baking Our Poky-based System

2. Baking Our Poky-based System

Configuring a host system

Downloading the Poky source code

Preparing the build environment

Knowing the local.conf file

Building a target image

Running images in QEMU

Summary

3. Using Hob to Bake an Image

3. Using Hob to Bake an Image

Building an image using Hob

Customizing an image with Hob

Summary

4. Grasping the BitBake Tool

4. Grasping the BitBake Tool

Understanding the BitBake tool

Exploring metadata

Parsing metadata

Dependencies

Preferring and providing recipes

Fetching the source code

Understanding BitBake's tasks

Generating a root filesystem image

Summary

5. Detailing the Temporary Build Directory

5. Detailing the Temporary Build Directory

Detailing the build directory

Constructing the build directory

Exploring the temporary build directory

Understanding the work directory

Understanding the sysroot directories

Summary

6. Assimilating Packaging Support

6. Assimilating Packaging Support

Using supported package formats

Understanding shared state cache

Explaining package versioning

Package feeds

Summary

7. Diving into BitBake Metadata

7. Diving into BitBake Metadata

Using metadata

Working with metadata

Summary

8. Developing with the Yocto Project

8. Developing with the Yocto Project

Deciphering the software development kit

Working with the Poky SDK

Developing applications on the target

Integrating with Eclipse

Summary

9. Debugging with the Yocto Project

9. Debugging with the Yocto Project

Differentiating metadata and application debugging

Tracking image, package, and SDK contents

Debugging packaging

Logging information during task execution

Utilizing a development shell

Using the GNU Project Debugger for debugging

Summary

10. Exploring External Layers

10. Exploring External Layers

Powering flexibility with layers

Detailing the layer's source code

Adding meta layers

Summary

11. Creating Custom Layers

11. Creating Custom Layers

Making a new layer

Adding metadata to the layer

Creating an image

Adding a package recipe

Writing a machine definition

Using a custom distribution

Machine features versus distro features

Understanding the variables scope

Summary

12. Customizing Existing Recipes

12. Customizing Existing Recipes

Common use cases

Adding extra options to recipes based on Autoconf

Applying a patch

Adding extra files to the existing packages

Changing recipe feature configuration

Customizing BusyBox

Customizing the linux-yocto framework

Summary

13. Achieving GPL Compliance

13. Achieving GPL Compliance

Understanding copyleft

Managing software licensing with Poky

Using Poky to achieve copyleft compliance

Summary

14. Booting Our Custom Embedded Linux

14. Booting Our Custom Embedded Linux

Exploring the Wandboard

Discovering Freescale ARM BSP

Using Wandboard with the Yocto Project

Building an image for Wandboard

Booting Wandboard from the SD card

Summary

A. References

A. References

Index

Index

Customer Reviews

3.9 (20)

5 star

40%

4 star

20%

3 star

35%

2 star

0%

1 star

5%

Writing a machine definition

Creating a new machine to be used by Poky is a straightforward task. It essentially provides the information needed for a machine to work. The bootloader, kernel, and hardware support drivers must be checked before starting to integrate the board into the BSP layer.

The Yocto Project supports x86-32, x86-64, ARM32, ARM64, MIPS, MIPS64, and PowerPC, representing the most currently used embedded architectures.

The prevailing set of variables used in a machine definition is as follows:

TARGET_ARCH: This sets the machine architecture, for example, ARM and i586
PREFERRED_PROVIDER_virtual/kernel: This overrides the default kernel (linux-yocto) in case you need to use a specific one
SERIAL_CONSOLES: This defines serial consoles and their speeds
MACHINE_FEATURES: This describes hardware features, so the needed software stack is included in the images by default
KERNEL_IMAGETYPE: This is used to choose the kernel image type, for example, zImage and uImage
IMAGE_FSTYPES...

Visually different images

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Embedded Linux Development with Yocto Project

Search

Your notes and bookmarks