Get in touch with your Things

Any object that can be attached to an Arduino microcontroller is a potential Things: get interaction in wireless or wired, acts automatically and is even remotely controllable from you smartphone or tablet.

Starts in three steps : get your building blocks, load Souliss and get your Things on the smartphone.

Do it simple!

Do it simple!
A network of Things in minutes for your Android and Arduino

Building Blocks

Building Blocks
Easily compose hardware

Souliss on AVRs

Souliss on AVRs
Load Souliss on your Things

Android App

Android App
Get your Things on your Smartphone

Sunday, June 21, 2015

First prototypes are ready!

Souliss Battery Boards, the first prototypes are ready!
Just got an email from KMP Electronics in the Inbox with some nice picture attached. Details will follow while will testing the boards.

This works with nRF24L01 radios and ESP8266 transceiver, with three sockets for Grove sensors and works on LiPo battery. Is designed to be as much as possible a plug&play solution for sensing data around your home and getting it into Souliss.

The UEXT socket allow extension with relay I/O and others while working on wall charger.

Souliss Battery Board with nRF24L01 radio
Now is time to find a name for this board and start playing with it.

Stay tuned!

Wednesday, June 10, 2015

Sensor Battery Board, PCB Arrived!

PCB for the Battery Board with nRF24L01 and ESP8266 support
Yesterday I got from our friend at KMP Electronics this picture, the PCB for the Sensor Battery Board has arrived in their facilities and the assembly of the first prototypes will soon start.

This board can stand a year or more on LiPo battery, the design remove all unnecessarily power waste while the module is in sleep, and the support for battery devices in Souliss will keep the usage simple.

In battery only mode the board will use the 2.4 GHz nRF24L01 radio, a socket of the ESP8266 is available to build a bridge that collect all the other boards. Is even possible use the ESP8266 while on battery, with a reduced battery life due to the higher consumption of the WiFi module.

Stay Tuned!

Saturday, May 30, 2015

Google I/O 2015 : Weave and the IoT

Google I/O 2015: Introduced Weave an IoT protocol

At I/O conference Google has introduced Weave, their protocol to standardize the communication between IoT devices, this isn't a new concept but Google can be strong enough to let Weave spread across devices and became a de-facto standard.

The only information that we actually have is a slide from the I/O talk, but the way Weave has been introduced lets assume that the protocol will allow devices to be discovered and able to describe their-self. A native support for Weave will be included in Android M with API exposed to App developers.

Weave Communication

This open a new scenario, where any Android app can access Weave based devices, as example a generic weather app can activate your sprinkler system to water your plants, without need a bind with the technology behind your sprinkler system.

If we look back, this was quite similar to a design that we tried to start a couple of years ago, just after Zozzariello an internal discussion on how to share data between application has been live for months, but nothing comes out. That's simply because after the design you need to be strong enough to get that protocol used, and of course we aren't.

So, what will be the impact on Souliss? Is simply a big opportunity, Souliss has yet an approach that let the nodes to be discovered and provide details on what they can do and it use a standardize communication between nodes using Typicals. Those are the features that Weave want to bring out in the cloud.

Souliss has been focused on Arduino AVR nodes, that generally are low performances devices that are not suitable to process complex ASCII protocols, the time will give more Arduino powerful devices, but that's not the way we want to follow. We will run a compatibility layer on SoulissApp and openHAB.

The Hardware-less approach, has been introduced with Zozzariello, it means improve without have to change your hardware. To keep a server-less approach SoulissApp will expose Weave through Zozzariello, that's basically the same that happen now with an our own JSON structure.
A server based approach will probably be based on a service that can run on a 24h powered home device, like a Raspi with openHAB.

This assume that Weave will be free for use and that the certification program will not be mandatory.

The release of Weave is expected at the end of the year, so we should still wait some months before know if it will became the IoT protocol.

Stay tuned!
Dario.

Thursday, May 28, 2015

Smart Home with ESP8266 and openHAB

Smart Home based on ESP8266 controlled via openHAB
Last weeks were full of news, as announced in a previous post we have started and basically completed the porting of Souliss on ESP8266 modules, isn't a simple use of the ESP8266 as a transceiver for an Arduino based on an Atmel AVR microcontroller, but is the Souliss framework itself that runs on the ESP8266. 
All has started from Saverio, it was Easter when he came out with the news, he compiled successfully most of Souliss code for an ESP8266 and after a couple of days we got some basic functionality available.This has been possible thanks to the amazing work of the guys that has ported the cores in the Arduino IDE for ESP8266.

Just the time to release a first try of Souliss for ESP8266 and a bunch of people in our mailing list were ready to test and share feedback, as result Souliss release v.7.0.5 is now ready to be installed from the Library Manager.

Just a couple of days ago we also got the official inclusion of the Tonino's binding in openHAB, so you can now officially use openHAB with a Souliss, and of course with ESP8266 running Souliss.

To use ESP8266 you need to install the relevant cores by ESP8266 community, this can be done directly from the Board Manager of your IDE using the instruction here. Then load the following sketch and follow the instruction to configure the binding.

 /**************************************************************************
    Souliss - Hello World
    
    This is the basic example, control one LED via a push-button or Android
    using SoulissApp (get it from Play Store).  
    
    Run this code on ESP8266 as WiFi SoC.
        
***************************************************************************/

// Configure the framework
#include "bconf/MCU_ESP8266.h"          
#include "conf/Gateway.h"                  
#include "conf/IPBroadcast.h"

// **** Define the WiFi name and password ****
#define WIFICONF_INSKETCH
#define WiFi_SSID               "mywifi"
#define WiFi_Password           "mypassword"   

// Include framework code and libraries
#include 
#include "Souliss.h"

// This identify the number of the LED logic
#define MYLEDLOGIC          0               

// Define the network configuration according 
// to your router settings
uint8_t ip_address[4]  = {192, 168, 1, 77};
uint8_t subnet_mask[4] = {255, 255, 255, 0};
uint8_t ip_gateway[4]  = {192, 168, 1, 1};
#define Gateway_address 77
#define myvNet_address  ip_address[3]  
#define myvNet_subnet   0xFF00
#define myvNet_supern   Gateway_address

// **** Define here the right pin for your ESP module **** 
#define OUTPUTPIN   5

void setup()
{   
    Initialize();

     // Set network parameters
    Souliss_SetIPAddress(ip_address, subnet_mask, ip_gateway);
    SetAsGateway(myvNet_address);  
    
    // Define a simple LED light logic
    Set_SimpleLight(MYLEDLOGIC);        
    
    pinMode(OUTPUTPIN, OUTPUT);  // Power the LED
}

void loop()
{ 
    // Here we start to play
    EXECUTEFAST() {                     
        UPDATEFAST();   
        
        // We process the logic and relevant input 
        // and output every 50 milliseconds
        FAST_50ms() {   
            // Drive the LED as per command
            Logic_SimpleLight(MYLEDLOGIC);    
            DigOut(OUTPUTPIN, Souliss_T1n_Coil, MYLEDLOGIC);                
        } 
              
        // Here we handle here the communication
        FAST_GatewayComms();                                        
        
    }
} 

Ensure that the pins available on your module matches the one in the sketches, so that you can control it via openHAB and of course SoulissApp.

Enjoy!

Saturday, May 16, 2015

Preview : Run Souliss on Olimex ESP8266-EVB

Expressif ESP8266 run Souliss directly on the module
A couple of weeks ago we got some Olimex ESP8266-EVB a small board to quickly prototype on the cheapest WiFi module for DIYers actually on the market, yesterday the porting of Souliss has been completed and now we can run directly on this module without have an Arduino ATmega inbetween.

The Arduino core for the ESP8266 is constantly updated and for this reason we are distributing an Arduino IDE for Windows that includes the tested cores (available here for download), just ensure that in your Documents/Arduino/libraries there isn't a Souliss library, this because the IDE that we provide contains also the latest Souliss code.

Run this sketch, considering the GPIO available on your module, this use GPIO5 that is used in Olimex ESP8266-EVB with a relay.

 /**************************************************************************  
   Souliss - Hello World for Expressif ESP8266  
   This is the basic example, create a software push-button on Android  
   using SoulissApp (get it from Play Store).   
   Load this code on ESP8266 board using the porting of the Arduino core  
   for this platform.  
 ***************************************************************************/  
 // Configure the framework  
 #include "bconf/MCU_ESP8266.h"       // Load the code directly on the ESP8266  
 #include "conf/Gateway.h"          // The main node is the Gateway, we have just one node  
 #include "conf/DynamicAddressing.h"     // Use dynamic addressing  
 #include "conf/DisableEEPROM.h"  
 // Define the WiFi name and password  
 #define WIFICONF_INSKETCH  
 #define WiFi_SSID        "mywifi"  
 #define WiFi_Password      "mypassword"    
 // Include framework code and libraries  
 #include <ESP8266WiFi.h>  
 #include "Souliss.h"  
 // This identify the number of the LED logic  
 #define MYLEDLOGIC     0          
 void setup()  
 {    
   Initialize();  
   // Connect to the WiFi network and get an address from DHCP  
   Setup_ESP8266();                
   SetAsGateway(myvNet_esp8266);    // Set this node as gateway for SoulissApp   
   // This node will serve all the others in the network providing an address  
   SetAddressingServer();  
   Set_SimpleLight(MYLEDLOGIC);    // Define a simple LED light logic  
   pinMode(5, OUTPUT);         // Use pin 5 as output   
 }  
 void loop()  
 {   
   // Here we start to play  
   EXECUTEFAST() {             
     UPDATEFAST();    
     FAST_50ms() {  // We process the logic and relevant input and output every 50 milliseconds  
       Logic_SimpleLight(MYLEDLOGIC);  
       DigOut(5, Souliss_T1n_Coil,MYLEDLOGIC);  
     }   
     // Here we handle here the communication with Android  
     FAST_GatewayComms();                      
   }  
 }   

If you have the Olimex module, is enough to press the button and then power the module, this set the module in firmware mode and let you load the code from the IDE using an FTDI at 3.3v as shown in Olimex post.

Using the ESP-01 and other modules from other vendors require an external connection as per following scheme
Connection between FTDI 3v3 and ESP-01

In the sketch insert your WiFi SSID and Password, once loaded the module connects to your router and you can control it directly from SoulissApp (download the app here) and the app will automatically discover your node.

The result is SoulissApp showing the node and the relay for control,
SoulissApp control the ESP8266
This is just a simple example, because the ESP8266 runs a full Souliss framework and you can communicate with other ESP and AVR based boards (where also wireless-RF and RS485 are supported) to have a full network between your nodes.

The support for ESP8266 has just started, use the community to get help and follow the wiki for details.