Set Up to use CROss PlatformS (CROPS): Work through the first six steps of the procedure in the "Setting Up to Use CROss PlatformS (CROPS)" section of the Yocto Project Development Tasks Manual.

Set Up the Poky Container to Use the Yocto Project: Go to https://github.com/crops/poky-container/blob/master/README.md and follow the directions to set up the Poky container on your build host.

Once you complete the setup instructions for your machine, you need to get a copy of the poky repository on your build host. See the "Yocto Project Release" section to continue.

Be Sure Your Build Host is Set Up: The steps to build an image in this section depend on your build host being properly set up. Be sure you have worked through the requirements described in the "Setting Up to Use the Yocto Project" section.

Check Out Your Branch: Be sure you are in the Source Directory (e.g. poky) and then check out the branch associated with the latest Yocto Project Release:

     $ cd ~/poky
     $ git checkout -b rocko origin/rocko
                        

Git's checkout command checks out the current Yocto Project release into a local branch whose name matches the release (i.e. rocko). The local branch tracks the upstream branch of the same name. Creating your own branch based on the released branch ensures you are using the latest files for that release.

Initialize the Build Environment: Run the oe-init-build-env environment setup script to define the OpenEmbedded build environment on your build host.

     $ source oe-init-build-env
                        

Among other things, the script creates the Build Directory, which is build in this case and is located in the Source Directory. After the script runs, your current working directory is set to the Build Directory. Later, when the build completes, the Build Directory contains all the files created during the build.

Examine Your Local Configuration File: When you set up the build environment, a local configuration file named local.conf becomes available in a conf subdirectory of the Build Directory. Before using BitBake to start the build, you can look at this file and be sure your general configurations are how you want them:

Start the Build: Continue with the following command to build an OS image for the target, which is core-image-sato in this example:

     $ bitbake core-image-sato
                        

For information on using the bitbake command, see the "BitBake" section in the Yocto Project Reference Manual, or see the "BitBake Command" section in the BitBake User Manual. For information on other targets, see the "Images" chapter in the Yocto Project Reference Manual.

Simulate Your Image Using QEMU: Once this particular image is built, you can start QEMU and run the image:

     $ runqemu qemux86
                        

If you want to learn more about running QEMU, see the "Using the Quick EMUlator (QEMU)" chapter in the Yocto Project Development Tasks Manual.

Exit QEMU: Exit QEMU by either clicking on the shutdown icon or by typing Ctrl-C in the QEMU transcript window from which you evoked QEMU.

Create a Local Copy of the meta-intel Repository: Building an image for the MinnowBoard Turbot requires the meta-intel layer. Use the git clone command to create a local copy of the repository inside your Source Directory, which is poky in this example:

     $ cd $HOME/poky
     $ git clone git://git.yoctoproject.org/meta-intel
     Cloning into 'meta-intel'...
     remote: Counting objects: 14039, done.
     remote: Compressing objects: 100% (4471/4471), done.
     remote: Total 14039 (delta 8130), reused 13837 (delta 7947)
     Receiving objects: 100% (14039/14039), 4.27 MiB | 3.98 MiB/s, done.
     Resolving deltas: 100% (8130/8130), done.
     Checking connectivity... done.
                        

By default when you clone a Git repository, the "master" branch is checked out. Before you build your image that uses the meta-intel layer, you must be sure that both repositories (meta-intel and poky) are using the same releases. Because you used the yocto-2.4.3 tag when you checked out the poky repository by tag, you should use a meta-intel tag that corresponds with the release you used for poky. Consequently, you need to checkout out the "8.0-rocko-2.4.3" branch after cloning meta-intel:

     $ cd $HOME/poky/meta-intel
     $ git checkout tags/8.0-rocko-2.4.3 -b meta-intel-rocko-2.4.3
     Switched to a new branch 'meta-intel-rocko-2.4.3'
                        

The previous Git checkout command creates a local branch named meta-intel-rocko-2.4.3. You have the option to name your local branch whatever you want by providing any name you like for "meta-intel-rocko-2.4.3" in the above example.

Configure the Build: To configure the build, you edit the bblayers.conf and local.conf files, both of which are located in the build/conf directory.

Here is a quick way to make the edits. The first command uses the bitbake-layers add-layer command to add the meta-intel layer, which contains the intel-core* BSPs to the build. The second command selects the BSP by setting the MACHINE variable.

     $ cd $HOME/poky/build
     $ bitbake-layers add-layer "$HOME/poky/meta-intel"
     $ echo 'MACHINE = "intel-corei7-64"' >> conf/local.conf
                        

     $ echo 'MACHINE = "intel-corei7-64"' >> conf/local.conf
                            

     $ echo 'MACHINE = "intel-core2-32"' >> conf/local.conf
                            

Build an Image for MinnowBoard Turbot: The type of image you build depends on your goals. For example, the previous build created a core-image-sato image, which is an image with Sato support. It is possible to build many image types for the MinnowBoard Turbot. Some possibilities are core-image-base, which is a console-only image. Another choice could be a core-image-full-cmdline, which is another console-only image but has more full-features Linux system functionality installed. For types of images you can build using the Yocto Project, see the "Images" chapter in the Yocto Project Reference Manual.

Because configuration changes are minimal to set up for this second build, the OpenEmbedded build system can re-use files from previous builds as much as possible. Re-using files means this second build will be much faster than an initial build. For this example, the core-image-base image is built:

     $ bitbake core-image-base
                        

Once the build completes, the resulting console-only image is located in the Build Directory here:

     tmp/deploy/images/intel-corei7-64/core-image-base-intel-corei7-64.wic
                        

Write the Image: You can write the image just built to a bootable media (e.g. a USB key, SATA drive, SD card, etc.) using the dd utility:

     $ sudo dd if=tmp/deploy/images/intel-corei7-64/core-image-base-intel-corei7-64.wic of=TARGET_DEVICE
                        

In the previous command, the TARGET_DEVICE is the device node in the host machine (e.g. /dev/sdc, which is most likely a USB stick, or /dev/mmcblk0, which is most likely an SD card).

Boot the Hardware: With the boot device provisioned, you can insert the media into the MinnowBoard Turbot and boot the hardware. The board should automatically detect the media and boot to the bootloader and subsequently the operating system.

If the board does not boot automatically, you can boot it manually from the EFI shell as follows:

     Shell> connect -r
     Shell> map -r
     Shell> fs0:
     Shell> bootx64
                        

     Shell> bootia32