Hemera SDK Overview

Hemera SDK is all you need for developing Hemera applications.

It consists of two main parts: the Hemera SDK Client tools, and one or more Hemera Emulators, depending on how many target devices you might have. The Hemera SDK Client tools are universal (for a specific Hemera version) and not device-dependent, whereas the Emulators are specific to a target Hemera device.

Note
Some of the concepts used in this documentation are explained in Base Hemera Concepts.

Hemera Emulators

Hemera Emulators are the living core of Hemera SDK. Besides being actual x86 Hemera appliances which can be used for testing and deployment of applications, they also contain a cross toolchain for the target device (with the exception of the Generic x86 emulator, which does not include such a thing). For such a reason, you don't need to clutter your system with any toolchain or rootfs, everything is managed transparently without you knowing.

Hemera Emulators are designed to run in VirtualBox, and are directly managed through Hemera SDK Client Tools - you don't need to (and usually, should not) interact with VirtualBox directly. Building on top of VirtualBox means relying on a performing, open, scalable and multi-platform Virtualization platform which allows us to deliver our SDK in the best possible way. With our Hemera SDK Client Tools being multiplatform as well, this makes Hemera SDK completely native on every major platform (Windows, Linux, OS X).

Note that the toolchain detail is completely hidden from the developer's eyes: you never interact directly with or have to work inside the emulator itself - Hemera SDK Client Tools do this for you instead. You always work on your machine.

Hemera Emulators are usually distributed as (compressed) VDI images, which can then be subsequently installed through hsdk or any GUI Hemera SDK Client Tools provide. Please refer to the installation manual.

Only one Hemera Emulator can be run at a time. This is because Hemera SDK uses TCP extensively (for Hyperspace) and needs to forward some ports on your machine. This also allow you to test Hyperspace for your applications. The default setup exposes Hyperspace(+Stream) both via https and http, on these ports:

  • 8080: Hyperspace over HTTPS (used by Hemera Client SDK Tools)
  • 6391: Hyperspace stream helper port for HTTPS (used by Hemera Client SDK Tools)
  • 8081: Hyperspace over HTTP
  • 6392: Hyperspace stream helper port for HTTP

Also, in case you need to perform additional debugging or need to access the Emulator's root filesystem, you can also SSH into it. Port 22 is forwarded onto port 2223 on your host.

If you are managing you Emulators from Hemera Client SDK Tools, they will take care of bringing them up and down automatically. Keep in mind that running more than one Emulator at a time leads to undefined behavior.

Current Limitations

  • For how Hemera Emulators are implemented, it is currently possible to develop Hemera applications only in a subdirectory (at any level) of your home. This limitation will be removed in the near future.

Hemera Devices

Devices are actual Hemera board running an Hemera instance, non-virtualized. They can be accessed and controlled by Hemera Client SDK Tools if they are in Developer Mode.

Given all the action happens on Emulators, on a Hemera device you can launch, deploy and debug applications only. On the other hand, you need to have your device connected for associating it with a known Emulator and for building applications.

Most Hemera devices come with a USB OTG port, which can be usually plugged into the Host PC to have the device connected. All Hemera Developer Mode devices also come with Hyperdiscovery, so that they are discoverable once plugged in. For most devices, you just need to simply plug the USB cable in, wait for boot, and allow Hemera Client SDK Tools to pick up your device and let you manage it.

Every Hemera Device has two IDs: a Hardware ID, securely generated from its hardware (its generation is heavily dependent on what is available on the board) and guaranteed to be the same at every reflash, and a System ID, which is generated upon the first boot and identifies the appliance. Hemera Client SDK Tools rely on the Hardware ID to identify a Device, which can be added to the system by giving it a common name.

Hemera Client SDK Tools

Hemera Client SDK Tools are a set of tools which provide an interface to Hemera Emulators and Devices. They revolve around a C++/Qt5 library, Hemera Developer Mode Client, which is then used for building several interfaces. If you are interested in developing your own or want us to integrate Hemera SDK Client Tools into your favorite IDE, please drop us a line! It's easier than you might think.

Before we start, please keep in mind that for security reasons, Hemera Developer Mode Client holds a lock on each Device and Emulator it is managing, and as such it is not possible to run more than one different frontend at the same time. This is intentional and prevents misuse of the Client SDK Tools or unexpected behavior.

HSDK

The reference implementation of Hemera Developer Mode Client and the main headless interaction mechanism is hsdk, a command line tool available on every platform.

If you are familiar with git, hsdk features a very similar user interface. hsdk –help is the best way to get started with it, and to consult its documentation. For each subcommand, a dedicated –help is available. hsdk will be used for demonstrating the capabilities of Hemera SDK Client Tools in the forthcoming sections, and at the time of writing is the recommended interface for Hemera Client SDK Tools.

Hemera target manager

Hemera target manager is a simple graphical tool that allows you to manage your Hemera Devices and Emulators, to inspect them and to launch/stop applications via Developer Mode. It is mostly meant as a simple GUI for managing your Hemera targets.

Qt Creator Hemera plugin

Currently in development, Qt Creator Hemera plugin is a full-fledged Hemera integration in Qt Creator which allows for target management, application development, deployment and debugging from within the IDE. Release is planned for end of 2014, and will eventually become the preferred way to interact with Hemera Client SDK Tools.