Yocto project has been used at Open-RnD for building a number of IoT related products. The talk will go though the details of integration of Poky build system and OpenEmbedded layers into 3 projects carried out at Open-RnD:
The presentation will approach to building software, automation and upstreaming of fixes.
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:
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 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).
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:
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.
We'll also cover a very simple Jenkins integration wrapper that can be utilized for building Poky based projects.
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.
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.
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.
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.
Speakers: Maciej Borzecki