PELUX baseline manifests

This manifest repository is used for building the PELUX baseline for various hardware targets using the Yocto project.

Maintained at https://github.com/pelagicore/pelux-manifests

Building an Image

The following manifests can be used for a build:

pelux-intel.xml - For building the core-image-pelux image for Intel
pelux-intel-qtauto.xml - For building the core-image-pelux-qtauto image, which is the baseline with Qt Automotive Suite
pelux-rpi.xml - For building the core-image-peluximage for Raspberry Pi 3

An image build can be started using a container/virtual machine, see section "Using vagrant", or using repo tool directly, see section "Using Repo tool". Since the Repo tool approach is not contained it is notably faster than using Vagrant. Therefore, the Vagrant approach is usually only used in situations where one does not want to depend on the host system, such as running continuous integration jobs.

Variables:

Manifest, refers to what <manifest-name>.xml file you want to use, for example pelux-intel.xml. Each hardware platform targeted by the PELUX reference has its own manifest describing what other git repositories are needed for the build.
Image, refers to what version of PELUX that should be built. Currently there are two versions: core-image-pelux and core-image-pelux-qtauto. The latter being a version that includes NeptuneUI and QtApplicationManager.

Using vagrant

Dependencies:

Vagrant
Docker or VirtualBox
virtualization enabled in bios

Procedure:

Clone the pelux-manifests git repository.
Start vagrant
```
vagrant up --provider="docker"
```

Set variables to be used below

export bitbake_image="core-image-pelux"
export yoctoDir="/home/vagrant/pelux_yocto"
export manifest="pelux-intel.xml"

Do repo init

vagrant ssh -c "/vagrant/ci-scripts/do_repo_init ${manifest}"

Setup bitbake with correct local.conf and bblayers.conf

vagrant ssh -c "TEMPLATECONF=${yoctoDir}/sources/meta-pelux-bsp-intel/conf \
    /vagrant/vagrant-cookbook/yocto/fetch-sources-for-recipes.sh \
    ${yoctoDir} \
    ${bitbake_image}"

Bitbake the PELUX image

vagrant ssh -c "/vagrant/vagrant-cookbook/yocto/build-images.sh \
    ${yoctoDir} \
    ${bitbake_image}"

Move the built images to the host

vagrant scp :${yoctoDir}/build/tmp/deploy/images ../images

Don't put them into the source folder because then they will be syncroniced back into the docker instance into the /vagrant directory which might take a reasonable amount of resources to do.

The container/virtual machine started via vagrant will sync the cloned git repository and use the manifests contained in it to set up the build environment. This means that the branch/commit currently checked out will determine what version is being built. The final step will copy the image directory containing the built images to the directory on the host where vagrant was started.

Using Repo tool

NOTE: When using this approach one should not clone this git repository, all git manipulation is handled by the repo tool.

First, install repo tool as instructed at http://source.android.com/source/downloading.html#installing-repo.

Then create a directory for the PELUX build.

mkdir pelux
cd pelux

Instruct repo tool to fetch a manifest using the command repo init. In this context, branch denotes what branch of git repo pelux-manifests to use. Then make repo tool fetch all sources using the command repo sync.

repo init -u https://github.com/Pelagicore/pelux-manifests.git -m <manifest> -b <branch>
repo sync

When repo sync has finished fetching the sources, the next step is to create a 'build' directory and set up bitbake. The TEMPLATECONF environment setting tells the oe-init-build-env script which path to fetch configuration files from. Note that the example below gets the template configuration for the Intel BSP. Adapt the path according to your current BSP.

export TEMPLATECONF=`pwd`/sources/meta-pelux-bsp-intel/conf/ 
source sources/poky/oe-init-build-env build

The script will create configs if there are no configs present, a message about created conf/local.conf and conf/bblayers.conf files is normal.

Finally, build the desired image. See the variables description above for information on the different images.

bitbake <image>

Targets

Below is a description of the currently supported hardware targets. For more information about how to use a built image with the targets, see Getting started.

PELUX Intel

Reference instance for the Intel i7 x86 platform using Yocto's BSP

Intel NUC
Minnowboard Max, Turbot

PELUX Raspberry Pi 3

Reference instance for Raspberry Pi 3 (coming soon)

Branching

This repository will follow yocto releases. Whenever a new yocto release has been released, a new branch with the same name will be created from the master branch. All feature growth should happen first on the master branch, but will also be cherry picked back to the latest yocto release branch. Security and bug fixes will be evaluated case by case and backported as necessary. The ambition is to actively maintain the four latest releases and/or two year old releases in this fashion.

License and Copyright

All metadata is MIT licensed unless otherwise stated. Source code included in tree for individual recipes is under the LICENSE stated in the associated recipe (.bb file) unless otherwise stated.

License information for any other files is either explicitly stated or defaults to MIT license.

jeremiah / pelux-manifests