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 jethro origin/jethro
                    

Git's checkout command checks out the current Yocto Project release into a local branch whose name matches the release (i.e. jethro). 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 Manual.

Exit QEMU: Exit QEMU by either clicking on the shutdown icon or by opening a terminal, typing poweroff, and then pressing "Enter".

Create a Local Copy of the meta-intel Repository: Building an image for the MinnowBoard MAX 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: 11988, done.
     remote: Compressing objects: 100% (3884/3884), done.
     Receiving objects: 100% (11988/11988), 2.93 MiB | 2.51 MiB/s, done.
     remote: Total 11988 (delta 6881), reused 11752 (delta 6645)
     Resolving deltas: 100% (6881/6881), 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. Consequently, you need to checkout out the "jethro" release after cloning meta-intel:

     $ cd $HOME/poky/meta-intel
     $ git checkout jethro
     Branch jethro set up to track remote branch jethro from origin.
     Switched to a new branch 'jethro'
                    

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 a Minimal Image for MinnowBoard MAX: Use the following command to build the minimal image for MinnowBoard MAX. 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.

     $ bitbake core-image-minimal
                    

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

     tmp/deploy/images/intel-corei7-64/core-image-minimal-intel-corei7-64.hddimg
                    

Write the Image: You can write the image to a USB key, SATA drive, or SD card by using the mkefidisk.sh script, which is included in the poky repository at scripts/contrib/mkefidisk.sh:

     $ sudo $HOME/source/poky/scripts/contrib/mkefidisk.sh HOST_DEVICE \
        tmp/deploy/images/intel-corei7-64/core-image-minimal-intel-corei7-64.hddimg TARGET_DEVICE
                    

In the previous command, HOST_DEVICE is the device node on the build host (e.g. /dev/sdc or /dev/mmcblk0). TARGET_DEVICE is the name of the device as the MinnowBoard MAX sees it (e.g. /dev/sda or /dev/mmcblk0).

Boot the Hardware: With the boot device provisioned, you can insert the media into the MinnowBoard MAX 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