The Omzlo One is a wired IoT Arduino-compatible platform with interesting features supporting home automation and sensors:

• You can use an Ethernet cable — or just 4 plain wires — to connect your Omzlo One devices to one another in a chain that can reach over 100 meters,
• One cable is used to bring both power and a CAN bus network working at 125000bps,
• It features an atmega328pb 16Mhz microcontroller with full Arduino Uno pin-level compatibility to build more stuff,
• You control your network with the Omzlo USB controller connected to a PC or a Raspberry Pi.
• You can use the “Nocan” library to easily make your device talk to each other, with a super-simple “publish/subscribe” protocol, without worrying about the nitty-gritty details of CAN bus networks.
• You can use a web interface to upload Arduino sketches to any device in your network, without the need to physically plug a programmer in your device.
• You can use a simple RESTful Web API to control your devices, reboot, enumerate, etc.

The drawing above illustrates a network of 3 Omzlo One devices connected to an Omzlo USB Controller, which is itself controlled by a PC through USB:

• The Omlzo One nodes execute Arduino compatible sketches, send and receive messages.
• The Omzlo USB controller acts as an interface between the network and the controlling PC (I use a raspberry pi)
• The PC runs the Nocan web dashboard, which allows you to communicate with any device, upload new firmware, reboot, etc.

Update

The content of this page is not fully up to date with the project: 

• We are currently upgrading the node's hardware to SAMD31G18, like the Arduino Zero.
• We are replacing the USB controller with a Raspberry-pi HAT.
• We are making things even simpler.

Nevertheless the main principles of the Omzlo platform remain the same and this page can be considered as a good introduction to the project. For the very latest updates go to http://omlzo.com.

Making things simple

The Omzlo One is deigned to use a network protocol called “NoCan” that is build on top of CAN bus and abstracts away the complexity of dealing with CAN bus directly. NoCan is based on the principle of pub-sub (publish/subscribes): nodes simply subscribe and publish to specific “channels” and the underlying software does the magic (e.g. you publish “on” to the channel “garden/light” and the garden lights switch on). You can consider this as simplified version of MTQQ. The Nocan protocol also takes care of allocating distinct addresses to each Omzlo One device.

Using Nocan is simple. Consider the sketch below as an example: it illustrates the case of an Omzlo One connected to an Adafruit NeoPixel led. First the application does a bit of setup. It notably creates a channel called "color" and subscribes to it. Then each time the application receives a message, it interprets it as a 3 byte RGB color code and changes the color of the connected led accordingly.

#include <nocan.h>
#include <Adafruit_NeoPixel.h>
// one led, connected to pin 6
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(1, 6, NEO_GRB + NEO_KHZ800);
void setup() {
  pixels.begin();
  Nocan.open();
  Nocan.registerChannel("color");
  Nocan.lookupAndSubscribeChannel("color");
}
NocanMultiplexer<1> mux;
int8_t status;
void loop() {
  status = Nocan.processMessage(mux);
  if (status==0 && mux[0].length==3)
  {
     pixels.setPixelColor(0, mux[0].data[0], mux[0].data[1], mux[0].data[2]);
     pixels.show();
  }
}

The user can change to color manually by simply updating the value of the channel "color" in the Nocan web dashboard running on his/her PC, as shown below.

Nocan allows the creation of up to 64 channels on a network. In the example above, we didn’t need to check from what channel the messages came from because we are only subscribed to one channel. Nocan uses some filtering tricks to make sure your application will not receive any message that it has not asked for. The application will never waste time or be...