Overview

What is HIOT

HIOT - pronounced Hi Oh Tee is the Hierarchical Internet Of Things - an open protocol which redefines IOT to deliver infinite scalability and interoperability

HIOT is not just about the central platform, but uses a roles based architecture to enable you to distribute functionality and remove bottlenecks across a deployment. Roles such as Aggregators and Bridges are what differentiate HIOT as these allow for integration with any number of 3rd party solutions and devices while also enabling traditional platform-based data processing tasks to be executed on any device.


Existing IOT solutions can be extended to support HIOT by implementing the open HIOT protocol

In HIOT however, the data processing happens at or near the data source, spreading the data processing and aggregation workload across the entire deployment through the use of various device roles. As a result, far fewer platform resources are required.

In addition to the HIOT specification, there is also a partial implementation of the protocol written in NodeJS

Every element of HIOT is open source and available from our GitHub Repos. The key repos are listed below

  • HIOTProto, the HIOT Protocol Specification
  • Platform, the core cloud platform
  • Coordinator Link, a platform side inteface to a deployment
  • Device, Any device in a HIOT deployment shares a common base, with roles and addtional handler files augmenting the functionality

As HIOT develops and matures, we will be rolling out a SaaS solution

HIOT is an Open Protocol for IOT solutions

The HIOT Protocol is designed to cover all IOT communications

...

Work in Progres available on GitHub

Draft 1.0 due Q2 2018

HIOT is an open-source IOT ecosystem

Features

HIOT uses JSON based control manifests to describe the functionality and configuration of each device. Once a device is added to a deployment it can be reconfigured from the platform at any time and from anywhere.
We also have an Auto-discovery function built into each device so you can find and configure new devices at the click of a button
The JSON manifests & Auto-discovery functionality can be used to integrate new devices directly into your HIOT deployment, offering true plug-and-play capabilities.

HIOT implements multiple levels of distributed aggregation and control, allowing you to grow truly massive deployments.
Larger IOT deployments can "stack" Aggregators and brokers to minimise the number of messages and aggregation effort on the platform

A set of distinct roles (e.g. Aggregators and Brokers) can be distributed across all devices. By providing you with real-time data on the performance of each device in your deployment, HIOT can help you ensure that not only does everything work, but that it works as efficiently as possible. We cover this in A LOT more detail in the Architecture section.

As a "know-nothing" architecture, any compatible device or solution can be effortlessly integrated into HIOT, resulting in greatly reduced complexity and simplified integration and interoperability. Simply add a new device to your local network and run auto-discovery from any coordinator. The device can then be configured as part of your IOT deployment from any client app.

Benefits

Reduced Traffic

Smaller Attack Surface

Open Integration Protocols

Distributed data processing and aggregation - Fog computing everywhere

And so much more...

We have a number of preconfigured scripts & schematics to interface HIOT with real-world devices. Using simple, readily available components (like the $5 ESP8266 family of micro-controllers) you can quickly and easily start controlling HVAC, lighting, irrigation systems and so much more.

Have a look around and feel free to get in touch if you need some assistance

With our physical exception handling, we can not only inform you of problems and emergencies, but also act upon them on your behalf.

Everything within your environment is auditable and controllable through HIOT. We're not just about switching lights off when a room is empty, instead, we can monitor and control just about everything. No matter where you're deploying HIOT, the sky isn't even the limit

Because the Things in IOT don't run a full Operating System, but instead have a single, fixed API, the attack surface of your IOT deployment is greatly reduced. Being Open Source, every line of code is open to the scrutiny of the community.

... and we'll keep doing it. If you have a particular usage or strategy in mind for HIOT, let us know. We'd love to help you get the most out of it.

Components

It might seem obvious, but it's important to differentiate between the real-world sensor and the IOT "Thing" that receives data from it. Similarly, a controller (e.g. for your office HVAC system isn't part of the Thing that integrates with it.

In HIOT, the sensor and controller are part of the real-world environment, we use them to learn about and alter our environment and as long as we can get real-world data and make real-world changes we don't really care that much about them. This will make more sense later...

This is where the magic happens!

The Platform has everything you would expect; Dashboards, device configuration and monitoring tools, Controller interfaces, Analytics and Business Intelligence etc. In time, we're going to set up a demo platform to showcase some of the features you can expect from HIOT.

We have a number of implementations for you to choose from depending on your particular needs - from small Vagrant boxes and simple NodeJS implementations, to production-ready OpenStack deployment scripts and a whole lot in between

As with all the other components in HIOT, the key aspect of the Platform is the API (or in this case, APIs) - these are fully documented and available in our Wiki.

In HIOT, the Thing is the edge of the deployment. A Thing can connect to any number of Sensors and is only limited by its physical interfaces (e.g. GPIO pins.)

We like to keep our Things as simple as possible. While a lot of IOT SDK etc. focus on devices like Intel® NUC and Raspberry Pi® devices capable of running a 'full' operating system, we like to use much simpler devices for 2 reasons, 1) they're a fraction of the cost (useful if you're deploying thousands of Things) and, 2) they have a much smaller attack surface as they typically need to be physically connected to a boot-loader in order to update their code.

We're developed a full & free (in every sense of the word) API implementation for devices like the Arduino Uno and the WiFi enabled ESP8266-based Wemos D1 and D1 mini. We also have NodeJS and Java implementations for more demanding Things.

Aggregators are one of the truly unique concepts within HIOT.

Aggregators can be deployed anywhere in your HIOT ecosystem and are used to collate and aggregate data from things and pass them upstream towards the platform. Aggregators can be chained, or stacked, so that you can distribute the data processing workload across the ecosystem as your HIOT deployment grows.

There are some examples in the architecture section of the site that will provide more details on distributed aggregation.

Whereas Aggregators collect and aggregate data from Things and pass them up to the Platform, Brokers are responsible for receiving commands from the Platform and passing them on to the relevant Things, Aggregators or other Brokers. Like Aggregators, Brokers can be chained together enabling massive scalability by decomposing the HIOT deployment into smaller functional units

Typically, there will be one Coordinator per physical location (apart from any redundant devices that might be used in the event of a failure). A coordinator manages every HIOT device in the location and is the only device in the location with access to the outside world. There is no hard limit to the number of devices which can be managed by a single coordinator. The Architecture section has some details on the factors which could impact (positively or negatively) the performance of the Coordinator.

We've deliberately split the HIOT UI from the main cloud platform in order to allow users to develop their own front-ends or client apps. As well as that, the "Commander" and "Dashboard" repos on GitHub demonstrate how you can connect and engage with local devices in your deployment (rather than having to query the main platform)

Contact Us

Want to learn more? Just fill in your details and we'll get back to you.