Key Capabilities of the Kaa IoT Platform:
Connectivity, Integration, and Data Processing

This page will guide you through the various aspects of Kaa so you can get a better understanding of its functionality and capabilities.

Hardware

The Kaa platform is hardware-agnostic. You can integrate pretty much any device, starting from those powered by fully-functional operating systems, all the way down to resource-constrained microcontrollers with less than 10 KB of available RAM. There are many platforms that are already pre-integrated and verified with Kaa, but even if you don’t see a particular platform listed, there is a good chance that it can be easily integrated using Kaa’s highly portable SDKs. They are now available in Java, C++, and C: just pick one that suits your case.

Simple car model


    {
         "type" : "record",
         "name" : "Car",
         "namespace" : "org.kaaproject.smartcar",
         "fields" : [ {
             "name" : "brand",
             "type" : {
                 "type" : "enum",
                 "name" : "Brand",
                 "namespace" : "org.kaaproject.smartcar",
                 "symbols" : [ "Audi", "BMW", "Lexus" ]
             }
         }, {
             "name" : "model",
             "type" : "string"
         }, {
             "name" : "vin",
             "displayName" : "Vehicle Identification Number",
             "type" : "string"
         }, {
             "name" : "color",
             "type" : "string"
         } ]
    }

Data models

Kaa can handle both structured and unstructured data, but favors the former. Well-structured data provides excellent material for any manipulation and analytics.

This kind of data also helps abstract out any unimportant details of the low-level implementation and your hardware. Kaa ensures that even gadgets based on very different technologies can be managed and operated identically, as long as they share the same set of data schemas. This is why in every aspect of its functionality, Kaa makes use of a corresponding data schema that governs the semantics and generates a lot of boilerplate code automatically. Schemas are Apache Avro compatible, and thus, very powerful. Apache Avro also allows data serialization to be very efficient.

Once you start working with Kaa, you will quickly find yourself in a data schemas state of mind — and that’s a good thing.

  • Works with structured and unstructured data
  • Apache Avro compatible
  • GUI for data schemas

SDK

Kaa endpoint SDKs are available in Java, C++, and C, and are designed to be embedded into your client application (or firmware). They handle client-server communication, authentication, data marshalling, encryption, persistence, and other functions provided by the platform.

Each generated SDK is fitted for your particular server instance. The generated SDKs contain server-specific data schemas translated into object bindings for your IoT application. The SDKs also have the knowledge of the transport layer protocol implementation in use, as well as how to establish communication with that specific server instance at which the SDK was generated.

  • Auto-generated code and data bindings
  • Abstracts out protocol, data consistency, and other complexities
  • Easily portable to virtually any hardware and OS

JavaCC++Objective-C

#include <stdint.h>

#include "kaa/kaa_error.h"
#include "kaa/kaa_context.h"
#include "kaa/platform/kaa_client.h"
#include "kaa/kaa_profile.h"

int main()
{
    kaa_client_t *kaa_client = NULL;
    kaa_client_create(&kaa_client, NULL);

    kaa_profile_t *profile = kaa_profile_car_create();

    profile->brand = ENUM_BRAND_Audi;
    profile->model = kaa_string_copy_create("A8");
    profile->color = kaa_string_copy_create("silver");
    profile->vin = kaa_string_copy_create("JTHGL1");

    kaa_profile_manager_update_profile(
        kaa_client_get_context(kaa_client)->
                                profile_manager
      , profile);

    profile->destroy(profile);
    kaa_client_start(kaa_client, NULL, NULL, 0);
    kaa_client_destroy(kaa_client);

    return 0;
}
package org.kaaproject.smartcar.test;

import org.kaaproject.kaa.client.DesktopKaaPlatformContext;
import org.kaaproject.kaa.client.Kaa;
import org.kaaproject.kaa.client.KaaClient;
import org.kaaproject.kaa.client.profile.ProfileContainer;
import org.kaaproject.smartcar.Brand;
import org.kaaproject.smartcar.Car;

public class SmartCar {
    public static void main(String[] args) {
        DesktopKaaPlatformContext kaaContext =
            new DesktopKaaPlatformContext();

        KaaClient kaaClient =
            Kaa.newClient(kaaContext, null);

        kaaClient.setProfileContainer(
            new ProfileContainer() {
                @Override
                public Car getProfile() {
                    return new Car(Brand.Audi, "A8",
                        "silver", "JTHGL1");
                    }
                });

        kaaClient.start();
        kaaClient.stop();
    }
}
#include ‹memory›

#include "kaa/Kaa.hpp"
#include "kaa/IKaaClient.hpp"
#include "kaa/profile/DefaultProfileContainer.hpp"

using namespace kaa;

int main()
{
    Kaa::init();
    IKaaClient & kaaClient = Kaa::getKaaClient();

    kaa_profile::Car profile;

    profile.brand = kaa_profile::Brand::Audi;
    profile.model = "A8";
    profile.color = "silver";
    profile.vin = "JTHGL1";

    kaaClient.setProfileContainer(
        std::make_shared<DefaultProfileContainer>(
            profile));

    Kaa::start();
    Kaa::stop();

    return 0;
}
#import "AppDelegate.h"

@import  Kaa;

@interface AppDelegate () <ProfileContainer>

@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    id<KaaClient> kaaClient = [KaaClientFactory clientWithContext:[[DefaultKaaPlatformContext alloc] init] stateDelegate:nil];

    [kaaClient setProfileContainer:self];

    [kaaClient start];
    [kaaClient stop];

    return YES;
}

- (Car *)getProfile {
    return [[Car alloc] initWithBrand:CarBrandAudi model:@"A8" color:@"silver" vin:@"JTHGL1"];
}

@end

Connectivity

Kaa is transport-agnostic. It allows building applications that function over any type of network connection — either persistent or intermittent. You may choose one of the existing transport protocol implementations that come with Kaa, or create custom-tailored transports and plug them into your system. Kaa will automatically advertise the connection parameters to endpoints and balance the load across the servers in the cluster.

Advanced platform users may find it handy that Kaa is able to flexibly assign transport implementations to platform services. For example, notifications may be delivered to endpoints via UDP or SMS while configuration and profile data may be synced via an AES-encrypted TCP-based binary protocol.

  • Transport-agnostic
  • Pluggable protocols
  • Multi-channel support

IoT gateways and routers

Kaa can be effectively used to enable advanced IoT features for gateways and Wi-Fi routers. With the Kaa functionality on board, these devices can act as an inexpensive yet multi-functional bridge between the endpoints and the IoT cloud.

Kaa-powered gateways and routers can largely simplify data collection from simple sensors or devices that use PAN-based protocols such as Bluetooth, ZigBee, or Z-Wave for connectivity. They can also be used to streamline the process of adding new devices to the given IoT cluster by converting the device’s data format into the “common tongue” used in the cluster.

For massive amounts of real-time data or large-scale deployments, Kaa allows implementing the edge analytics into IoT gateways, which is preliminary data processing and data aggregating performed by an IoT gateway before sending out a bulk of data to the Kaa server/cloud. In this way, the traffic load in the network can be reduced by ten times or more, leading to substantial savings in the server equipment or rented cloud processing facilities.

Kaa server

The Kaa server acts as a foundation for your custom-tailored IoT back-end system. It offers a number of mechanisms for internal customization and integration with external systems: REST interfaces for integration with product-specific services, log appenders for integration with analytics, data management and visualization systems, pluggable implementations of custom transports, and other modules.

The Kaa server is usually deployed as a cluster of nodes, which is easily expandable as soon as higher performance is required. The Kaa server architecture also eliminates the risk of downtime by enabling the high availability mode and precluding a single point of failure in the cluster. The Kaa cluster uses Apache Zookeeper for coordination of servers, primary node elections, and failure mitigation. Since Kaa is a 100% open-source platform, it can be easily deployed on premises, in cloud, or in a mixed mode.

The Kaa server was designed to handle millions of connected devices under peak pressure without ever getting tired.

  • Easily customizable and expandable
  • Load balancing in the cluster, no single point of failure
  • Multiple deployment options: on premises, in cloud, or mixed

Data processing

Collecting and analyzing data from connected devices is one of the most recurring IoT use cases. Kaa’s mission is to make these tasks totally straightforward, even at massive scale. Based on the log schema you design for your application, the Kaa server constructs object bindings and APIs for your custom-tailored SDK. You then use these APIs to instruct Kaa to deliver log records to the back-end data processing and/or warehousing system. A Kaa endpoint temporarily caches log records and sends them to the server as soon as an upload trigger fires. Both temporary data cache implementation and upload triggers are pluggable and customizable.

On the server side, Kaa acts as a swiss army knife of data injection, supporting a framework of pluggable log appenders you use to load data into the database of your choice, to send this data to stream processing, or to make it available to custom data processing modules via REST, Flume, etc. Thus, with Kaa, you can do the data processing and analytics with your favorite tools, which is especially easy because Kaa ensures end-to-end structured data flow.

  • Pre-integrated with popular data processing systems
  • Easily expandable with data visualisation tools
  • Scalable to handle vast amounts of data

Complete application

The Kaa platform was created to streamline and secure the development of your IoT applications. It automates complex data management intricacies, provides virtually unlimited scalability, and gets you right into the business of creating what is most important: your application’s business logic. A few more things while you are here...

  • You can build any application on top of Kaa; there is vast freedom as to the target programming language, device type, and data models.
  • You can plug in your own modules, analytics systems, visualization tools, and assemble a perfectly fitted solution for your case.
  • You can take advantage of a variety of demo apps, tutorials, and our friendly forum.
Ready to try it out?

Get started