Using qiBuild with Aldebaran packages¶
Quick start¶
Creating code running on your computer¶
| Step | Action |
|---|---|
Open a Command Prompt and go to the examples folder included in the C++ SDK documentation. $ cd /path/to/cpp/sdk/doc/examples
For example, Windows users will do: 
|
|
Type this command in order to create a worktree. $ qibuild init
|
|
Type this command in order to create a default toolchain using the feed from the C++ SDK: $ qitoolchain create mytoolchain /path/to/cpp/sdk/toolchain.xml --default
Where mytoolchain is the name you want to give to this specific toolchain (you could have several). |
|
Type these commands in order to configure and build the helloworld project: $ cd core/helloworld
$ qibuild configure -c mytoolchain
$ qibuild make -c mytoolchain
|
|
| If those steps were successful, you should able to open the project in your favorite IDE and start working on your code. See section: Using an IDE from qibuild documentation. |
Creating code running on the robot¶
You have to be on Linux to be able to compile code for the robot.
| Step | Action |
|---|---|
Get the cross-toolchain that matches your robot version (atom for V4 and later, geode for previous version), and extract it, say in /path/to/atom/ctc Note on linux64 you will have to install some 32bits libraries for the cross-compiler to work. On ubuntu, you should use something like: $ sudo apt-get install gcc-multilib libc6-dev libc6-i386
|
|
Create a toolchain using the feed from the cross-toolchain. $ qitoolchain create cross-atom /path/to/ctc/
$ qibuild configure -c cross-atom
$ qibuild make -c cross-atom
|
Detailed description¶
Creating a work tree¶
First you need to choose a qibuild “worktree”.
This path will be the root from where qiBuild searches to find the sources of your projects.
In the following document, we will use the notation QI_WORK_TREE to refer to this path.
Then go to this directory and run:
$ qibuild init --interactive
If you want, you can also create a worktree inside the SDK, so that you will be able to easily compile all our examples.
to do so, simply run:
$ cd /path/to/sdk/doc/examples
$ qibuild init --interactive
You will be asked to choose a CMake Generator.
Warning: Although qiBuild supports many platforms and configurations, only a few ones are supported in the current C++ SDK:
- Unix Makefiles (for Linux and Mac)
- Visual Studio 9 2008
- Visual Studio 10
Using qiBuild with the C++ SDK¶
Here you should tell qibuild to use a toolchain.
Simply run:
$ qitoolchain create <name> <path/to/sdk/toolchain.xml> --default
You can choose whatever name you want for the toolchain (for instance ‘linux32’ on linux).
This will tell qibuild that you have a new toolchain, and CMake will look for packages in the same directory the toolchain.xml resides.
If everything goes well, you should see:
$ qitoolchain create linux32 /path/to/cpp/sdk/toolchain.xml --default
Now using toolchain linux32 by default
$ qitoolchain status
Toolchain linux32
Packages:
naoqi-sdk
in /path/to/cpp/sdk
Now you can either:
- Create a new project from scratch, then configure and build it with:
$ qibuild create foo
$ qibuild configure foo
$ qibuild make foo
- Or, if you choose to create a worktree inside doc examples:
$ qibuild configure helloworld
$ qibuild make helloworld
Note that a build directory has been created for you by qibuild, in build-<name>, where <name> is the name you pass to the qitoolchain command.
On Unix and Mac, you can open the root CMakeLists with QtCreator and tell it to use the build folder created by qibuild.
On Windows, a .sln should have been generated for you in the build directory.
In any case, you can open the correct IDE by using:
$ qibuild open <project_name>
Finally, note that on Unix, qibuild will build your project on debug, to build in release, use:
$ qibuild configure --release <project_name>
$ qibuild make --release <project_name>
You will note that qibuild will use a different build directory (build-<toolchain-name>-release).
Using qiBuild with a cross-toolchain¶
You just have to tell qibuild to use another toolchain.
Simply run:
$ qitoolchain create opennao-geode /path/to/geode-ctc/toolchain.xml
for instance.
You can now cross-compile by using:
$ qibuild configure -c opennao-geode
$ qibuild make -c opennao-geode
And of course, cross-compile in release is done with:
$ qibuild configure -c opennao-geode --release
$ qibuild make -c opennao-geode --release
Going further¶
If you want to discover the full power of the qiBuild framework, you can read more about it in the qiBuild documentation