Embedded Linux Using Yocto Part 2

Learn how to create your own layer in Yocto, a logical collection of related recipes, and why naming it with the meta- prefix helps you identify it easily.

Create your own layer to store recipes and custom images, kernel, and patches, instead of modifying local conf. Avoid editing upstream layers to ease updates across Yocto versions.

Explore how to organize Yocto layers by type, adding machine, distribution, or recipe content in the appropriate conf and recipes subdirectories, and learn how layer priority guides Bitbake decisions.

Discover manual layer creation by adding a config folder and a layer.conf file, rename skeleton to my layer, and compare with using a bitbake script to include the layer.

Use the bitbake layer create layer script to auto-generate a yocto layer with a layer configuration file, recipes-example, and licensing files, then compare automatic and manual approaches and priority six.

This lecture explains layer configuration file in Yocto, showing how path and search locations are built with append and plus-equals operations, and how Bitbake locates core image minimal in layers.

Use the Yocto check script to assess your layer's compatibility with the Yocto project, run tests from the layer path, and apply to the Yocto project compatible program.

Explore the meta folder to identify which operators are used most, comparing plus equals, underscore append, and overriding syntax.

Define image as a recipe inheriting the image class, and explain building it yields a Linux distribution from source, including compilers, tools, libraries, kernel, bootloader, and root file system.

Create custom images for embedded Linux by building from scratch or extending existing recipes, adding your own packages and applications within the Openembedded build system.

Understand what a package group is—a set of packages installed into the rootfs via the image install variable, providing the minimum packages for bootable images from existing package group recipes.

Create a minimal Yocto image from scratch by inheriting the core image, configuring image install, generating rootfs and kernel, and booting with qemu.

Add the USB utilities package to an existing Yocto image using image_install and plus equals to enable lsusb and verify USB connectivity in the rootfs.

Reuse the core image minimal as a base, extend its image install with usb utils using require, and generate a custom image while noting the difference between require and inherit.

Learn how image features determine what goes into a Yocto image by examining the core image class and the image_features variable, including debug tweaks, splash, and package groups.

Explore how image features enable choosing between dropbear and OpenSSH servers in Yocto core images, then build the rootfs, start the ssh service, and verify password behaviors.

Understand how debug tweaks enable passwordless login for the root user to speed development. Recognize the need to remove them from production images to prevent unauthorized root access.

Explore why a read-only root filesystem protects flash memory and prevents power‑failure corruption, then enable the read only rootfs feature in Yocto and verify with mount and touch.

Configure the splash image feature in Yocto to show a bootup logo or company logo during startup and shutdown. Learn how rootfs contents and image generation affect the splash screen.

Enable image features in Yocto to add strace, gdb, and debugging tools, optionally install a full SDK and toolchain for on-device compilation, while avoiding production image bloat.

Learn how to add other language support by updating the image_language variable to include locales such as Chinese, then generate the image for the build.

Explore image underscore types and how the image_type variable controls which root filesystem formats Yocto generates, including squashfs, jfs, and ext3, within the core image class.

Create a custom Yocto image type by inheriting image_types and implementing image_command_image. Reference meta Raspberry Pi examples and configure rootfs formats and partitions, including a bootloader on the first partition.

Modify the image name with the image_name variable to replace the base name. Generate and verify the image, and add locales such as Chinese to demonstrate customization.

discover how the image manifest lists installed packages by name, architecture, and version, with the manifest located in deploy/images and reflecting the image features.

Explore various image features in the core image class, try x11 and other image features, and identify all available image features.

Define a recipe as a text file that specifies a single software component for the OpenEmbedded build system, including its source location, patches, configuration, compilation, and packaging for the rootfs.

Learn the recipe file format: base name, underscore, version, and extension dot vb, using lowercase characters and avoiding reserved suffixes such as native, cross, initial, or dev.

Learn how Bitbake parses a recipe, derives fetch, unpack, patch, configure, compile, install, and package tasks, and how to control the build with -c and task lists in Yocto.

Examine the fetch stage by defining src_uri to pull sources from git, https, svn, ftp, or local files, and see how do_fetch uses schemes to store downloads.

Fetch and unpack the source into the recipe's working directory in the temp/work folder; Bitbake uses the s variable to locate the extracted directory, and git sources use work git.

Patch the code after fetching, as Bitbake automatically applies patches ending in .patch or .diff using the patch task and the -p1 option; adjust with the strip level option.

Learn how to declare licenses in yocto recipes, specify the license and license file checksum, and handle gpl v2 when licensing appears in source or a separate file.

Configure the source code using cmake or autotools by adding a do configure task when needed, and skip this step if the project already provides cmakelists.txt or configure.ac.

Execute the recipe from compile to install and packaging, copying build artifacts to user bin, then split outputs into logical packages like debug symbols and man pages.

Create a Yocto recipe for a hello world C program, including folder structure, MIT license, checksum, source handling, compile with cross compiler, and install the binary into rootfs/usr/bin via bitbake.

Explore how the install command replaces multiple steps by copying files, creating directories, changing ownership and permissions, and optionally stripping debugging symbols in a single command.

Show how each recipe uses the temp work folder to form a work directory by architecture, package name, and version fields PV and P, with R0 for no revision.

Explore openembedded variables such as s, d, work, p, pv, and pr, and see how bitbake uses them to build my hello 0.1 for x86_64.

Explore the work directory and see how BitBake creates folders, copies programs, and organizes image, package, and install paths, including usr bin and hello package.

Explains the Yocto recipe build flow by stepping through fetch, unpack, configure, compile, install, and package stages, including cleanups, temp folders, and log insights.

Configure stage to create recipes folders for host and target builds; compile generates a user program and install copies it to image/usr/bin with 0757 permissions, and rpm packages are created.

Learn how a Yocto recipe builds the image rootfs with target libraries and host tools, and how image install adds the binary to image bin with permissions.

Write a C code recipe that uses a header file, includes a header, and combines a C file with a header to complete this session's challenge.

Trace bitbake image builds by inspecting temp log cooker and the console latest log, revealing tasks like fetch, unpack, configure, and install. Speed builds with log files and estate.

Open the work directory and its temp subdirectory to access log and run files for fetch, patch, configure, compile, and install tasks.

Explore bitbake logging utilities for python and shell in recipes, learn how logs appear in cooker vs task-specific logs, and apply various log levels during do compile and do install.

Explore Python logging functions for Yocto builds, illustrating fatal errors that terminate processing, errors that display without stopping, and warnings, debug, and plain messages with run and log files.

Enable debug output from Bitbake by using the -d option to display debug messages at multiple levels, and review log files, per-task logs, and run files in Yocto.

Demonstrates a Yocto recipe to build a two-file C program by copying required files into the files folder and listing both sources for compilation.

Learn to use preprocessing directives in a Yocto recipe to switch between system call and printf by defining a macro with -D.

See how a makefile drives compilation in a Yocto environment, from targets like all and clean to passing ldflags and compiling a C program.

Understand how do_compile and do_configure use run make to execute make when a makefile exists, otherwise run make clean, with error checks such as die make failed.

Learn how to pass extra make options in openembedded using EXTRA_OEMAKE, such as V=1 for verbose output, and observe how these options are expanded during the do_compile stage.

Implement a make install task in a Yocto recipe by directing installation to the image directory with a destdir, handling sudo permissions, and validating packaging with BitBake.

Set clean broken equals to one in the recipe when a makefile lacks a clean target, preventing do configure from running make clean and enabling a successful build.

Learn how to pull code from a Git repository in Yocto by creating a Git-based recipe, configuring source URL, protocol, and revision, and debugging with BitBake.

bitbake uses the src variable to select the revision from a repository, choosing auto revision for latest or a fixed hash for stability.

Add a compile and install task to the recipe by specifying the source and ldflags, then copy the user program to the bin directory via bitbake.

Add a git recipe to the image to install a package and generate an updated Embedded Linux image with Yocto.

Learn how to select a specific revision in Yocto by using a sha1 hash, compare it to auto revision, and configure the source with repository, workdir/git, and revision.

Specify a branch in bitbake to fetch the source from a non-master branch, avoid spaces in the branch name, and ensure the source matches the selected branch.

Learn to fetch from a local git repository using protocol=file, specify the local path, and verify commits before pushing to the remote repository.

Learn how private repositories in Yocto require ssh authentication with public keys, enabling password-free access after storing the public key on the remote.

Pass a git tag to a recipe in Yocto by using the tag parameter to fetch a specific tag, such as 1.1.0, instead of a revision or branch.

Explore how git recipes in embedded linux Yocto projects use source revision and auto revision, comparing latest fetches versus specific revisions across repositories like Meta OpenEmbedded.

Learn how to patch a recipe source in yocto, modify the work area, force recompile with bitbake, and why patches preserve changes better than direct edits.

Create and apply patches to embedded Linux sources using git by committing changes, generating patch files with git format patch, and applying patches in a Yocto recipe.

Tackles a hands-on challenge to understand how setting PV in Yocto recipes affects package versioning, by exploring meta layers like meta openembedded and git recipes and manually setting package versions.