Open-RnD is a small software company from Łódź, Poland. We have started using Yocto/Poky in late 2013 as a better alternative to in-house build system. Since then, we have successfully implemented a number of projects based on Poky. The presentation will go through the details of 3 projects that cover a diverse range of applications:

• an autonomous parking space monitoring system (ParkEasily)
• a distributed 3D stereoscopic image acquisition system (Ros3D)
• a gadget for acquisition of metabolic parameters of professional athletes (Sonda)

We only use widely available hardware platforms such as BeagleBone Black, Raspberry Pi, Wandboard or Gateworks GW5400 (not as widely used as the previous ones, but still fully supported), hence all the points made during presentation are directly applicable by professionals and hobbyists alike.

Open-RnD

Open-RnD is a small company. The embedded team if even smaller, currently consisting of only 4 people. Since we have rather little resources for maintaining of software, as much work as possible is pushed upstream to Yocto, OE, libraries and packages we depend on (swupdate, Vala, rabbitmq-c, sparts, edts) or tools (ex. jhbuild).

Poky/OE methodology

The presentation will cover out methodology of staying close to the upstream. Normally when starting a new project we will base it on Poky master instead of relying on, so called, stable releases (the same approach is used for other layers). This has a number of advantages:

• you get the latest versions of libraries (with fixes & bugs alike)
• it's easy to upstream fixes

Our practice is to maintain a mirror of upstream repositories. The mirrors are synced every couple of days by our staff members. The branches are then periodically merged into project related branches. Systematic merges help to reduce the number of commits that we need to look at, so the whole effort of merging & reviewing is rather limited. Effectively very few software packages are used by the projects, so most of the commits have no or little effect on the stability of the software stack.

Jenkins

We'll also cover a very simple Jenkins integration wrapper that can be utilized for building Poky based projects.

Development methodology

We'll give some tips on how we think is convenient to develop software so that the integration with any build system is smooth. Specifically we'll emphasize the role of tools such as jhbuild in the whole process and provide tips on how to utilize them efficiently.

ParkEasily

The project's goal is to build a system for autonomous parking space monitoring. This is used for feeding a mobile client application with information on parking space availability within a given area and allows us to direct users to the closest available car park.

The project is composed of a server backend written in Erlang (hoping to be able to present a couple of issues at Lambda Days in Krakow), an intemediate AMQP broker (RabbitMQ) and device endpoints that integrate with parking gates or tap into industrial video streams.

The presentation will cover our first prototyping steps on Raspberry Pi and a later implementation on BeagleBone Black. We'll highlight the aspects of layer organization, and how our methodology of working with Yocto upstream applies in this case.

It will also go through number of fixes related to building of bootable SD card images were implemented for the wic tool. The upstreamed fixes allowed for building a bootable SD images for BeagleBone Black out of the box.

The presentation will focus on layer organization, and give tips on maintenance of custom application layers. We'll also introduce our open-rnd branded distribution within meta-openrnd layer and justify why we have done so.

Since the project covered some aspects of 3G/4G and VPN connectivity, we'll cover that providing examples how to tie that nicely with systemd and udev at Poky level.

Sonda

We used Yocto to implement a mobile base hub and recharging station for IoT gadgets. The base hub was responsible for downloading of any unsent data from the devices. We'll give details on implementing a service that needs to react to external devices appearing on a USB bus.

Since we did a low level integration with a MQTT broker. This part will also cover why it is important to have a working build system for software packages before starting with Poky and problems we identified with libmqttv3c library from Eclipse's Paho Project. Due to limited compatibility with Glib's main loop approach of the libmqttv3c library, we have decided to implement a separate library based on embedded version of the original MQTT library. The library requires cleaning up and will be pushed to our github.

Ros3D

The project is aimed at building a system for acquisition of stereoscopic video for professional filmmakers. The project is partially funded by a grant from the National Centre for Research and Development.

The project is the most demanding compared to other two. The talk will focus on do's and don'ts of layer organization and custom distributions.

Specifically we have implemented a layering scheme that nicely separates the base layers, the BSP layers and the application layers. This allows for plugging in a different platform at the BSP level to keep the development cycle going even when the target hardware is not available.