The Yocto Project is an open-source collaboration that provides a framework for developers to create custom Linux-based systems for embedded devices. Instead of scaling down a desktop Linux distribution, Yocto builds a tailored system from the ground up, ensuring it's optimized for the specific hardware and application.

It provides a flexible suite of tools and a shared environment for embedded developers, promoting efficiency and innovation across a wide range of industries like automotive, medical, and IoT.

Layers are repositories containing metadata that tell the build system what to do. They allow for logical separation of information, promoting collaboration and reuse.

Key layers include:

• meta-poky: Core metadata for the Poky reference distribution.
• meta-openembedded: A collection of community-maintained recipes.
• BSP Layers (e.g., meta-qcom): Provides hardware-specific configurations and drivers (Board Support Package).
• Custom Layers: Your own layers for project-specific recipes and configurations.

Recipes are the most common form of metadata. They are files (with a `.bb` extension) that contain instructions for building a specific piece of software. A recipe typically defines:

• Where to get the source code (SRC_URI).
• Dependencies on other recipes.
• Configuration and compilation options.
• How to install the compiled files.

Here is a simplified example of a recipe:

DESCRIPTION = "My Custom Application"
LICENSE = "MIT"
SRC_URI = "file://my-app-source.tar.gz"

S = "${WORKDIR}/my-app-source"

do_compile() {
    oe_runmake
}

do_install() {
    install -d ${D}${bindir}
    install -m 0755 ${S}/my_app_executable ${D}${bindir}/
}

Configuration files control the build process. The two most important ones are:

• conf/local.conf: For user-specific settings like the target machine, packaging format, and download directories.
• conf/bblayers.conf: Lists all the layers that BitBake should include in the build. The order matters!

The `bitbake-layers` tool helps manage your layers.

# Create a new layer
bitbake-layers create-layer meta-myproject

# Add the new layer to your bblayers.conf
bitbake-layers add-layer meta-myproject

To modify an existing recipe, you should almost never edit it directly. Instead, create a .bbappend file in your custom layer. This file "appends" or overrides the original recipe.

For example, to add a patch to the `busybox` recipe, you would create `meta-myproject/recipes-core/busybox/busybox_%.bbappend` with the following content:

FILESEXTRAPATHS:prepend := "${THISDIR}/files:"
SRC_URI += "file://my-custom-patch.patch"

Build failures are common. Here are some frequent causes and solutions:

• Resource Exhaustion: Insufficient disk space or RAM. A "Killed signal" error often means you ran out of memory. Try reducing parallel jobs in `local.conf`:
  Copy

  BB_NUMBER_THREADS = "4"
  PARALLEL_MAKE = "-j 4"

• Fetching Problems: Network/proxy issues or dead links in `SRC_URI`. Check connectivity and try `bitbake -c fetch ` to isolate the issue.
• Checksum Mismatch: The downloaded source doesn't match the expected checksum. The error log provides the new checksum; update it in the recipe.

The Yocto SDK (Software Development Kit) provides a cross-compiler toolchain and sysroot for building and debugging applications for your target hardware on your host machine.

1. Generate the SDK:
   Copy

   bitbake <image-name> -c populate_sdk

2. Install and source the SDK environment script. This will set up your shell for cross-compilation.
3. Include debug tools in your image by adding `tools-debug` and `ssh-server-openssh` to `EXTRA_IMAGE_FEATURES` in your `local.conf`.
4. Use `gdbserver` on the target and the cross-GDB from the SDK on your host to perform remote debugging.

Qualcomm provides a Board Support Package (BSP) as a set of Yocto layers to enable its hardware. The primary layer is meta-qcom. This provides the core recipes and machine configurations needed to build for platforms like the IQ9.

Because Qualcomm's BSP involves many different Git repositories, they recommend using the `repo` toolA tool built on top of Git that helps manage projects with multiple repositories. to initialize the source code.

The typical workflow involves using `repo` to fetch a manifest file, which lists all the required layers and their correct versions.

# Install repo tool
mkdir ~/bin
curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo
export PATH=~/bin:$PATH

# Initialize and sync the repositories
mkdir qualcomm-iq9-yocto
cd qualcomm-iq9-yocto
repo init -u https://github.com/quic-yocto/qcom-manifest -b qcom-linux-scarthgap -m <manifest.xml>
repo sync

After `repo sync` completes, you can source the `oe-init-build-env` script and proceed with your build as usual, making sure your `local.conf` specifies the correct Qualcomm machine.

In your custom layer (`meta-myproject`), create a C file for a simple hello world application.

File location: `meta-myproject/recipes-apps/hello-iq9/files/hello_iq9.c`

#include <stdio.h>

int main() {
    printf("Hello, Qualcomm IQ9 from Yocto!\\n");
    return 0;
}

Create a `.bb` file to tell BitBake how to build your app.

File location: `meta-myproject/recipes-apps/hello-iq9/hello-iq9_1.0.bb`

SUMMARY = "Simple 'Hello World' application"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0b288087f3954208f17ea"

SRC_URI = "file://hello_iq9.c"
S = "${WORKDIR}"

do_compile() {
    ${CC} ${CFLAGS} ${LDFLAGS} ${S}/hello_iq9.c -o ${B}/hello_iq9
}

do_install() {
    install -d ${D}${bindir}
    install -m 0755 ${B}/hello_iq9 ${D}${bindir}/
}

Create a custom image recipe that includes your new application.

File location: `meta-myproject/recipes-images/images/my-iq9-custom-image.bb`

inherit core-image-minimal

DESCRIPTION = "Custom image for IQ9 with hello-iq9 app."

IMAGE_INSTALL += "hello-iq9"

Finally, run BitBake to build your new custom image.

bitbake my-iq9-custom-image

After the build finishes, you can find the image file in `build/tmp/deploy/images/<machine>/` and flash it to your device.