souliss

Souliss and Visual Studio 2019

2019-11-06T00:00:00+00:00

Using a convenient Integrated environment can ease the task of writing and mantaining your Souliss sketches, especially if it’s possible to use some of a modern IDE features. Visual Studio 2019, free in its community flavour, can be a relevant enhancement to your development environment. Setting it up to run and debug souliss sketches is really easy.

YOU WILL NEED:

Visual Studio 2019 - Download it at https://visualstudio.microsoft.com/
Visual Micro plugin, available directly from the IDE
An existing Arduino installation w/ Souliss library installed

For the installation of the Souliss library refer to relevant wiki guide. It’s not very up to date, But it’s easy to ‘map’ it to current Arduino version (1.8.10 at the time of this post). The Arduino IDE is still needed, as Visual micro plugin will be using libraries and boards installed on it. You could copy your environment and let Visual Studio use another one, I frankly didn’t notice any interferences though.

After having installed Visual Studio and chosen a comfortable theme, you can immediately install Visual Micro plugin, searching among online extensions (search for “arduino”). After a VS reboot and minimal setup (Arduino IDE path), fork https://github.com/souliss/demoNode, thus creating a new project. Please notice that for ease of setup I committed IDE-only files (.sln, .vcxproj, etc.) that shouldn’t really be there, but it’s pretty easy to create your own new solution (yes, that’s still the term used) starting from existing sketches.

I suggest to test a basic sketch before going on with Souliss’ ones, but as long as the plugin reads same folders and libs, you should have no issue in get up and debugging the demo node, with Souliss libraries linked and navigable directly from source code. Code auto-complete works, too.

Once set-up, Visual Studio will let you debug with ease, setting up conditional break-points and investigating variables values (with some obvious limitation)

STEPS:

Install Visual studio
Add Visual micro plugin and point it to your existing Arduino environment
[optional] Fork souliss demo sketch and test your environment

Tested with Arduino IDE 1.8.10 on Olimex Boards, using demoApp example by Shine 11/2019

SoulissApp Android 10 update

2019-10-31T00:00:00+00:00

Updating soulissApp is both a pleasure and a pain. Proud of mantaining a 7 years old app, born under Android 2 Gingerbread environment, it still takes some old legacy dependancy with it and several spiderwebs. Hard to update and/or mantain, especially because of the earthquaking environment. But it still works, I “just” had to redo backgroud services and remove much legacy code. This new version is compiled targeting sdk 29, aka Q, Android 10, but the biggest changes came adapting to previous Android’s major release.

Demo mode has been temporanely removed, as the public IP isn’t available any longer. Write us if you can host one and are willing to.

Please be patient, as this software is entirely free. As always, I’d be glad to receive some pull request and/or translations

CHANGELOG: Quite a long list, even though it doesn’t look so.

Preferences screen entirely re-made according to new Settings API.
Watchdog died. He was a good boy, but Android now forbids receiving system Intents
Because of Android 8.0 Behavior Changes, SoulissDataService has been deeply slimmed
New Font style, merged old (API < 19) ones
Several useless lint suggestions/forced changes
Migrated some dependency to Jetpacks. I don’t even know what does it mean, frankly.
Several once-fine deprecated methods updated

DST - Digital Souliss Thermostat

2018-03-08T00:00:00+00:00

The need to be able to find your heated environment when you return is a necessity that everyone must meet, and here it is born “DST”, the SOULISS digital thermostat based on the WiFi ESP8266-12 chip, connected to the 3.2 inch NEXTION HMI display allows you to manage your heating from a local area using a touch screen graphic interface, The DST can also be managed by SoulissApp (Play Store) both locally and remotely.

The graphic interface is divided into two different pages, the HOME PAGE and the PAGE SETTINGS:

INFO: Temperature and Humidity, ntp time, Setpoint set, WiFi connection status to the local router, System power status, Heating status Timer, Icon of light blue color when the temperature is below 17 ° C

CONTROLS: System power button, Setpoint setting, setpoint ECO, NORMAL, COMFORT timer 60m, 120m,

The timer function if set, will turn off the heaters at the end of the time …. if the timer will not be activated and the heating will be turned on leaving the decision to us, the timer will still count the time since the start, and if we decide later to to activate a time established by the timer menu, automatically it will decide the time already elapsed from the switching on.

The “DST” code is based on the Souliss Framework, and hosts the Telegram bot that alerts you in real time on your smartphone when the system and / or the heating systems are switched on or off. Update home page

COMPONENTS USED:

NodeMCU Esp8266-12 3.2 “Nextion DHT22 Temperature & Humidity sensor Relay ON / OFF Boiler For those who do not know what Souliss is, please read the corresponding wiki at https://github.com/souliss/souliss/wiki.

HOW TO START TO REALIZE THE PROJECT

First we need to install the necessary software on the PC to load the firmware on the ESP8266 chip Then download the 1.6.12 .zip version of the IDE Arduino, https://www.arduino.cc/en/Main/OldSoftwareReleases#00xx once downloaded we create a portable folder in C: \ programs and extract our IDE to ‘ inside the newly created folder.Done this we launch the IDE program from the .exe file, once started we must install the ESP8266 cores, here I report the extract taken from the ESP8266 support site http://esp8266.github.io/Arduino/versions/2.0.0/doc/installing.htmlCORE

ESP8266 Core installation:

Start Arduino and open Preferences window.
Enter http://arduino.esp8266.com/stable/package_esp8266com_index.json into Additional Board Manager URLs field. You can add multiple URLs, separating them with commas.
Open Boards Manager from Tools> Board menu and find esp8266 platform.
Select the version you need from a drop-down box.
Click install button.
Do not forget to select your ESP8266 board from Tools> Board menu after installation.You may optionally use the staging boards manager package link: http://arduino.esp8266.com/staging/package_esp8266com_index.json. This may contain some new features, but at the same time, some things might be broken.

You can always check the cores supported by Souliss at the following link If something is not clear, read this article http://souliss.github.io/media/how-to-load-a-sketch-on-ESP/ https://github.com/souliss/souliss/wiki/Supported%20Hardware#expressif-esp8266-based-board

After installing the ESP cores, we close the IDE, pick up the necessary libraries from my github repository at the following link https://github.com/Giuseppe-P/souliss-DST-CODE and the stable souliss framework https://drive.google.com/drive/folders/0BzyjHRwlzov4SmFkUXNNcFJ0LTg and once downloaded, copy the folders inside the path C: \ Users
xxxxx \ Documents \ Arduino \ libraries, now the IDE is ready to load the DST sketck “always available from my repository” on the ESP8266 chip.

TELEGRAM CONFIGURATION

Download and install the Telegram App from your Play Store, done this, for the creation of the bot I invite you to faces page at the following link http://www.nigiara.it/telegram/come-aprire-i-bot-su-telegram.htm

Without this we need the ID of the chat easily available by following these steps

First we start the chat by clicking on the button just created and type the command /start

So we open any browser at the address

https://api.telegram.org/bot/getUpdates

replacing the code generated during the creation of the bot. Now your bot is ready to receive the messages from the DST Souliss

FLASH SKETCH DST

I preferred to use the board nodeMCU ready for the USB connection, so before connecting it to the PC to load the sketch you need to set the ESP bootloader, and to do this just hold down the flash button on the board and then insert the cable usb to the pc.Now open the .ino file and automatically open IDE, and set the following parameters

Board as Generic ESP8266 Module
Flash Mode QIO
Flash Frequency 40 MHz
CPU Frequency 80 MHz
Flash Size 4M (1M SPIFFS)
Upload Speed 115200

Now you have to enter some parameters in sketch necessary to make the ESP work, consequently enter your SSID and PASWORD for Wifi, enter the required data for telegrams to receive status notifications,and upload the sketch to the board.

The first time the sketch is loaded via cable, subsequent updates can be uploaded via OTA http://esp8266.github.io/Arduino/versions/2.0.0/doc/ota_updates/ota_updates.html

NEXTION CONFIGURATION

First of all, download the https://nextion.itead.cc/resources/download/nextion-editor/ software from the following link and install it on your PC.

To load the firmware on the nextion we need a FTDI serial converter, I used the CP2102 and connected as follows

NEXTION——- ->FTDI GND————->GND TX————–>RX RX————–>TX 5V————–>5V

This done open the .HMI file downloaded from my repository, the program will open and the only thing you need to do to load the firmware on the nextion, is to click on the upload button

Once the loading is completed on the NEXTION we are ready to put into production our DST, connecting the coma components from the following diagram

After installation in the sApp we will have the Temperature slot, the Humidity slot, the Heating slot, the digital Input slot that will switch its status according to the boiler on or off, and the slot to dim the brightness of the nextion display.

Create your case and your frame according to your needs, I do not have 3D print files or preconfigured accommodation, this is just the hw / sw project.

I have adapted a frame for three buttons and I glued the display with hot glue and inserted the electronic board in the back space.

Controll remote openHAB or Souliss App

The system requires 5v 1.5a power supply

I hope I will be a great contribution.

Giuseppe Preite

Use the KMP DINo WiFi (ESP8266)

2016-10-30T00:00:00+00:00

The KMP DINo WiFi is finally here and has full support starting from Souliss v7.2.1 here we describe how get started with this board.

Generally the DINo WiFi can be used as any other ESP8266 based board, but there are some tips that you should not to get started quickly!

This board is a natural evolution of previous KMP DINo boards that has been largely used with Souliss, we worked closely with KMP while defining the requirements of this board and as result there are Grove and UEXT connector to easily expand the functionality of the board with external sensor and peripherals without additional wiring. As previous KMP DINo boards also the DINo WiFi has relays and opto-isolated inputs, is smaller than previous boards and share a similar switching regulated on-board power supply that goes from 5VDC to 30VDC.

The board comes boxed into a 3 modules DIN rail enclosure.

Loading Souliss on DINo WiFi

The first code upload need an USB to USART converter, next upload can use OTA. The board is not powered from the USART adapter so you need to connect and external power supply every time. The image below show the connection of the power supply wires and the correct position of the USART adapter provided (optionally) with the board.

The pin mapping is the classic one that can be found on many USB to USART adapter, the GND is on the right side of the header and a 3.3VDC adapter shall be used

Near the header used to connect the USB to USART converter there is a jumper and a pushbutton (visible in the below picture), jumping it will allow to program the board. As alternative, power-off the board and press the FLASH button, with the button pressed power-on and then start uploading the code.

Setup the Arduino IDE

Just program this board as any other ESP8266 using the following settings:

Flash Mode: QIO
Flash Frequency : 40 MHz
CPU Frequency : 80 MHz
Flash Size : 4M (1M SPIFFS)
Reset Methods : nodemcu
Upload Speed : 115200

The use of the portable mode in the IDE (just create a folder called portable) is suggested, so that all libraries and cores will be locally installed with in the IDE folder.

You can use the DINo WiFi with Souliss v7.2.1 (or greater) mixing WiFi and RS485 networks, a couple of examples are bundled to build a chain of boards connected via RS485 with a WiFi bridge.

The code below is for the Gateway

This code will connect via WiFi to SoulissApp and via RS485 to the Peers

/**************************************************************************
    Souliss - Lights
    It handle the four relays either via IN1 to IN4 inputs or using the
    Android interface. Connecting the relays to lights or similar electrical 
    appliance, you can get remote control of them.
    Connect multiple ProDINo Wroom via RS485 using the e08_WiFi_Lights_n2.ino
    on the peer boards.
        
    Applicable for:
        - Light
        - Other ON/OFF electrical appliance
    
    Runs on KMP Electronics ProDINo Wroom (WiFi ESP8266)
***************************************************************************/

// Let the IDE point to the Souliss framework
#include "SoulissFramework.h"

#include "bconf/DINo_WiFi_Bridge_RS485.h"   // Define the board type
#include "conf/Gateway.h"                   // The main node is the Gateway, we have just one node
#include "conf/Webhook.h"                   // Enable DHCP and DNS
#include "conf/DynamicAddressing.h"         // Use dynamic address

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

// Include framework code and libraries
#include <SPI.h>
#include <ESP8266WiFi.h>
#include <EEPROM.h>

/*** All configuration includes should be above this line ***/ 
#include "Souliss.h"

#define LIGHT1                  0           // This is the memory slot used for the execution of the logic
#define LIGHT2                  1           
#define LIGHT3                  2           
#define LIGHT4                  3           

void setup()
{   
    // Init the board
    InitDINo();

    // Connect to the WiFi network and get an address from DHCP
    GetIPAddress();                           
    SetAsGateway(myvNet_dhcp);       // Set this node as gateway for SoulissApp  
    
    // Define Simple Light logics for the relays
    Set_SimpleLight(LIGHT1);
    Set_SimpleLight(LIGHT2);
    Set_SimpleLight(LIGHT3);
    Set_SimpleLight(LIGHT4);    
    
    // This node will act as addressing server for the other peers in the network
    SetAddressingServer();
}

void loop()
{ 
    // Here we start to play
    EXECUTEFAST() {                     
        UPDATEFAST();   
        
        FAST_50ms() {   // We process the logic and relevant input and output every 50 milliseconds
        
            DigIn(IN1, Souliss_T1n_ToggleCmd, LIGHT1);          // Read inputs from IN1
            DigIn(IN2, Souliss_T1n_ToggleCmd, LIGHT2);          // Read inputs from IN2
            DigIn(IN3, Souliss_T1n_ToggleCmd, LIGHT3);          // Read inputs from IN3
            DigIn(IN4, Souliss_T1n_ToggleCmd, LIGHT4);          // Read inputs from IN4
        
            Logic_SimpleLight(LIGHT1);                          // Execute the logic for Relay 1
            Logic_SimpleLight(LIGHT2);                          // Execute the logic for Relay 2
            Logic_SimpleLight(LIGHT3);                          // Execute the logic for Relay 3
            Logic_SimpleLight(LIGHT4);                          // Execute the logic for Relay 4
            
            DigOut(RELAY1, Souliss_T1n_Coil, LIGHT1);           // Drive the Relay 1
            DigOut(RELAY2, Souliss_T1n_Coil, LIGHT2);           // Drive the Relay 2
            DigOut(RELAY3, Souliss_T1n_Coil, LIGHT3);           // Drive the Relay 3
            DigOut(RELAY4, Souliss_T1n_Coil, LIGHT4);           // Drive the Relay 4
        } 
        
        // Here we process all communication with other nodes
        FAST_GatewayComms();    
    }
    
    EXECUTESLOW() { 
        UPDATESLOW();

        SLOW_10s() {  // Process the timer every 10 seconds  
            Timer_SimpleLight(LIGHT1);
            Timer_SimpleLight(LIGHT2);  
            Timer_SimpleLight(LIGHT3);
            Timer_SimpleLight(LIGHT4);
        }     
    }
}

The code below is for the Peers

Each of the board running this code will connect to the Gateway via RS485

/**************************************************************************
    Souliss - Lights
    It handle the four relays either via IN1 to IN4 inputs or using the
    Android interface. Connecting the relays to lights or similar electrical 
    appliance, you can get remote control of them.
    Connect multiple ProDINo Wroom via RS485 using the e08_WiFi_Lights_n2.ino
    on the peer boards.
        
    Applicable for:
        - Light
        - Other ON/OFF electrical appliance
    
    Runs on KMP Electronics ProDINo Wroom (WiFi ESP8266)
***************************************************************************/

// Let the IDE point to the Souliss framework
#include "SoulissFramework.h"

#include "bconf/DINo_WiFi_RS485.h"   // Define the board type
#include "conf/DynamicAddressing.h"         // Use dynamic address  

// Include framework code and libraries
#include <SPI.h>
#include <ESP8266WiFi.h>
#include <EEPROM.h>

/*** All configuration includes should be above this line ***/ 
#include "Souliss.h"

#define LIGHT1                  0           // This is the memory slot used for the execution of the logic
#define LIGHT2                  1           
#define LIGHT3                  2           
#define LIGHT4                  3           

void setup()
{   
    // Init the board
    InitDINo();
   
    
    // Define Simple Light logics for the relays
    Set_SimpleLight(LIGHT1);
    Set_SimpleLight(LIGHT2);
    Set_SimpleLight(LIGHT3);
    Set_SimpleLight(LIGHT4);    
    
    // This board (peer) request an address to the gateway one at runtime, no need
    // to configure any parameter here
    SetDynamicAddressing();
    GetAddress();
    
}

void loop()
{ 
    // Here we start to play
    EXECUTEFAST() {                     
        UPDATEFAST();   
        
        FAST_50ms() {   // We process the logic and relevant input and output every 50 milliseconds
        
            DigIn(IN1, Souliss_T1n_ToggleCmd, LIGHT1);          // Read inputs from IN1
            DigIn(IN2, Souliss_T1n_ToggleCmd, LIGHT2);          // Read inputs from IN2
            DigIn(IN3, Souliss_T1n_ToggleCmd, LIGHT3);          // Read inputs from IN3
            DigIn(IN4, Souliss_T1n_ToggleCmd, LIGHT4);          // Read inputs from IN4
        
            Logic_SimpleLight(LIGHT1);                          // Execute the logic for Relay 1
            Logic_SimpleLight(LIGHT2);                          // Execute the logic for Relay 2
            Logic_SimpleLight(LIGHT3);                          // Execute the logic for Relay 3
            Logic_SimpleLight(LIGHT4);                          // Execute the logic for Relay 4
            
            DigOut(RELAY1, Souliss_T1n_Coil, LIGHT1);           // Drive the Relay 1
            DigOut(RELAY2, Souliss_T1n_Coil, LIGHT2);           // Drive the Relay 2
            DigOut(RELAY3, Souliss_T1n_Coil, LIGHT3);           // Drive the Relay 3
            DigOut(RELAY4, Souliss_T1n_Coil, LIGHT4);           // Drive the Relay 4
        
        } 
            
        // Here we process all communication with other nodes
        FAST_PeerComms();
        
        // At first runs, we look for a gateway to join
        START_PeerJoin();

    }
    
    EXECUTESLOW() { 
        UPDATESLOW();

        SLOW_10s() {  // Process the timer every 10 seconds  
            Timer_SimpleLight(LIGHT1);
            Timer_SimpleLight(LIGHT2);  
            Timer_SimpleLight(LIGHT3);
            Timer_SimpleLight(LIGHT4);              
        }     
        
        // Here we periodically check for a gateway to join
        SLOW_PeerJoin();        
    }
}

Enjoy!

Parliamo di SmartHome a Torino, Bologna, Milano e Roma!

2016-04-17T00:00:00+00:00

SmartHomeNow è una serie d’incontri incentrati sugli sviluppi degli oggetti domestici e la loro interazione con internet ed altre nuove tecnologie, quello che ieri era chiamato domotica ed oggi rientra nel più moderno concetto di SmartHome abbracciando l’IoT.

La formula è classica, con una serie di presentazioni brevi al mattino e tavoli di discussione al pomeriggio, ingresso gratuito ma a numero chiuso ed una selezione di partecipanti variegata, grandi società come Cisco, ABB e Gewiss, associazioni come Energy@Home, integratori e sviluppatori di soluzioni open-source.

La prima tappa di Torino è stata una sperimentazione e la principale ingonita era capire come potevamo collocarci all’interno di questo contesto misto, sopratutto nei confronti di società da anni nella domotica classica. La presentazione di Fulvio è stata diretta ed ha mostrato come soluzioni open-source possano porsi come alternativa ai prodotti commerciali, pur se diretta ad una platea di nicchia e competente.

L’interesse è cresciuto mostrando l’integrazione tra Souliss, openHAB ed altri strumenti per il monitoraggio dei dati raccolti nella rete.

Le slide principali sono riportate sotto come immagine, ma il file completo è disponibile.

Integrazione con openHAB

Monitoraggio distribuito riscaldamento

Consumi elettrici

Dall’esperienza positiva di Torino è nato l’invito per partecipare anche a Bologna, dove Alessandro ha introdotto con un taglio diverso la storia ed i motivi per cui è nato Souliss.

La presenza di un piccolo Laboratorio mobile ha poi permesso ai partecipanti di vedere qualche esempio da vivo, toccando con mano il lavoro delle notti insonni di Flavio ed Antonino con la loro idea di riuscire ad emulare NEST in open-source con SST.

Il risultato è stato interessante e l’impegno è quello di partecipare ad altre tappe tra cui Milano e Roma, dove probabilmente verrà replicato l’esperimento del laboratorio mobile per mostrare direttamente ai partecipanti come utilizzare Souliss.

Registrate la vostra presenza (l’ingresso è gratuito, ma la registrazione è obbligatoria) per le prossime tappe sul sito di SmartHome Now, ci vediamo al prossimo evento!

Using Eclipse Arduino IDE with Souliss

2016-03-13T00:00:00+00:00

This is tutorial how to setup Eclipse Arduino IDE to compile sketches using Souliss.

I assume you use Windows (Windows 7 64-bit in my case) - for other operating systems there are minor differences.

Download and install

Download Arduino IDE Bundle

I recommend to download whole bundle: Eclipse + Arduino IDE plugin in stable version V2.4_win64.2015-12-06_20-24-02

http://eclipse.baeyens.it/stable-win.html

Select 32 or 64 bit version, according to your Windows version.

I choose 64-bit version and downloaded V2.4_win64.2015-12-06_20-24-02.tar.gz file.

Unpack Eclipse Arduino IDE

Unpack V2.4_win64.2015-12-06_20-24-02.tar.gz using for example 7-zip, to any directory without spaces in name.

In my case it is: C:\Apps\eclipseArduino-V2.4_win64.2015-12-06_20-24-02\

Download Arduino IDE 1.6.5

You need exactly that version - 1.6.5!

Page: https://www.arduino.cc/en/Main/OldSoftwareReleases#previous

I recommend Windows ZIP file for non admin install: http://arduino.cc/download_handler.php?f=/arduino-1.6.5-r5-windows.zip

So you need to unpack arduino-1.6.5-r5-windows.zip to any directory. In my case it is: C:\Apps\arduino-1.6.5-r5\

You can also use Windows installer, but remember to use correct Arduino installation path later.

Download make.exe

Windows users need make utillity, because it is no more in Arduino.

Download from ftp://ftp.equation.com/make/32/make.exe and place on your PATH or in your Arduino IDE hardware\tools\avr\bin directory. In my case it is: c:\Apps\arduino-1.6.5-r5\hardware\tools\avr\bin

Configure Eclipse Arduino IDE

Launch eclipseArduinoIDE.exe

Configure Arduino plugin

Enter Preferences: Menu Window, Preferences
select Arduino on the left tree
Enter correct paths

You should see green text: ide is supported

If make.exe is on your PATH you can check test if make can be found and you should see green Make is found on your system.

If make.exe is in hardware\tools\avr\bin you will see make is not found on your system but it still should work.
Apply

Set the save before build option

Enter Preferences: Menu Window, Preferences
select General, Workspace on left tree
Mark Save automatically before build checkbox
Apply

Add `.ino` and `.pde` as C++ Source

Enter Preferences: Menu Window, Preferences
Select C/C++, File types on left tree
Press New.., enter .ino and select C++ Source File, OK
Again press New.., enter .pde and select C++ Source File, OK
Apply

Create and compile first Sketch

Create new Arduino Sketch based on blink example

Connect your Arduino board to computer
Menu File, New, New Arduino sketch or press New sketch on toolbar
Enter Project name, for example hello, Next
Select your board and COM port, for example Arduino/Genuino Uno, COM11, Next
In Select code choose: Sample Sketch. In Select Example code mark checkbox for Blink under 01.Basics, Next
OK

Compile (Verify) your sketch

Press Verify button on toolbar

On Console tab you should see many messages and at the end:

'Finished building target: hello'
Build Finished

On Problems tab should be no red Errors

Upload your sketch

Press Upload button on toolbar

On Console Tab you can see messages like this:

Starting upload
using arduino loader
Starting reset using DTR toggle process
Flushing buffer
Toggling DTR
Continuing to use COM12
Ending reset using DTR toggle process


Launching C:\Apps\arduino-1.6.5-r5\hardware\tools\avr/bin/avrdude -CC:\Apps\arduino-1.6.5-r5\hardware\tools\avr/etc/avrdude.conf -patmega328p -carduino -PCOM12 -b115200 -D -Uflash:w:C:\Apps\eclipseArduino-V2.4_win64.2015-12-06_20-24-02\workspace\hello/Release/hello.hex:i 
Output:

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e950f
avrdude: reading input file "C:\Apps\eclipseArduino-V2.4_win64.2015-12-06_20-24-02\workspace\hello/Release/hello.hex"
avrdude: writing flash (1030 bytes):

Writing | ################################################## | 100% 0.18s

avrdude: 1030 bytes of flash written
avrdude: verifying flash memory against C:\Apps\eclipseArduino-V2.4_win64.2015-12-06_20-24-02\workspace\hello/Release/hello.hex:
avrdude: load data flash data from input file C:\Apps\eclipseArduino-V2.4_win64.2015-12-06_20-24-02\workspace\hello/Release/hello.hex:
avrdude: input file C:\Apps\eclipseArduino-V2.4_win64.2015-12-06_20-24-02\workspace\hello/Release/hello.hex contains 1030 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.15s

avrdude: verifying ...
avrdude: 1030 bytes of flash verified

avrdude done.  Thank you.

avr/bin/avrdude finished
upload done

And your Arduino board should blink!

If uploading is very slow and you see on Console tab:

avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x39

it meanse you have communication problems.

Double check your cables and COM port number.

You can change COM port (or even board type)

Select in menu: Project, Properties
Select Arduino on the left tree
Correct your COM port and/or board type

Create and compile Souliss sketch

Download Souliss

Open https://github.com/souliss/souliss/ and Download zip (https://github.com/souliss/souliss/archive/friariello.zip)

Unpack Souliss

Unpack souliss-friariello.zip to your Arduino library - the same you configured in Configure Arduino plugin step as Private Library path. Rename souliss-friariello directory to just souliss.

Create new Arduino Sketch based on Souliss example

Connect your Arduino board to computer
Press New sketch on toolbar

Enter Project name, for example souliss-test, Next
Select your board and COM port, for example Arduino/Genuino Uno, COM11, Next
In Select code choose: Sample Sketch. In Select Example code mark checkbox for e01_HelloWorld under souliss and ethernet, Next
OK

Add libraries to your sketch

Menu Arduino, Add a library to the seleected project
Mark checkboxes on souliss and SPI, Finish

Exclude some souliss file from compilation

Because all souliss files (both .h and .cpp) are actually included in your sketch, compile must not compile .cpp files. So you need to exclude them from compilation!

In Project Explorer, expand your project, Libraries, souliss, select all directories from base to webhook

Then select from context menu Resource Configuration, Exlude from builds, Select all, OK

Directories base, bconf, … webhook should be grayed out:

Compile (Verify) your sketch

Press Verify button on toolbar

Sketch should build without errors (but with many warnings - it’s normal) and you can upload it to board.

How much power a smart bulb need?

2016-01-30T00:00:00+00:00

Recently GreatScott published an interesting video on the LYT bulbs by Authometion, he focused his interest mostly on power consumption and measured a very low efficiency and high power consumption for the LYT, he honestly admitted that his math was wrong, but lets go deep inside.

Let’s start from the result, the LYT88 consume approximately 8.7 W at full bright and has an electrical efficiency of 81%.

Now, take a bunch of minutes to see his video and read some comments

In the comments some users point out that those measure can be affected by the reactive power and for this reason GreatScott has posted as errata corrige new measures and some scope waveform.

This picture has shocked me, it shows the voltage and current waveforms for the LYT bulb at full bright, is not a sinewave at all. None of the standard theory applies in these cases and I discovered that myself as many others has too little knowledge on how to measure the power for such type of device.

LONG STORY SHORT: If you want to measure power, don’t fight with math! Use a power meter

Using a power meter is easy and quite cheap, the one in the picture isn’t a professional device but give an accurate enough measure to understand the power magnitude.

Now the question is, were the measure posted by Scott in the errata corrige right? The answer is a big no and we will see below the reason.

WHAT’S THE REACTIVE POWER

Powering a not resistive load like an electric motor with a sine-wave result in a sine-wave current with a different phase, from a physical point of view the device it self will source back some of the power that has sink. That portion of the power doesn’t produce any work because has a zero average value and is called reactive power.

Isn’t clear? The picture below shows the voltage, current and power for a resistive load (top) and inductive one (bottom). In case of an inductive load the power cross the zero and has negative values, while negative the load is sourcing back some of the power that has sink before crossing the zero.

In both resistive and inductive case, has been used normalized (1 V and 1 A magnitude) waves so you have the same peak value but different power values. That’s the reason why you cannot simply measure the magnitude and get the power, the angle position of the waves matters.

Without diving in details, you can use the cosine function of the angle between voltage and current (known as cosphi) to get the active power from the magnitude values. The active power is the one that does the work and is the one that you pay in your home bill. So, Scott has posted new measures and math using standard calculation that applies for sine-wave and has applied to the LYT that has a current that isn’t a sine-wave.

ESTIMATE THE POWER FOR A NOT SINE-WAVE CURRENT

There are multiple way to proceed but here we follow the short path, computer does the math for us and we can just apply the power formula, multiply voltage and power in a time constrained integral. Nowadays is easy, you just need to export the values from the oscilloscope and use a great tool like Scilab, but Scott didn’t exported the values.

So an estimation can be made calculating the normalized power of a voltage and current waveforms that are near to the one in the oscilloscope, here the code

The power waveform is always greater than zero and there is no reactive power but is too far from a sine-wave to apply any standard math, a discrete integration of that wave gives a normalized power vale that’s useful because is the scaling factor to be applied once we know the magnitude values. This is the equivalent of the cosphi for our wave.

WHAT A MULTIMETER MEASURE

So now we just need the magnitude (maximum value in the wave) for both current and voltage, easy? Not at all!

Without the values from the oscilloscope (because we don’t know the scaling factor and Scott hasn’t provided details about) the only source of information is the multimeter. In the video Scott has used a nice True RMS multimeter, so the measure is the mean square root value and not the peak value.

Using the measure from the video we have and applying the following scaling factor we can get the peak value

Measure	Waveform	Scaling Factor
Voltage	Sinewave	1/0.707
Current	-	1/0.365

The scaling factor of the current can be calculated as the RMS of the normalized wave

So, using the scaling factor we can get the peak values and applying the normalized power value we get the estimation of the power consumption as 10 W, that’s an estimation because the wave form was just a raw shape from a picture and not an export from an oscilloscope.

These 10 W are a most reliable estimation and shows the proper way to follow, at the end the long story short is the way to proceed, using a watt-meter that shows 8.7 W used on the AC side.

Back to the efficiency, the measure on the DC side at full bright are free from PWM and are supposed to be mostly constants because the microcontroller power consumption (that is clock driven) is negligible compared to the LED ones at full bright. So the 7.05 W on the DC side can be considered a good measure and compared to 8.7 W on the AC side gives a good 81% of efficiency.

UPDATES

Gabriele has a professional meter and after reading the post has done some measures on the bulb. I’ve got the export from his scope and applied the integral into a period of time to get the average power on AC and DC side, with a 82% efficency as result in the case of 2.5 W consumption on the AC side.

The measures as well as the Scilab code to get the plots are available here.

Enjoy!

The new ESP8266 based ProDINo is coming!

2016-01-24T00:00:00+00:00

This is the time where more and more ESP8266 based devices are popping-up and KMP Electronics is coming also with a new design, a ProDINo based on the popular WiFi SOC. In these years we had a very close partnership with KMP Electronics and the design of the new board has started based on a common brainstorming on specification required by the new module.

The board carriers four relays and four opto-input as the previous DINo and keep the RS485 transceiver to create mixed WiFi/Ethernet network, as well as UEXT and Grove connector for easy expansion.

This is an earlier design started around our experience with ESP8266 and RS485, the new WiFi ProDINo (the final name hasn’t yet been defined) will keep compatibility with the actual ProDINo based on Wiznet W5200, so that you can build a Souliss based network with a mix of Ethernet, WiFi and RS485.

Specification	Type and Nominal Value
Power Supply	DC/DC Switching from 9 to 30 VDC
SoC	ESP8266 - ESP-12
MCU	32-bit RISC CPU based on Tensilica Xtensa LX106 running at 80 MHz
Communication	WiFi - IEEE 802.11 b/g/n
Communication	Half Duplex RS485 - TIA-485-A
I/O Expansion	I2C MCP23S08
Input	No. 4 Opto-isolated
Output	No. 4 Monostable Relay 15 A / 10 A
Programming	Via onboard USB connection
Expansion	Grove and UEXT
Terminal	Pluggable

Overall the new board will be smaller than the actual ProDINo and will get more flexibility from the pluggable terminals and the expansion connector based on Grove and UEXT, price and release date are not yet available, but on these pages will get all the updates.

Stay tuned!

Have fun with WiFiPixels

2016-01-16T00:00:00+00:00

Far from the New Zeland the WiFi Pixel has arrived in my mailbox, this is a combination of a NeoPixel Ring and an ESP8266 WiFi SoC that gives the awesome effects of 16 WS2812 addressable LEDs.

The WS2812 combine three LED (Red, Green and Blue) and a small circuit that acts as a shift register 24 bit memory. So you can use a proper waveform to have it store a color as input and as any shift register it output the previous value, the result it that a single pin can drive an array of LED with the length as you want.

The below image by Adafruit shows the internal view of the addressable LED

Assuming that you know how to use the Arduino IDE and the ESP8266, you just have to download the Adafruit NeoPixel library and have the latest Souliss release (v7.1.1 at time of writing) to run the following sketch

/**************************************************************************
    Souliss - WiFi Pixels

    Control a WiFi Pixels board from Android or openHAB, it network the node
    so that you can control the light effect also from other Souliss nodes
    using peer to peer send or listening for broadcasted/multicasted topics.

    Need Adafruit NeoPixel library.

    Run this code on one of the following boards:
      - Protoneer WiFi Pixels
      - An ESP8266 with WS2812 LEDs

***************************************************************************/

// 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

// **** 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 <EEPROM.h>
#include "Souliss.h"

// Dependency
#include <Adafruit_NeoPixel.h>

// WiFi Pixels pin
#define WS2812_PIN        2
#define WS2812_PIXELS     16

// Souliss logic (aka typical) slots
#define LEDCONTROL        0
#define LEDRED            1
#define LEDGREEN          2
#define LEDBLUE           3
#define ALLTHESAME        4
#define COLORWIPE         5
#define THEATERCHASE      6

/*** 
    Color Effect Mode:

        4 - All The Same
        5 - Color Wipe
        6 - Theater Chase
***/
uint8_t coloreffect=ALLTHESAME;

// Index of the addressed pixel
uint8_t i_coloreffect=0;    
unsigned long timedelay=millis();
#define TIME_DELAY           50     // Not stopping delay in milliseconds

// Init the LED object, refer to Adafruit NeoPixel library for more details
Adafruit_NeoPixel strip = Adafruit_NeoPixel(WS2812_PIXELS, WS2812_PIN, NEO_GRB + NEO_KHZ800);

void setup()
{   
    Initialize();

    // Get the IP address from DHCP
    GetIPAddress();                          
    SetAsGateway(myvNet_dhcp);                  // Set this node as gateway for SoulissApp                        

    Set_T16(LEDCONTROL);                        // Set a logic to control a LED strip
    Set_T11(ALLTHESAME);                        // Set a button for the All The Same effect
    Set_T11(COLORWIPE);                         // Set a button for the Color Wipe effect
    Set_T11(THEATERCHASE);                      // Set a button for the Theater Chase effect

    // Init the pixels
    strip.begin();
    strip.show(); 

    // Init the All The Same mode as default
    mOutput(ALLTHESAME) = 1;
}

void loop()
{ 
    // Here we start to play
    EXECUTEFAST() {                     
        UPDATEFAST();   

        // Execute the code every 10 milliseconds   
        FAST_10ms() {

            // Execute the logic that handle the LED
            if(Logic_T16(LEDCONTROL)) timedelay=millis();
            setColor();

            // Just process communication as fast as the logics
            ProcessCommunication();
        } 

        // Execute the code every 110 milliseconds  
        FAST_110ms() {
            
            // Select the effect mode
            if(Logic_T11(ALLTHESAME)) {
                coloreffect = ALLTHESAME;

                // Reset the other color mode
                mOutput(COLORWIPE) = 0;
                mOutput(THEATERCHASE) = 0;
            }

            if(Logic_T11(COLORWIPE)) {
                coloreffect = COLORWIPE;

                // Reset the other color mode
                mOutput(ALLTHESAME) = 0;
                mOutput(THEATERCHASE) = 0;
            }

            if(Logic_T11(THEATERCHASE)) {
                coloreffect = THEATERCHASE;

                // Reset the other color mode
                mOutput(COLORWIPE) = 0;
                mOutput(ALLTHESAME) = 0;
            }

        }

        // Process the other Gateway stuffs
        FAST_GatewayComms();

    }
    EXECUTESLOW()
    {   
        UPDATESLOW();

        SLOW_10s()  {

            // The timer handle timed-on states
            Timer_LED_Strip(LEDCONTROL);                      
        }     
    }       
}

// Set the selected color and effect
void setColor() {
    
    if(coloreffect==COLORWIPE)          colorWipe();
    else if(coloreffect==THEATERCHASE)  theaterChase();
    else                                alltheSame();

    strip.show();
}

// Set the same color for all pixels
void alltheSame() {
    uint32_t c = strip.Color(mOutput(LEDRED), mOutput(LEDGREEN), mOutput(LEDBLUE));

    for(i_coloreffect=0;i_coloreffect<strip.numPixels();i_coloreffect++)
        strip.setPixelColor(i_coloreffect, c);
}

// Set the current color one pixel per time
void colorWipe() {

    // Update periodically
    if((long)(millis()-timedelay)>0) {

        uint32_t c = strip.Color(mOutput(LEDRED), mOutput(LEDGREEN), mOutput(LEDBLUE));

        strip.setPixelColor(i_coloreffect, c);
        i_coloreffect = (i_coloreffect+1) % strip.numPixels();
        
        timedelay = millis() + TIME_DELAY;
    }
}

// Turn the third pixel and shut the previous
void theaterChase() {

    // Update periodically
    if((long)(millis()-timedelay)>0) {

        uint32_t c = strip.Color(mOutput(LEDRED), mOutput(LEDGREEN), mOutput(LEDBLUE));

        strip.setPixelColor(i_coloreffect, c);
        strip.setPixelColor(i_coloreffect+2, 0);
        i_coloreffect = (i_coloreffect+3) % strip.numPixels();

        timedelay = millis() + TIME_DELAY;
    }
}

In SoulissApp you will have direct control of the main color and you will be able to select a light effect between three choices, more can of course be added, just keep in mind that Souliss is running in the background and effect shall not stop the code execution.

Enjoy this little light module and share were you will use it!

Smart Socket Hack Tutorial

2015-12-25T00:00:00+00:00

These 2200W wifi controlled Smart Sockets are available from suppliers on Ebay for about £15 - they are available with various Mains input plug formats (Europe, UK, US), they have multi-standard Mains output sockets, onboard USB charging socket, onboard configuration push button, and 2 onboard LEDs (green and blue).

In a Nutshell

This article is more than just a tutorial, it is also a ‘Goodies Bag’ offering some other helpful nuggets. The tutorial shows how to hack the Smart Socket to remove its original wifi board and fit an alternative ESP8266 stripboard DIY replacement, resulting in a user-programmable versatile switched-mains power socket that is capable of being used with any of the ESP8266 programming and control alternatives such as AT commands, Lua scripts, MicroPython, Arduino sketches etc, and particularly Souliss (link to go here).

It is a safe low voltage hack because none of the potentially dangerous Mains stuff is involved, and the hack can be powered via a 5v USB cable for testing and flashing, so the Smart Socket is only plugged into the Mains for usage after being completed.

It uses an ESP-12 or similar (ESP-202, ESP-07 etc), a BMP180 temp+humidity sensor (or BME280 which also includes barometric pressure), a small logic level converter module, four 10K resistors, and a 0.1uF bypass capacitor.

Note: If you would prefer to include this hack functionality into your own home-built switched socket(s), see the Footnotes section at the end.

The Souliss example sketch can integrate the Smart Socket as a peer node or gateway on the Souliss automation network (the gateway can also include peer functionality) thereby allowing it to be controlled by android devices using SoulissApp.

###Why Bother?

If you are a visitor to Souliss and wondering why bother going to the effort of ESP-8266 conversion just to arrive back at a similar starting point with phone app control of the Smart Socket, here’s a brief overview of Souliss to explain why…

Compare Souliss to the global postal service:

Souliss peer ‘nodes’ are the equivalent of postal addresses.
The Souliss ‘gateway’ is the local post office which routes all unopened mail from the sending addresses to the appropriate delivery addresses.
Postal address ‘nodes’ may have multiple mail-box ‘slots’ for multiple residents (GPIO slots).

Sure, you could create an alternative local delivery system, but the real power of the postal service lies in its ability to reliably deliver messages globally from door to door anywhere around the world without the end-users ever needing to know details of the road, rail, sea and air transport stages that were required for the delivery. Similarly, the true power of Souliss lies in its sophisticated hidden delivery infrastructure which allows messages to be automatically routed and transparently bridged across different types of network media (Ethernet, Wifi, RF, RS485, Serial etc). Souliss also includes a ‘quickie’ postcard-like system for optimal communication efficiency which allows nodes to send concise ‘typical’ standardised event-related messages which can be automatically responded to by receiving nodes where applicable, and the free android SoulissApp contains appropriate corresponding controls and status displays for these standardised ‘typical’ messages (plus other goodies such as voice control). Peer to peer interaction is autonomous, so no additional controlling hardware or software is required, but Souliss can be integrated with OpenHAB (open-source) home automation computer systems if wished. It is also possible to access nodes via web browsers. Software will soon be available that can treat a Souliss ESP node plus its relevent sensors and devices as a simple ‘black box’ that can easily be configured via web page then re-programmed wirelessly ‘Over The Air’ without requiring any programming skills or knowledge… essentially ‘Souliss IOT for Dummies’ like me.

What all this means is that with minimal effort and programming knowledge it is relatively easy to get Souliss nodes interacting with each other across different network media, and to have overall android or web remote control and monitoring of everything, on an extensible automation framework which can accomodate evolving automation systems without requiring any major restructuring, and because Souliss runs on the ubiquitous Arduino framework its nodes can offer integration of almost anything that can be done using an Arduino or ESP8266.

And all for free, because Souliss is open-source, and driven by a knowledgable and welcoming community who are ever reaching out to new horizons, and ever ready to give help and advice whenever needed.

So that is the incentive for using Souliss, but it is not an essential requirement of this hardware hack, which allows the ESP8266 to be used with whatever software is preferred.

###Smart Socket Hack

This hack is intended for DIY construction on a postage stamp sized piece of stripboard, and is aimed at people like myself who don’t have any PCB design or manufacturing resources.

The hack has a basic Souliss sketch available to provide quick and simple Android remote control of the Smart Socket, but the real benefit comes from what else is possible.

For example, the switched-socket hack also includes an internal temp+humidity sensor which offers potential for environmental monitoring using SoulissApp or Internet Web Browser, plus automatic environmental triggering of other peer to peer nodes, and even the potential for the Smart Socket to be a local self-contained programmable thermostat.

Additionally, other external sensors can be plugged in via the USB socket - perhaps a PIR sensor for occupancy detection, or an LDR for automatic light level switching, or both together, plus almost any other analog and digital sensors you could realistically need.

The USB socket also provides easy external ‘flashing’ access to the ESP using ‘mode-sharing’.

All the ESP hack hardware details are offered, but it is for users to provide appropriate software to exploit their hardware potential.

###Onboard Facilities

The interesting elements of the Smart Socket are a 3.3v regulator, two LEDs, a pushbutton, a USB charging socket, and a transistor-driven 20A relay with ‘back-emf’ protection diode.

This hack uses a couple of GPIOs to provide an i2c bus for sensors, a couple more for relay and button controls, and optionally a couple for independent control of the 2 LEDS.

###USB Charging Socket

The Smart Socket has a USB charging socket which provides 5v and Gnd on the outer pins.

The USB 5v also supplies a 3.3v regulator on the Mains board which powers the wifi board.

A useful consequence of this is that the onboard electronics and hack can be safely tested or re-flashed simply by plugging in an external 5v USB male cable into the USB socket, without the Smart Socket being connected to the Mains or being Live during testing or re-flashing.

An added bonus is that the 2 inner USB serial data pins which are not being used by the Smart Socket are therefore available for hack purposes, and can provide:

Quick plug-in external access to RX and TX for easy re-flashing.
Quick plug-in access of external analog and digital sensors.
Quick plug-in access for re-flashing AND external sensors - this takes advantage of the fact that when in flashing mode the GPIOs are floating, and when in normal mode the TX and RX lines are floating… so the 2 USB data wires can be ‘mode shared’ without conflict.

###Hack Circuit

This hack uses i2c to communicate with internal and external sensors, and so uses a Logic level Converter module to interface the ESP 3.3v i2c pins to the 5v USB socket.

GPIO2 is used for SCL because it requires a pullup, and the BMP180 internal sensor already has 4.7K i2c pullups on board, which can conveniently also be used for the GPIO2 pullup.

GPIO13 is used for SDA, with similar i2c pullup from the BMP180.

RX is paired with GPIO13 for mode-sharing of SDA on the USB (-) data line.

TX is paired with GPIO2 for mode-sharing of SCL on the USB (+) data line.

GPIO0 is used for reading the ‘WPS’ button, allowing the button to conveniently set the ESP into flashing mode at Reset/PowerOn, and also be used for user input if required.

GPIO15 is used for the ‘active high’ RLY1 relay because it needs a pulldown resistor anyway.

By default the hack board track bridges the Green RLY1_LED to WPS for visual confirmation of button presses, and similarly bridges the Blue RLY2_LED to RLY1 to echo relay status.

(The relay draws negligable current because of it’s 4.7K transistor base resistor, and the LEDS have 1K series limiting resistors, so each adds less than 5mA load to a GPIOs 12mA max output)

Options 1 & 2 omit the LED wires by bridging the LEDS on the Mains board solder pads.

Option 3 uses GPIO5 and a track cut to give independent software control of the Green LED.

Option 4 uses GPIO4 and a track cut to give independent software control of the Blue LED.

Option 5 simply replaces the BMP180 with a BME280 to also read barometric pessure.

That’s quite a lot of functionality to squeeze onto a stripboard area the size of a postage stamp. All the necessary information is present, so If you are confident of where you’re going and how to get there then feel free to go ahead and ‘do your own thing’, but be aware that even with much careful planning there is only just enough room for things to fit, so if you prefer to tread in known footsteps then follow the step-by-step instructions carefully. No electronics knowledge is required, just some competence with a soldering iron and the ability to use a small file and hacksaw blade, but you are assumed to already know how to ‘flash’ your ESP.

Many accompanying pictures and diagrams have been included in an effort to lead by example. Besides showing what to do, they also show what’s already been done and therefore is plainly possible, and should offer confidence that if a short-sighted pensioner (me) can do this hack then anybody else can too. When you are ready, let’s get started.

###Disassembly

Remove the screws and the front plastic cover, taking careful note of the location and positioning of a loose un-attached clear piece of plastic which is sandwiched underneath the front cover - it’s placement is not particularly obvious, but it is there for a reason (safety), so needs properly replacing again during final re-assembly.

None of the Mains stuff needs to be interfered with, and the hack is easily achieved with the thick blue internal Mains wires still attached, so leave them alone to avoid any problems.

###Connections

Looking underneath the Mains pcb, and ignoring the 2 larger structural side joints for the moment, you will see three groups of 3, 4, and 5 small solder pads which attach the wifi pcb to the Mains pcb (see the pic above).

From left to right, the first group of 3 are: Gnd, 3v3, Gnd

The second group of 4 are: WPS, RLY1_LED, RLY2_LED, RLY1

WPS goes to the mains boards ‘config’ push-button which switches directly to Gnd.
RLY1_LED goes to an ‘active-high’ green LED via a 1K series current limiting resistor.
RLY2_LED goes to an ‘active-high’ blue LED via a 1K series current limiting resistor.
RLY1 goes to the 20A Mains switching relay via a transistor and its 4.7K ‘base’ resistor.
The third group of 5 are just spare outputs from the wifi board and are not used by the Smart Socket, so you don’t need to worry about reconnecting to any of those.

Nor do you need to worry about reconnecting to the 2 Gnd pads each side of the 3v3, because the 2 side structural joints are both Gnds anyway and much easier to solder to, and likewise it is easier to pick up +3.3v from the Mains board C11 capacitor than the smaller 3v3 solderpad.

Also don’t worry about the tiny SMD component which is bridging the WPS pin to its neighbour, because we won’t be needing that anymore.

###Better Than Expected

Out of the 12 small pads that need de-soldering to remove the old wifi board, only the centre group of 4 require reconnection again (and perhaps only 2 of them, depending on chosen options). And to make things easier for soldering wires to the 4 solder pads we will be cutting out a lower access slot on the replacement wifi board (see above) to offer better unhindered access… so hopefully the job is not as daunting as it may have initially appeared.

I had been expecting removal problems, but it was much easier than first thought. All the pads and joints de-soldered ok (including the SMD component), and the wifi module was able to be removed in one piece without causing any damage or needing to nibble bits away with cutters. It’s certainly worth de-soldering everything twice though, and using a magnifier to double-check for remaining solder splashes rather than risk ripping off any pads or tracks.

After the original wifi board is removed, re-tin the required group of 4 pads on the Mains board with a blob of solder to aid re-attaching wires. Don’t re-tin the side structural joints yet though, because that could obstruct sliding the replacement board over the slots.

###A Tight Squeeze

If you view the underside of the top cover you can see the integral plastic walls which fit over and around the Mains pins to insulate them from the rest of the protruding electronics.

The position of the insulating walls is marked by white lines on the Mains board pcb, so you can use the line as a guide of how much room is available to fit your hack into - everything on the wifi board needs to fit between the white line and outside edge of the Mains board.

(Pictures of an earlier hack version which included internal DHT sensor and flashing socket)

Follow the instructions carefully and everything fits in ok as shown above - there is not much room to get away with poor soldering though, so the following soldering tips are for those who would welcome them to help improve results, and for others to just skip over.

###Soldering Tips

My own soldering is terrible due to poor eyesight… a case of take aim, dive in for a couple of seconds (timing is everything) then check for damage afterwards with a magnifier (I sometimes miss target completely and discover I’ve soldered an empty adjacent track). So I wouldn’t have a hope in hell of soldering anything if I didn’t heed the following points.

The difference between soldering success or failure is mainly just a matter of having the patience for cleanliness and attention to detail. Impatient or lazy soldering shortcuts inevitably have unwanted consequences… which may seem obvious when you know, but can be a hard lesson to learn, and makes much more sense if you know the reasons why.

Soldering requires heating the local area of the two items to be joined sufficiently for the solder to melt into them and create a molecular bond… so what’s to go wrong?

Well, if heat is applied for too long (for whatever reason, and there are many) it causes overheating of surrounding areas, resulting in charred insulation, naked wires, de-laminated tracks, possibly even component damage. If that sounds familiar, then there is room for improvement, which is fairly easy once you know the reasons for the problems, and how to avoid them.

Solder will only fuse with clean metal, so any impurites will hinder or prevent it from fusing. Therefore ensure no plastic cable insulation can make contact with the joint, or it will contaminate the area and repel the solder away to prevent it from bonding.

Gold is used for contacts because it doesn’t react with air to cause the surface corrosion problems that plague copper and alluminium. Those cheaper conductive metals just have a spray laquer coating to act as an air barrier, because without protection the copper will react with oxygen in the air to form a tarnished green copper oxide coating, and aluminium will similarly go black. But oxides aren’t metal, so they will repel solder. Fine abrasive paper can get back to clean shiny metal suitable for soldering, but it won’t last long.

Multi-core solder contains veins of flux, which acts like a sort of active detergent for breaking down the surface tension barriers between the different metals to help the solder ‘run’ and flow evenly between them. But the active life of hot flux is brief (it’s the few seconds of wispy smoke seen from freshly melted solder), so continued heating just leaves a charred contaminating residue which actually repels solder and prevents it from flowing - and continued stubborn overheating inevitably makes things worse, eventually degrading the conductive metalic solder into a dirty carbonised resistive blob of impurities which will never bond to metal… resulting in a mechanically and electrically unsafe ‘dry joint’.

To avoid that, the hot clean soldering iron tip needs to be applied to the clean joint for maximum heat transfer for minimum time necessary for the solder to run and fuse into the metals - ideally for just a brief ‘dab’ of a second or two. But before even trying, touch solder onto the soldering iron tip to make sure the solder melts quickly (within 1 second) - because the dirtier the tip, the poorer the heat transfer, the longer it takes the solder to melt and flow… and every second of excessive heat on the joint can be causing worsening damage.

Don’t leave the soldering iron switched on when it’s not being used. Don’t leave the heated tip to dry out for any length of time, keep it ‘whetted’ with solder to prevent it burning. The tip should be shiny silver, any dullness shows a coating of impurities building up which will act as a barrier to heat transfer as well as contaminate any fresh solder and flux applied to the joint. So clean the tip frequently on a damp sponge to remove the dead solder, then ‘whet’ it again with a drop of new solder. And do it before every joint… a clean fresh bead of solder on the tip offers much better surface contact area and quicker heat transfer than the small point of contact of a crusty dry tip.

Dirty residues will still gradually build up and blacken the tip anyway, causing contamination of the fresh solder and flux before it can do its job, but a quick poke into a metal mesh tip cleaner then a fresh blob of solder should make the tip shiny again.

All surfaces should be in good physical contact with each other to give good heat transfer, otherwise it is effectively trying to create a hot solder bridge across a colder air gap between surfaces at different temperatures… which ain’t gonna work!

It is important for the soldering iron tip to make good contact with both surfaces to be joined at the same time so that they both heat equally quickly, because if the tip only touches one surface then the heat must transfer all the way through that first item before it can get to the second surface sufficient to fuse solder into the metal… by which time the first surface is already overheating and causing problems.

The flat surface of a bevel or chisel tip provides a bigger surface contact area for increased and quicker heat transfer from the iron. If using a pointed tip, instead of using the pointy end, try using its side, held parallel to the joint to offer more side surface contact area.

The first stage of the hack is to create a stripboard carrier, so there’s no way the copper track will be clean after such handling, Invisible finger-prints are a greasy mask to flux chemistry which repels molten solder and prevents it bonding to the metal below, so it is important to ensure no contaminants are lurking on any surface to act as a barrier which interferes with the flux process and obstructs the clean molecular flow of the solder. I have an old toothbrush and jar of acetone on hand to ensure removal of any invisible sweaty fingerprints, and some fine abrasive paper for making dull surfaces shiny… but things don’t stay shiny for long, so clean just before use.

Due to the tight squeeze, some wires need soldering directly to the copper tracks (rather than the usual luxury of soldering convenient conductors poking through from the component side). So although it might seem convenient to poke a trimmed wire end into a handy hole on the copper side for soldering to the track, the tip will have so little conductor available for heat transfer that it will end up melting the plastic insulation which will contaminate both flux and solder, requiring even more heat, making the mess ever worse.

The solution is easy… pre-solder (‘tin’) the required area of copper track first, and also the bared cable end, then bend it at right-angles and trim off the surplus. Leave sufficient tinned conducter sticking out sideways from the insulation to provide good physical contact with the track and offer somewhere more tangible for ‘dabbing’ the freshly-cleaned and ‘whetted’ tip in order to quickly fuse the two pre-soldered surfaces together. If it takes long enough to burn your fingers while holding the wire in place, then it’s taken too long - and if you jerk away and cause movement in the molten solder just as it’s solidifying it will cause it to crystalise into a dull dry joint that has resistance and can cause all sorts of problems.

The melting point of solder is obviously much lower than of the metals to be soldered, so when in doubt, remember the surest way to ensure a good, quick, clean joint is to pre-solder the two surfaces first. This allows both surfaces to already have a fused layer of solder so that when they are brought together for joining it takes significantly less time heating the two touching pre-soldered surfaces sufficient to re-melt together, than it would to also heat up their underlying metal surfaces sufficient for solder to fuse into the metal.

Lastly, if you don’t want shiny copper tracks and joints to tarnish and corrode, brush them clean with solvent to remove flux residue, then seal from the air with a light spray of laquer.

###Stripboard

The key to success for this Smart Socket hack is to pre-prepare a suitable replacement wifi carrier board from some stripboard. It is not difficult, and just needs a bit of care and patience - you need to get this right though, because available space is at a premium, and the hack instructions depend on a replacement carrier board which is the same as shown.

Cut out a 19 holes by 9 holes stripboard blank, then cut out the 2 side ‘locating’ slots (using the original wifi board as a template), then cut out the lower ‘access’ slot as shown above.

Check that it slides onto the Mains board ok (copper side out). Also check it against the original wifi board to ensure it does not stick up higher, or hang lower, and if so, file level.

Cut the tracks where shown above, the coloured overlays have been added to help visualise circuit connections and serve as an aid for subsequent component and wiring placement.

###Construction Overview

The BMP180 (or BME280) is connected by short wires to offer some slight flexibility in its positioning. The level converter at the opposite end is connected by longer wires to allow it to be hinged around and folded back tight against the outboard copper side of the ESP board, preferably into the unsoldered track area behind the ESP so it can fit more flush. The replacement wifi board needs to slot over the Mains board component side first (inboard), therefore nothing can be mounted on the component side in the area between the two side slots which could prevent the board from being fully located. This means that the GND link wire (black) and 0.1uF bypass capacitor both need soldering onto the outboard side directly to the copper tracks. Similarly for the solder pad ‘flying’ wires routed from underneath the Mains board. All these outboard items can be soldered to anywhere along their respective tracks - their locations on the diagram are shown for clarity, not best fit, so try to keep them clear of the area where you wish the level converter to be ‘hinged’ into.

###Construction Details

Solder the component-side jumper wire to link up the two +3.3v (red) rails as shown above. Install the 4 resistors. Values aren’t critical, you can use anything from a couple of K up to 20K, but for RST and EN you may want to tend towards lower values for better stability.

Solder wires to the ESP - including the 2 option wires if required - and ‘stick’ the ESP to the board with some double-sided tape, then connect it up as shown above. The long looping wires are only shown for diagram clarity, but in practice they need to be routed neatly and as short as practical, and cannot stick out above the top or below the bottom of the ESP.

Install the 0.1uF Bypass Cap and GND Link Wire directly on to the copper track side. If requiring Option 3 or 4 for Independent LEDs, make the appropriate track cuts.

Connect the sensor with sufficient ‘slack’ to allow some flexibility for best positioning.

Connect the Level Converter with wires of sufficient length to allow the module to be hinged around and laid flat to the un-used copper area behind the ESP (see below). Don’t connect the USB ‘flying’ wires yet because they are only shown above for circuit clarification.

Check that the board stills fits onto the Mains board ok, then remove it again.

###Board Installation

Solder a +3v3 connecting wire to the inboard (+) leg of capacitor C11 on the Mains board.

Trim the loose end to length, bare the end, and insert into the replacement wifi board where shown below as the board is slid onto the Mains board, then solder the wire in place.

Solder a couple of thicker bare wire off-cuts between each of the side structural solder joints on the Mains board to their nearest adjacent copper track on the bottom of the stripboard - these are to anchor the replacement board in place as well as supply the Gnd.

###Final Wiring

The lower access slot offers easier soldering of wires to the group of 4 small solder pads on the underside of the Mains boards, and allows the wires to be conveniently routed up ‘outboard’ and soldered directly to their appropriate copper tracks. Use thin flexible (not solid) wires to prevent the small fragile pads and tracks from being put under cable ‘stress’ to reduce risk of any pads or tracks being pulled off the pcb.

Ensure the required Mains board pads are pre-tinned first with a small blob of fresh solder. Cut the wires to length and bare the ends… if requiring Option 1 or Option 2 for bridged LEDs, spread those wire ends sufficient to bridge the 2 pads. Tin the wires then ‘dab’ them on to their appropriate WPS, RLY2_LED, RLY1_LED, RLY1 pads on the Mains board.

Route the wires up through the access slot and solder them directly to anywhere convenient along their appropriate copper tracks, as per the diagram above.

Remove the SMD component bridging the 2 inner USB socket pads on the underside of the Mains board, then solder 4 thin flexible wires to the USB pads. Route the wires towards the Button end of the Mains board (right-hand side of the picture) so that they go away from the Mains - then arc them back down and along the outer edge of the Mains board until they can be routed up through the access slot of the replacement wifi board.

Trim the wires to fit into their appropriate Level Converter holes, then ease out the Level Converter module sufficient to solder the wires in place. Use a bit of double-sided tape afterwards to hold the module back where it belongs. Hold all the wires in place with some duct tape, and particularly the USB wires on the underside of the Mains board to prevent any possible broken wires from moving and touching any nasty Mains stuff.

Finally, stick duct tape over the wifi board to hold everything in place, then re-assemble.

###Flashing

Ensure the Smart Socket is not plugged into a Mains outlet… I cannot advocate flashing the Smart Socket while it is powered by Mains unless using non-contact OTA (Over The Air).

Make a simple USB Flashing Adapter by salvaging an old USB mouse cable with plug, then crimping on 4 female Duponts (or solder a bit of header socket) to the cut end for easy connection to the 5v UARTs appropriate pins, remembering to cross-connect RX and TX. Boot into flashing mode by holding down the on-board WPS button as the flashing adapter is plugged into the USB socket, then release the button and start the upload.

###External Sensors

I2c sensors such as the BME 280 sensor modules can offer things like barometric pressure, temp and humidity all on the same little i2c pcb, but you aren’t just limited to those.

A small PCF8591 AD/DA Converter Module (available for about £1) offers four i2c addressable analog channels, plus even includes on-board temp and LDR sensors.

A similarly addressable PCF8574 I/O expander can offer up to 8 digital channels (of mixed inputs/outputs) and an MCP23017 module offers 16 (both are cascadable for more).

If you want to use 3.3v sensors, include an AMS1117-3.3 module and level converter. Much flexibility is possible for various alternative plug-in digital and/or analog sensors, either plugged directly into the Smart Socket, or via USB extension cables and splitters.

So although originally only a hack ‘bonus’, the ability for plug-in external sensors actually offers a very useful and convenient mains-powered sensor platform just in its own right!

To see how useful, take a look at the ‘K2’ smart socket which has come on the market since I started this article (search AliExpress.com). It is probably unlikely to use an ESP8266 so therefore would probably need hacking to be Souliss compatable, but the important point to note is the fact that the manufacturer has standardised on a range of USB plug-in sensor modules, and that those neat USB plug-in sensors are sold separately.

They certainly give an idea of how useful the facility for external sensors could be, but perhaps they may also use i2c… in which case there could be a 50% chance of them being hardware compatable without even needing to swap the Smart Sockets 2 USB data wires.

Remember that i2c is a daisy-chained ‘bus’, so pullups are only needed on the last device in the chain - which means that some devices with onboard pullups (such as BMP180) may need their i2c pullups disabling (typically by removing a track link).

Adding or removing i2c devices is likely to affect the required value for the pullups, so if devices are expected to be changed, it may be better to use separate plug-in terminating resistor modules to allow quick changes of alternative value pullups when required.

You can get a handfull of these USB to DIP adapters for less than £2 from ebay. They can be soldered directly to your external sensor adapters, or use ‘flying’ wires for connecting to a small ‘development’ terminator breadboard offering quick-change i2c resistor selection, or they could directly accomodate the two i2c pullup resistors and then perhaps be neatly housed in any old unwanted USB dongles you might have lying around.

Those with an osilloscope could select for best resistor values by monitoring for the squarest i2c waveform, but others can use some lateral thinking to select for best communications speed and reliability (which is the real goal anyway). Loop commonly available i2c scanner code and keep checking for valid device responses as the i2c comms speed is progressively increased until the device response fails - now try substituting higher or lower value resistor pullup pairs (easy if using the above mentioned terminator breadboard) and keep repeating the speed test until unable to improve further… then you can more permanently install the ‘best’ i2c pullups with some confidence.

###Software

The Souliss ‘Smart Socket Hack’ example code gives ‘Basic’ wifi On/Off control of the relay, plus local manual On/Off toggle of the relay using the WPS button for test purposes. The simple ‘Basic’ Mains switching functionality could be usefully enhanced by software to offer additional benefits such as…

Scheduled Control - automatic Daily/Weekly switching according to pre-set dates/times.
Duration Timers - automatic switching Off or On after preset duration or delay.
Reboot Sequence - SoulissApp Button to cause the selected device to power Off for 10 seconds then automatically back On again, for rebooting routers or servers etc (could also be auto-triggered by loss of connection if wished).

The inclusion of the internal temp sensor offers potential for a programmable thermostat.
Note: Electronics generates heat, therefore the temperature measured inside the Smart Socket (or any closed housing) is likely to be higher than the ambient temperature outside. To compensate for this, run the assembled Smart Socket long enough for the temperature readings to stabilise, then dismantle it and safely power it via USB to measure the ambient temperature and compare the difference after readings stabilise again. A simple software subtraction of that difference from the sensor reading in your program would then give the effective ambient temperature rather than the warmer level inside the Smart Socket.

OTA Web Configuration could allow all such Smart Socket features and sensors to be easily configured and enabled on an as needed basis, and hopefully that is just around the corner.

Alternatively, some simple i2c Scanner code could check responses of specific device addresses from a ‘possibles’ list to automatically discover and configure available sensors.

It is up to users to provide the software to suit their own needs and hardware options, and hopefully to contribute back their successes for the benefit of others.

###Footnotes

Although this hack was specifically developed for the Smart Socket, it is worth pointing out that all the features and expansion options are also equally as applicable for any home-built switched mains sockets… or any other devices it can be fitted into, for that matter.

A larger piece of stripboard could allow easier component placement and even accomodate an ESP-12 adapter plate if wished, plus offer room for things like side header pins for easy GPIO test access, flashing buttons, 3.3v regulator module and 470uF smoothing cap, etc.

The drawing above only suggests a possible starting point - your own stripboard shape and size should take advantage of available space to best accomodate your own required items.

For those wanting a more professional-looking result, a 5cm x 5cm ESP-12E printed circuit board offering similar functionality is available from Juan Pinto (link to go here). He can also supply populated boards if wished, including suitable Souliss software, plus a matching range of convenient 3D printed housings (including DIN Rail and Table Lamp versions).

And for those prefering the convenience of a completed and ready-to-use switched-mains socket, Lesjaw Ardi (link to go here) produces a range of ready-built Souliss items.

One of the problems when creating a home-built switched mains socket is how to power the electronics without using a second dedicated external mains plug just for powering the low voltage supply - which can makes things clunky, untidy, and unsatisfactory. Ideally the low voltage supply for the electronics would be included within the home-built switched socket housing, so here’s a cheap compact mains-derived PSU complete with USB charging socket that some people may not be aware of - it may not be the best option for everybody, but it is worth pointing out as a potential alternative that otherwise could be over-looked.

It’s available for just £1 and free postage off ebay, and in any colour you like - not that colour matters when the first thing to do is prise the plug apart to remove the 5V 1A USB charging module from within… and if it can be stuffed into a UK mains plug, it should be relatively easy to fit inside a home-built switched socket housing. (Anyone thinking ‘but I need a NON-UK version’ should be using battery power for their own safety!)

To find them, enable ‘Buy it now’, ‘Worldwide’ and ‘FreeP&P’ in the ebay side panel (do each separately and wait for the screen refresh between each option change), and similarly enter a ‘to’ price of £2 (or equivalent) to cut out the more expensive clutter - then do a search for ‘mains plug usb charger’, and find the cheapest resulting seller who delivers to your country.

You might want to do similar search options for ‘AMS1117-3.3 Module’, and perhaps again for ‘5v relay module 1 channel’, and also ‘Logic Level Converter’. All 4 items can be bought for a combined total of less than £4 including free delivery, and along with the Smart Socket hack could provide all the electronics needed to make a home-built switched mains socket… but I am only suggesting ingredients, what recipes you choose to cook up are down to you. Don’t forget you won’t have the Smart Sockets C11 capacitor to use as the smoothing cap for your 3.3v supply, so you will need to add one of your own - but you can salvage almost any low voltage electrolytic between 100uF and 1000uF (preferably mid value) for that job.

Another Smart Socket alternative worth considering is to put the ESP hack into an RF switched socket housing, or even a plug-in electronic timer (not a mechanical one) - they offer a safe and neat housing with integral mains plug and switched mains output socket, and are available much cheaper than the Smart Socket. You might even be able to retain use of the existing low voltage supply and/or the relay, but if you need to discard everything it could offer sufficient room to fit the replacement items, and perhaps even for a display.

Almost done, but this couldn’t be complete without giving special thanks to Dario for his brilliant concept and very thorough professional implementation of Souliss, and to Alessandro for his excellent and indispensable Souliss App, and to the many others who have contributed to making Souliss as good as it is, and thanks also to all of the Souliss community - and others - who take the time and effort to share their innovations for the benefit of us all.

And finally - this is my first real hack, my first tutorial, and my first experience of ESPs. So I am certainly no expert, nor the best person to be offering such advice - but rather than taking the quick easy selfish option of just implementing the hack for myself, I prefer taking the opportunity to offer a contribution for others to benefit from if they wish (and hopefully most can find something of interest from within, however small it may be). Discovering the Smart Socket circuitry was the easy part compared to evolving a suitable solution for diverse needs and skill levels, plus producing the subject matter for every picture, and creating every component used in the drawings from scratch and to scale. It’s been a large and lengthy task which has continually changed and grown, so please don’t expect everything to be set in stone and absolutely perfect, just consider it a collection of helpful tips for anyone who would welcome them until they are able to learn any better for themselves.

Automate with Automate

2015-11-28T00:00:00+00:00

After quite a lot of words on the integration of SoulissApp with Automate and Tasker through intents and plugins, is now time to have a detailed look on how to get it working.

We focus on Tasker Plugin that is a set of open API supported from multiple Android software like Tasker (of course) or Automate that will be covered in this tutorial. The Plugin allow an interaction with Souliss via common language like turn on the living room light or is the living room light on?.

Using Automate you can have preemptive notification, that asks you if you want to perform common task based on time, position or other condition (open app, accelerometer sensor of the smartphone)

Execute an Action or take Decision

In the flow editor, included in the APPS menu there are the two Plugin that can be used with SoulissApp, the Action and Decision. The former is used to execute an action, the latter to take a decision based on the state of a device in SoulissApp.

So you can turn on the Main Light using the Action one or,

Check if the Main Light is on using the Decision one

These two Plugin can be used in any Automate flow, even if this is not a full Automate tutorial, lets see how we can build simple conditional actions.

Recursively check for a condition with Forks

Flows are easy to use but needs recursive check to be effective, the flow in the below picture checks for a time frame and later show a notification if the ambient light cross a threshold value.

Once started the flow will wait for a time frame, after 9 PM it enters in the next step and check for the ambient light using the embed sensor of the smartphone. If in the time frame the ambient light is too high,it will show a notification and will ask the user if he want to lower the brightness.

That’s works nice if after 9 PM you cross the threshold, if not the flow will check the light value and waits there. So, the morning after you will likely get the notification even if this wasn’t your goal.

You need a recursive check of a condition using parallel flow, those are called Fork. In Automate Flows can interact with their Forks but not with other Flows.

Having a recursive check needs a dedicated fork, like in the above picture. It first checks if connected to Plinio WiFi network (set it as Immediately) is not it holds on the same check with On Change parameter. This will not drain your battery while waiting for a change in the connection state.

Once connected, it starts a fork that will be a new flow starting from that point that will do something else, and checks again the WiFi state On Change, if the connection is lost it will stop the fork and restart the flow. So in this way you are recursively checking for the WiFi state and your flow will stop at every time if this condition is missed.

This applies to any block as a time frame or else, after the fork you can apply the same scheme creating multiple condition in AND, like check for WiFi and time frame.

Create Custom Interaction

Even if the Plugin allow few commands like turn on, turn off and toggle you can create custom and complex interaction with dedicated code on your node.

Lets assume that you have three LYT bulbs and you want to set a Movie Time to lower the switch off two of the three bulbs and use a low brightness amber light, this quite complex state can be achieved with a custom action defined in your node.

In the Gateway node include a set of pushbutton as T14 and configure them to broadcast a topic, like in this case LowMood, FullLight and MediumLight.

In this way any other node in your network can listen for this topic and apply the required changes.

...

#define LowMood                                 0xFF01,0x01
#define FullLight                               0xFF01,0x02
#define MediumLight                             0xFF01,0x03

...

void setup()
{ 
  ...

    Set_T14(PUSH1);
    Set_T14(PUSH2);
    Set_T14(PUSH3); 
}

void loop()
{
  ... 

    FAST_110ms() {

    // LowMood Command
    if(Logic_T14(PUSH1))
        if(mOutput(PUSH1))  publish(LowMood);

    // Full Light Command
    if(Logic_T14(PUSH2))
        if(mOutput(PUSH2))  publish(FullLight);

    // Full Light Command
    if(Logic_T14(PUSH3))
        if(mOutput(PUSH3))  publish(MediumLight);
    }
}

On the node side, as example

...

#define LowMood                                 0xFF01,0x01
#define FullLight                               0xFF01,0x02
#define MediumLight                             0xFF01,0x03

...

void loop()
{
    ...
    // Listen for topic published by other nodes
    FAST_110ms() {
    
        // Set LowMood
        if(subscribe(LowMood))
        {
            // Do something
            ...
        }

        // Set Full Light
        if(subscribe(FullLight))
        {
            // Do something
            ...
        }

        // Set Medium Light
        if(subscribe(MediumLight))
        {
            // Do something
            ...
        }
}

At this time you will get on SoulissApp the three T14 that can be renamed as you like and be activated from the Plugin.

Automate extend SoulissApp features and gives sense to your automation

So, what if you smartphone will preempt you asking if you want to lower the light? This give sense to your automation that is no longer a simple remote control.

What if SoulissApp will be able to recognize when you and your family are at home? Simply build a flow that periodically trigs a state (one for each people at home) when you enters at home and connect to your WiFi, use a timer on the node side to clear the state. This will show when you are at home and any node can benefit from.

What if you build a shortcut that open your IPCamera app and at same time turn on the lights without have you to dig in SoulissApp?

Enjoy!

Are you lazy enough? Automate and Tasker integration

2015-11-08T00:00:00+00:00

Laziness is a life style and tap your finger on the smartphone screen looking for the button to dimmer out lights or do any other routine action is boring as step-up to the wall button. Wouldn’t be nice if your smartphone can propose you what you need?

Is not yet time for an Artificial Intelligence that learns your habit, it will likely be in the next future but our laziness cannot wait, so starting from SoulissApp 1.6.1 any other Android application can interact through Intents.

A special Intent is the Tasker Plugin, that is supported by Automate, Tasker and other Android application that lets build If-Then-Else rules based on sensors and internet data.

There are two types of plugins, the Action Plugin can be used to send command through SoulissApp as you were using Voice Commands, the wiki has more details but basically you just have to write something like turn on bedroom lights where you have a set of keyword like turn on, turn off, open, close and others that shall be followed with the name that the target device has in SoulissApp

As well a state can be retrieved in a similar way using the Conditional Plugin, having a True/False statement as result.

We will soon start to release examples for Automate and Tasker, but the SoulissApp Plugins will generally be the last step in your flow, there are several example that can be build and fully customized based on your needs:

Using the light sensor of your phone, in the evening and if connected to your home WiFi, a notification can ask you if you want to lower the brightness of your lights in the living room,
Using the GPS or Cell Tower position to open automatically the Garage Door or ask with a notification if you want to open it,
Catch the sunset using an online service and turn gradually on an LYT Bulb with a warm yellow.

The release 1.6.1 of SoulissApp is in preview on the mailing list and will be available in the Play Store in few days.

Have fun!

SoulissApp Tasker and Automate integrations

2015-10-28T00:00:00+00:00

Chit-Chat about #IoT is becoming noisy, automation being part of it. So we couldn’t delay SoulissApp APIs any longer, even doubting anyone will ever use them. Tasker and Automate are two popular tools to automate thing, they already implement any sort of complex and integrated behaviour so that we only had to figure out how to integrate them. Now you can open window blinds shaking your phone. Neat? Please let us know about creative and weird Tasker profiles you may be using with Souliss.

Automation is a buzzword? We can automate without a server

From next release of SoulissApp, send and receive from SoulissApp through general Intent or Tasker (and Automate) Plugin will be supported, we have a growing wiki page dedicated to SoulissApp integrations.

Maker Faire Rome 2015

2015-10-24T00:00:00+00:00

Are almost three years that Maker Faire is in Rome for the European edition, this year we have powered the Authometion and IONO booths with Souliss and had the change to meet them and have some fun looking over the many expositor of the faire.

At the Authometion booth there were a couple of LYT8266 running Souliss and our logo on their flayers, has been nice and hopefully next year we will be there again.

It was of course an opportunity for an informal meeting with pizzas, friarielli and other street food dishes

</a>

See you next year at Maker Faire Rome!

IONO Ethernet Relay Board

2015-09-27T00:00:00+00:00

This year September has been a month full of news, and the latest is the support of IONO a professional-like relay board that can be used for home automation. We just got a sample to work with and evaluate the product, that has a good manufacturing and interesting features.

The IONO is mostly an Arduino shield with a DIN-rail enclosure, you can purchase it as standalone (IONO Solo) or packed with an Arduino Ethernet. The board has a socket compatible with Arduino UNO rev3, so you can plug in any compatible Arduino board or Arduino Ethernet.

The focus for the IONO is on the I/O side, because it support input as Digital or Analog 0-10V / 4-20 mA and has six relays with bistable coil with 12 A of steady current and 80 A for inrush.

The inputs use an Operational Comparator to work either as digital or analog, using resistor to scale the value from 0-10V or 4-20 mA as 0-5V. The use of 0-10V and 4-20 mA is a standard in industrial application, current loop have better noise rejection, but isn’t common for home application. There are totally 6 inputs, 4 of them are connected to an Analog Input with ADC so that can be used either as digital or analog values; the other two are connected to digital inputs and can be attached to an interrupt. The use of digital is in voltage-free configuration, so you should connect a switch and power the input.

On the output side, the relays have a bistable coil and an embed driver, so from the user point of view are just standard digital outputs but there is no current waste because the relay is designed to mechanical retrieve the last position. As example, in case of power outage relays will remain in their position. Generally speaking this nice trick can improve relays life very much.

All terminals are detachable, this is also a common feature in industrial protocol, allow easy and reliable replacement of the electronics without have to rewire all the connection and helps in case of constrained spaces.

A detailed focus on the I/O design is available on the IONO website with details on power supply, inputs, digital outputs and analog outputs. The hardware manual is also a good reference to understand if the I/O fits your needs and how you can wire it.

IONO support will be officially available in Souliss v7.1 but as preview you can get it from the current souliss branch

The guys at IONO will expose their boards at Maker Faire Rome from 16th to 18th October, and they will also setup a small demo with Souliss running on two IONO Ethernet.

Stay tuned!

LYT8226: an Arduino LED Bulb based on ESP8266 WiFi

2015-09-26T00:00:00+00:00

Working with the ESP8266 is always a great experience, it becomes just a matter of getting the proper I/O and then in few minutes your module is running. The introduction of the ESP8266 in the supported SoC for Souliss has open the world of smart devices to the DIYers and the very competitive price of this IC will spread it into consumer products.

In the last few days we have started working with Authometion to support the new LYT8266, a variant of their RGBW LED Bulb that has an ESP8266 inside, so that you should program your sketches directly into the lamp (this is in contrast with the approach used with LYT88).

Thanks to the Arduino cores for ESP8266 you can program this bulb directly from the Arduino IDE using OTA (Over the Air) programming, running Souliss you have direct access via SoulissApp or openHAB.

A side-to-side comparison show a LYT88 bulb (on the left side) with a LYT8266 (right one), the voltage regulation is based on a switching circuit (on top right, you can see the inductor and regulator) this is due to the high current required by the ESP8266 compared to a standard microcontroller with external RF radio (as on the left side). The I/O is basically the same, with one mosfet for each channel used to sink the current from the LEDs powered at near 12 Vdc.

LOAD YOUR SKETCH OverTheAir (OTA)

Loading a new sketch has two option, using the cable or the air. The Over the Air programming is very simple and can be used right out-of-the-box if your bulb has Souliss pre-loaded.

You need the following pre-requisites to load a sketch:

Install the Arduino IDE 1.6.5 (this is the supported release at time of writing)
Install Python 2.7 and have it in your Windows path
Install the ESP8266 cores for Arduino, the cores are distributed via the Arduino IDE Board Manager and needs an URL for the distribution of the code. You can check the supported core here
As today, the URL to be used is http://arduino.esp8266.com/staging/package_esp8266com_index.json into Additional Board Manager URLs field. You can add multiple URLs, separating them with commas.
Install Souliss library on Library Manager of Arduino IDE

Once you will power your bulb, if is the first time and has never been configured before, you will see an Access Point called Souliss, just connect and point your browser to http://192.168.4.1

You get a web interface from where you can configure the WiFi and IP parameters, and select the node as Gateway or Peer. Configure one bulb as Gateway and the others as Peer, they will build automatically a Souliss network and will be available in SoulissApp. Note: if the DHCP box is ticked it will over-ride a manually entered address if present - and likewise for the Gateway address - so don’t tick those boxes if you wish to manually specify the addresses.

Your bulbs have full features, but if you want to upload a new sketch you just need to go in the Arduino IDE and set the following parameters:

Board as Generic ESP8266 Module
Flash Mode QIO
Flash Frequency 40 MHz
Upload Using OTA
CPU Frequency 80 MHz
Flash Size 1M (64K SPIFFS)
Upload Speed 115200

In the Port sub-menu you will see the bulb and its OTA IP address which allows you to upload a new sketch over wifi as if it was connected via cable (assuming your Arduino IDE computer has wifi access to the ESP device of course).

It is very important that you always upload an OTA enabled sketch each time, otherwise you will not see the OTA device available in the Port sub-menu for uploading to over the air, and therefore you will need to connect and upload via the cable. Start from the e02_LYT8266_WiFi_Bulb.ino to build your own sketch.

LOAD YOUR SKETCH VIA USART CABLE

Using the cable to connect via USART can be useful if you don’t want OTA or if you have bricked your OTA sketch, also you can use the whole flash size (1 MByte) whereas on OTA you are only able to use 512 KBytes. All the previous pre-requisite applies also for this case.

PIN	Resistor	Serial Adapter
ESP03_URXD		TX
ESP03_UTXD		RX
GPIO16_RESET		RTS*
GPIO0		DTR*
GND		GND

The two connection with * are not mandatory, without you need to turn OFF the bulb and place GPIO0 to GND every time that you want to program it, this is similar to any other ESP8266 based device, this tutorial gives the basic to use the Arduino IDE and the ESP8266 cores.

On board of the LYT8266 the programming connector, is very small and need an adaptor supplied with the dev kit, and expose the TX, RX together with GND and GPIO0 and others. You haven’t the Vcc, so you should power the ESP8266 board connecting it to main 220 Vac (or 110 Vac), so be careful.

On the module there is an ESP-03, so on the Arduino IDE select the COM module as per your operating system and the following settings:

Board as Generic ESP8266 Module
Flash Mode QIO
Flash Frequency 40 MHz
Upload Using Serial
CPU Frequency 80 MHz
Flash Size 1M (64K SPIFFS)
Upload Speed 115200

As first step, you need to load the e02_LYT8266_WiFi_Erase sketch, this will clear the FLASH sector used as EEPROM from random data and later load the e02_LYT8266_WiFi_Bulb this will start the bulb as access point with a web configuration interface restoring the factory firmware.

/**************************************************************************
   Souliss - LYT8266 WiFi RGBW LED Bulb
    
    This is the basic sketch for an LYT8266 a WiFi LED Bulb based on ESP8266,
    at first boot it starts as access point with a basic web interface to 
    allow WiFi and Souliss configuration.
    Info are stored in the module and used at next boot.
    
    Configure one module as Gateway for your network and all the other as 
    Peer. Before load this sketch, run the e02_LYT8266_WiFi_Erase to erase
    the memory.
    Once configured, can be accessed via SoulissApp or openHAB.
 
***************************************************************************/

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <EEPROM.h>
#include <WiFiUdp.h>

// Configure the Souliss framework
#include "bconf/LYT8266_LEDBulb.h"          // Load the code directly on the ESP8266
#include "conf/RuntimeGateway.h"            // This node is a Peer and can became a Gateway at runtime
#include "conf/DynamicAddressing.h"         // Use dynamically assigned addresses
#include "conf/WEBCONFinterface.h"          // Enable the WebConfig interface

#include "Souliss.h"
   
// Define logic slots, multicolor lights use four slots
#define LYTLIGHT1           0    

#define RED_STARTUP         0x50
#define GREEN_STARTUP       0x10
#define BLUE_STARTUP        0x00

// Setup the libraries for Over The Air Update
OTA_Setup();

void setup()
{
    // Init the network stack and the bulb, turn on with a warm amber
    Initialize();
    InitLYT();
    
    /****
        Generally set a PWM output before the connection will lead the 
        ESP8266 to reboot for a conflict on the FLASH write access.
        Here we do the configuration during the WebConfig and so we don't
        need to write anything in the FLASH, and the module can connect
        to the last used network.
    ****/
    SetColor(LYTLIGHT1, RED_STARTUP, GREEN_STARTUP, BLUE_STARTUP);

    // Read the IP configuration from the EEPROM, if not available start
    // the node as access point.
    //
    // If you want to force the device in WebConfiguration mode, power OFF
    // your router and power OFF and then ON the bulb, you will see an access
    // point called Souliss.
    if(!ReadIPConfiguration()) 
    {   
        // Pulse a bit
        LYTPulse();

        // Start the node as access point with a configuration WebServer
        SetAccessPoint();
        startWebServer();

        // We have nothing more than the WebServer for the configuration
        // to run, once configured the node will quit this.
        while(1)
        {
            yield();
            runWebServer(); 
        }

    }

    if (IsRuntimeGateway())
    {
        // Connect to the WiFi network and get an address from DHCP                      
        SetAsGateway(myvNet_dhcp);       // Set this node as gateway for SoulissApp  
        SetAddressingServer();
    }
    else 
    {
        // This board request an address to the gateway at runtime, no need
        // to configure any parameter here.
        SetDynamicAddressing();  
        GetAddress();
    } 

    // Define a logic to handle the bulb
    SetLYTLamps(LYTLIGHT1);
    
    // Init the OTA
    OTA_Init();
}

void loop()
{  
    EXECUTEFAST() {                     
        UPDATEFAST();   
        
        // Is an unusual approach, but to get fast response to color change we run the LYT logic and
        // basic communication processing at maximum speed.
        LogicLYTLamps(LYTLIGHT1);       
        ProcessCommunication();
      
        // Run communication as Gateway or Peer
        if (IsRuntimeGateway())
            FAST_GatewayComms(); 
        else 
            FAST_PeerComms();   
    }

    EXECUTESLOW() {
        UPDATESLOW();
        
        // Slowly shut down the lamp
        SLOW_10s() {
            LYTSleepTimer(LYTLIGHT1);      
        }       
        
        // If running as Peer
        if (!IsRuntimeGateway())
            SLOW_PeerJoin();
    } 
    
    // Look for a new sketch to update over the air
    OTA_Process();
}

The LYT8266 in our hands are actually prototypes that will be unvelived at Maker Faire Rome 2015 at the Authometion booth, there will be also a workshop to have your hands on these devices. The sales will start after the faire, so a month or so before having them available on the market.

UPDATE

The LYT8266 is now on the Authometion store, have a look here is also available as pre-assembled device

Enjoy!

Multicolor WiFi Bulb, the first Arduino based one

2015-09-24T00:00:00+00:00

In these days we are working closed with Authometion and their new bulb, the LYT8266 that will be unveiled at European Maker Faire in Rome (from 16th to 18th October 2015). These new bulbs share with the LYT88 the AC/DC and RGBW LED but instead of an ATmega88 use an ESP8266 that gives WiFi and control over the LEDs.

The LYT8266 compares directly with the most famous WiFi bulb, the Lifx, with a more competitive price and most important with full access to the ESP8266 microcontroller and its Arduino support.

As any other ESP8266 based device, also the LYT8266 can be programmed using the Arduino IDE and can run Souliss natively, just before the start of the Maker Faire we will release Souliss v7.1 with example sketches for the new LYT bulb. In the while here a quick preview, the LYT8266 will be the first product that benefit the new WebConfig interface that allow full IP and Souliss network configuration on runtime.

At the startup the ESP8266 starts as access point and stars a simple webserver as in the below picture, from where you can configure all the needs, included the Gateway or Peer behavoir of the node.

At the Maker Faire you can preview the LYT8266 running Souliss or any other Arduino sketch, this include SoulissApp and openHAB as well as all networking feature.

SoulissApp 1.5.4 is out with Voice Recognition!

2015-09-20T00:00:00+00:00

SoulissApp 1.5.4 has just been released with voice recognition as new feature. You can simply use your voice to issue commands to Souliss, naming your things per name and command. After having enabled the relevant option, tap on the mic icon and use one of the following:

    [<turn on>|<turn off>|<open>|<close>] [(deviceName)+]
    [<execute> <scene>] [sceneName | sceneId]

The keywords has been translated, so you should talk in the language of your android device, using keyword to activate multiple commands like turn on living room light and kickten light. Renaming devices is suggested in order to ease the recognition process.

Out of voice recognition other bugs were fixed, TAG section should now be almost ok. You can now sort TAGs, save them with backup function and restore as needed. Fahrenheit temperatures have been added, even though the process of converting every temperature to this unit is not yet complete.

Getting started downloading SoulissApp from the Play Store.

How to install OpenHAB on RaspberryPi2.

2015-09-07T00:00:00+00:00

This tutorial has been written in occasion of my OH installation on a brand new RPi2 model B. It is meant to be a step by step guide to help myself (and others) in case of new installations.

Purchasing the hardware

I had a RPi1 model B already running in my apartment with OpenHAB and other backup services. It was running not very fine, mainly suffering from the slow CPU trying to run the JVM. On that machine OpenHAB was often slow giving a bad user experience.

OpenHAB community have a hardware FAQ page here suggesting BananaPi over RPi due to its SATA connection much more efficient than the microSD. Personally I decided for the RPi because of its vast community and because I did not like the idea to have an additional SATA HDD outside the tiny box.

I decided to get a RPi2b + NOOBS + black case available for €46,50 from RS

Configuring the RPi (headless)

Connecting

Just plug the Ethernet connector to your network and power up the unit providing 5Vdc via the micro USB connector. The unit is shipped with dynamic IP address and if you have a DHCP server in your LAN it will get a proper IP. Open your router webpage and look for the assigned IP address, otherwise use Fing application for Android to get the address; you should look for Raspberry Pi Foundation device.

In my case I got 192.168.1.204

By using ssh (on Linux) or Putty (on Windows) you can connect to that IP. The default root user is ‘pi’ and the default password is ‘raspberry’ You may eventually change the password with sudo raspi-config command

Setting a static IP Address

I followed a really nice guide available here

And basically I edited the network configuration file with command sudo nano /etc/network/interfaces

Simply change the line that reads:

iface eth0 inet *dhcp*

iface eth0 inet *static*

Then directly below this line enter the following (Please Note. You will need your own addresses we gathered in Part B, more details below). . . .

address 192.168.1.3
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255
gateway 192.168.1.1

sudo rm /var/lib/dhcp/*

Then we’ll need to reboot and check your changes. . .

sudo reboot

Log back in and run

ifconfig

Which should reveal your new settings.

Installing JVM

NOOBS comes with pre-installed java. You can easily check this by calling the command:

java -version

pi@rpi2-openhab ~ $ java -version
java version "1.8.0"
Java(TM) SE Runtime Environment (build 1.8.0-b132)
Java HotSpot(TM) Client VM (build 25.0-b70, mixed mode)

Installing OpenHAB

Derived from instructables step by step guide.

Create the OH folder

sudo mkdir /opt/openhab

Move to that folder

cd /opt/openhab

Visit the OpenHAB download page and copy the runtime package web address to be used in the command below.

download the package typing:

sudo wget https://bintray.com/artifact/download/openhab/bin/distribution-1.7.1-runtime.zip

unzip the package

sudo unzip distribution-1.7.1-runtime.zip

remove the package

sudo rm distribution-1.7.1-runtime.zip

Move to the addons directory

cd addons

download the addons package

sudo wget https://bintray.com/artifact/download/openhab/bin/distribution-1.7.1-addons.zip

unzip the package

sudo unzip distribution-1.7.1-addons.zip

Remove the package

sudo rm distribution-1.7.1-addons.zip

Visit this page to get the latest version of Souliss OpenHAB binding

Copy file org.openhab.binding.souliss_1.7.0.201507152300.jar in folder /opt/openhab/addons

Configure Souliss binding

The following steps are basically following the souliss-openhab wiki.

Souliss binding basic configuration

Move to configuration folder:

cd /opt/openhab/configurations

Create a copy of the default cfg files to add your personal settings:

cp openhab_default.cfg openhab.cfg

Edit the file :

sudo nano openhab.cfg

Add the following lines a the bottom:

################################ Souliss Binding ##########################################
#
# Souliss  
#
# For ITEM defination in file .item
#{souliss#<Typical>:<nodeID>:<slot>:[<bit>|<useOfSlot>]}

souliss:IP_LAN=192.168.1.100
souliss:USER_INDEX=71
souliss:NODE_INDEX=134
#SERVERPORT - Leave empty for casual port
souliss:SERVERPORT=

#time in mills - min 50
souliss:REFRESH_DBSTRUCT_TIME=600000
souliss:REFRESH_SUBSCRIPTION_TIME=120000
souliss:REFRESH_HEALTY_TIME=60000
souliss:REFRESH_MONITOR_TIME=500
souliss:SEND_DELAY=1500
souliss:SEND_MIN_DELAY=100
souliss:SECURE_SEND_TIMEOUT_TO_REQUEUE=5000
souliss:SECURE_SEND_TIMEOUT_TO_REMOVE_PACKET=30000
###########################################################################################

My complete openhab.cfg file is published here

items configuration

Move to items folder:

cd /opt/openhab/configurations/items

Create an item file:

sudo nano souliss.items

Add your souliss items using the syntax {souliss=<Typical>:<nodeID>:<slot>:[<bit>]} as detailed described in the howto guide here

My souliss.items file is published here

sitemaps configuration

Move to sitemaps folder:

cd /opt/openhab/configurations/sitemaps

Create a sitemap file:

sudo nano souliss.sitemap

Create your personal sitemap according to the OpenHAB syntax.

I have two sitemaps, the one I use is published here, the one designed for my wife is here.

using custom icons

My sitemaps uses some custom icons.

These icons shall be copied in folder /opt/openhab/webapps/images

Start OpenHAB manually

By default the “start.sh” script is not an executable file. Do the following in order to make it executable:

sudo chmod +x start.sh

sudo ./start.sh

And the fun begins! You should have a fully loaded system with your items and sitemps according to your configuration. Open you favorite browser and type (of course subsitute my ip address with the one of your server):

http://192.168.1.3:8080/openhab.app?sitemap=souliss

Configuring openHAB to Start Automatically at Boot

Follow this guide.

In my first installation I encounter issues due to a wrong line end: the script was not working, a simple dos2unix command on the script solved the issue.

Installing HABmin

HABmin is a web administration console for openHAB. It aims to provide a complete interface to administer openHAB.

Get the zip web address from the habmin download page.

Move to openhab folder:

cd /opt/openhab

Download the zip:

wget https://github.com/cdjackson/HABmin/releases/download/0.1.3-snapshot/habmin.zip

Unzip the package:

unzip habmin.zip

Remove the package:

rm habmin.zip

Restart openhab:

sudo /etc/init.d/openhab restart

Open habmin by simply pointing your browser to:

http://192.168.1.3:8080/habmin/index.html

Enabling OpenHAB persistence

Check that package org.openhab.persistence.rrd4j-1.7.1.jar is present in folder openhab/addons

Create a persistence rule

Move to persistence folder:

cd /opt/openhab/configurations/persistence

Create a new persistence rule:

`sudo nano rrd4j.persist’

And create your own rule according to openhab syntax.

My persist file is published here

Restart openhab:

sudo /etc/init.d/openhab restart

To check that persistence is working you can look in /opt/openhab/etc/rrd4j/ for fresh rrd files.

If persistence and habmin are working on your system you may play a bit with very nice graphs:

General Tips

Some general tips about Java perfomace on Raspberry Pi.

rpi-update

Stay up to date with rpi-update An easier way to update the firmware of your Raspberry Pi.

System memory

Java loves memory. I’d rather suggest you to operate this unit headless and reduce GPU memory.

Run sudo raspi-config select memory_split and decrease GPU memory to 16. You’ll get more than 100 Mb of additional system memory.

Disabling TV Service

For headless, add these to /etc/rc.local:

## Limit GPU IRQs
fbset -xres 16 -yres 16 -vyres 16 -depth 8
/opt/vc/bin/tvservice -o

Swap file

Do not swap! Manage your JVM memory consumption with -ms and -mx keys. If you absolutely have to swap move swap file (/var/swap) to USB HDD of fast flash drive because swapping to SD card is painfully slow. You can set swap size in /etc/dphys-swapfile config file.

Overclocking

Overclocking does not seem to have a significant impact on OpenHAB performances.

The ESP8266 in Commercial Products!

2015-08-29T00:00:00+00:00

The ESP8266 is a cheap WiFi SoC that is getting a growing interest within Makers and many people have asked them-self if this extremely low price (is sold at 5$ for a single piece) is hitting the market of cheap products.

Andreas looking inside an RGBWW (5 channels, 3 for RGB and 2 for White) controller has found an ESP8266 and even the connector to program it with the Arduino cores.

This device sells at 10$ for a single piece and can be used with any custom Arduino sketch, like this one below

/**************************************************************************
    Souliss - RGB LED Strip Hack
    
    Control and RGB LED or a Strip using the PWM, fade in/out and flash 
    effects are available as the Android interface or openHAB.
 
    Run this code on one of the following boards:
      - RGBW Led Strip Driver based on ESP8266
    
***************************************************************************/

// 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

// **** 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 <EEPROM.h>
#include "Souliss.h"

#define LEDCONTROL        0
#define LEDRED            1
#define LEDGREEN          2
#define LEDBLUE           3
#define	LEDSTRIP1         4
#define LEDWHITE1         5
#define LEDSTRIP2         6
#define LEDWHITE2         7

void setup()
{   
    Initialize();

	  analogWriteFreq(500);
	  analogWriteRange(255);

    // Get the IP address from DHCP
    GetIPAddress();                          
    SetAsGateway(myvNet_dhcp);                  // Set this node as gateway for SoulissApp                        
                
    Set_LED_Strip(LEDCONTROL);                  // Set a logic to control a LED strip
    Set_DimmableLight(LEDSTRIP1);
    Set_DimmableLight(LEDSTRIP2);
   
    // Define inputs, outputs pins
    pinMode(12, OUTPUT);                 // Power the LED
    pinMode(13, OUTPUT);                 // Power the LED
    pinMode(15, OUTPUT);                 // Power the LED    
    pinMode(14, OUTPUT);                 // Power the LED
    pinMode(4,  OUTPUT);                 // Power the LED 
}

void loop()
{ 
    // Here we start to play
    EXECUTEFAST() {                     
        UPDATEFAST();   

        // Execute the code every 1 time_base_fast      
        FAST_10ms() {
                    
            // Execute the logic that handle the LED
            Logic_LED_Strip(LEDCONTROL);
            Logic_DimmableLight(LEDSTRIP1);
            Logic_DimmableLight(LEDSTRIP2);

            // Use the output values to control the PWM
            analogWrite(15, mOutput(LEDRED);
            analogWrite(13, mOutput(LEDGREEN);
            analogWrite(12, mOutput(LEDBLUE);
            analogWrite(14, mOutput(LEDWHITE1);
            analogWrite(4, mOutput(LEDWHITE2));

            // Just process communication as fast as the logics
            ProcessCommunication();
        } 

        // Process the other Gateway stuffs
        FAST_GatewayComms();
          
    }
    EXECUTESLOW()
    {   
        UPDATESLOW();

        SLOW_10s()  {
        
            // The timer handle timed-on states
            Timer_LED_Strip(LEDCONTROL); 
            Timer_DimmableLight(LEDSTRIP1);
            Timer_DimmableLight(LEDSTRIP2);                       
        }     
    }       
}

A couple of friends are just getting a sample to use it with Souliss, stay tuned!

Build your DIY Arduino compatible Philips Hue like LED Bulb, using LYT and Souliss

2015-08-13T00:00:00+00:00

Recently a lot of RF light bulbs with smartphone enabled control has been on the market, the most known and expencive is the Philips Hue, but other cheaper solution like the Mi-Light has been out for a while. All offer a smartphone app to control remotely the brightness and the color, but none is Arduino compatible.

In this video we review the LYT bulbs from Authometion, the first Arduino controlled light bulbs. Here instead of have a gateway that bridge your smartphone to your lamps you have an Arduino shield, this enable you to make your own Philips Hue like bulbs.

In the video we runs Souliss as framework and control the light with SoulissApp, below you can find a step by step guide to get it working.

Overview

The shield is the piece of hardware that you are really looking for, is from that one that you can send radio commands to the lamps and get feedback. There are two radio, an ESP8266 WiFi SoC and a PL1167 2.4 GHz radio, the former is used to connect your Arduino with the home router and the latter is to control the bulbs.

The PL1167 is a SPI radio wired to the microcontroller of your Arduino board (UNO and Leonardo are the most appropriate), the ESP8266 and the Arduino are connected via USART. From the Authometion store you can download the libraries and examples, those allow you to bridge command via WiFi to the USART and then to the PL1167. A mirror copy with few modification to integrate with Souliss is available on our Google Drive.

In our case we will not use the Authometion examples, but a Souliss dedicated one, so that you can get control of your bulbs directly from SoulissApp or openHAB.

We will run two instances of Souliss, one on the ESP8266 and the other on the Arduino board, this because Souliss embed the communication between different nodes and this let us skip the writing of a custom code to link these two devices.

The bulb is a 9 Watt with RGB+W LEDs, the white has a very good bright and colors allow to create moods effect with a good color depth, is bigger than standard bulbs but smaller than other radio controlled ones. It should generally fit in most of the lamps with E27 plug, but you should cross-check if you are using lamps with very small space or smaller plug type.

Lets start, unpack and have a first try

As first step, we should load the Authometion libraries and use them to verify if our lamps are working properly. Those are standard Arduino libraries, so import them using the Arduino IDE and restart it, you should see three new more folders in the Example submenu: LYTWiFi, PL1167 and Messanger in the LYTWiFi one there is the demo_firmware_lytwifi.ino that is a good starting point.

Ensure that the jumper on your shield are all on the left side as per previous picture, this means that PL1167 is using PIN10 as Chip Select (doesn’t play nice with Arduino Ethernet, be aware) and SoftwareSerial to communicate with ESP8266. Load the demo_firmware_lytwifi.ino from Examples->Lytwifi menu and start the Serial Monitor, ensure that you are matching the baudrate of your sketch (default is 9600 bps) and the Carriare Return is set, then type the following command

PON,0,0,1

This is the ON command for lamp with address 0, 0 the last parameter means that you don’t want a feedback answer from the lamp. If your lamp is properly powered, it will turn ON in full white. Turn it OFF as,

POF,0,0,1

If you want to have a fun with colors, use the following to get a RED

RGB,0,0,255,0,0,1

Address of the lamps

If you have multiple lamps, you may want to control them independently, so you need to assign them a unique address (this isn’t related to the vNet address of the Souliss nodes) that can be done using

SEA,0,0,0,1

The command listed above assign the address 0, 1 to the lamp 0, 0. All lamp are shipped with 0, 0 as default address, so you should give power to one lamp per time and proceed assigning an unique address for each lamp. You are free to use the digits that you like, a suggestion is to use the first digit to identify the room and the other for the lamp.

Note down all the assigned address and relevant lamps, you will need this information while setting up the Souliss code.

If desired, you can save a pre-defined state for the lamp (ON/OFF, color and brightness) typing SAV in the Serial monitor, this will save the current state and every time the lamp is powered-on that state will be used as starting condition.

Load Souliss

As stated before, you will have two instanced of Souliss and that’s why you will found two sketches in the LYT folder. One is for the ESP8266 and the other for the Arduino board that control the PL1167.

Load Souliss on ESP8266

Remove the shield from the Arduino and connect the pins to a USB to USART at 3v3 as shown in the below picture (pay attention, the brown wire is connected on the back of the shield on the GND and the last two pins on JP4 need a jumper only while updating the sketch). Unsure that you are powering the device at 3v3, in the picture you can see the red wire that supply DC.

You need to setup the Arduino IDE for the support of ESP8266, this tutorial can help you if you haven’t done before; select Generic ESP8266 for the IDE menu and use 80 MHz as clock option leaving all the others at default settings.

Open the Souliss sketch for ESP8266 from the Example->souliss->LYT menu and load it, don’t forget to customize the sketch with your SSID and Password. If this succeed, you will see two empty node in SoulissApp. The IP address of the ESP8266 depends on the DHCP, so you don’t know it in advance. Generally SoulissApp detect a gateway automatically, is enough that no IP address has been set in the application. If this doesn’t work, open your router webpage and look for the assigned IP address, otherwise use Fing application for Android to get the address of the ESP8266 (look for ExpressIf as manufacturer).

/**************************************************************************
    Souliss - LYT Light Bulb
    
    This sketch control the Authometion LYT bubls through the Authometion
    shield.
    
    Load this sketch on an ESP8266 WiFi module used to bridge via USART the
	Arduino AVR microcontroller that handle the radio.
    Verify shield's jumpers and select Hardware Usart while using this sketch, 
    remember to remove the jumpers before programming the Arduino. Use pin 10 as
	chip select for the radio.
        
***************************************************************************/

// 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/usart_fast.h"                // USART / RS485 transceiver
#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 <ESP8266WiFi.h>
#include <EEPROM.h>
#include "Souliss.h"

void setup()
{   
    Initialize();

    // Connect to the WiFi network and get an address from DHCP
    GetIPAddress();                           
    SetAsGateway(myvNet_dhcp);       // Set this node as gateway for SoulissApp  

    // This is the vNet address for this node, used to communicate with other
    // nodes in your Souliss network
    SetAddress(0xAB01, 0xFF00, 0x0000);
    SetAddress(0xCE01, 0xFF00, 0x0000);
    SetAsPeerNode(0xCE02, 1);
}

void loop()
{ 
    // Here we start to play
    EXECUTEFAST() {                     
        UPDATEFAST();   
             
        // Process the communication basic at max speed, this allow smooth handling of color and music synch                                
        ProcessCommunication(); 
            
        // Complete the communication tasks at normal rate
        FAST_GatewayComms();
    }
}

You will just see two empty node, because the dirty job is done by the Arduino board.

Load Souliss on Arduino

Don’t insert the shield on the Arduino, just program the board as standalone using the appropiate sketch that is always in Example->souliss->LYT, don’t forget to customize the address of your LYT (if you have changed them). Refer to the Getting Started guide for details.

Before insert the shield, ensure that the JP1 and JP2 are selected for the Hardware USART as shown in the picture below,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/**************************************************************************
    Souliss - LYT Light Bulb
    
    This sketch control the Authometion LYT bubls through the Authometion
    shield.
    
    Load this sketch on an Arduino UNO/Duemilanove (use of Leonardo require
    the use of the proper USART configuration) and using the USART bridge it
    to an ESP8266 WiFi module.
    Verify shield's jumpers and select Hardware Usart while using this sketch, 
    remember to remove the jumpers before programming the Arduino. Use pin 10 as
    chip select for the radio.
    
***************************************************************************/
#include "bconf/StandardArduino.h"              // Use an Arduino board
#include "bconf/LYT88_LEDBulb_Radio.h"          // Define the board type
#include "conf/usart_fast.h"                    // Ethernet through Wiznet W5100

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

// Include Authometion libraries
#include <PL1167.h>
#include <Lytwifi.h>
#include <WiFiInterrupt.h>

// There are not used in this sketch, keep it just to pat the compiler
#include <EEPROM.h>
#include <SoftwareSerial.h>

// Define logic slots, multicolor lights use four slots
#define LYTLIGHT1           0                   

void setup()
{   
    Initialize();
    
    // Set network parameters
    SetAddress(0xCE02, 0xFF00, 0xCE01);
    
    // Se the LYT bulbs (index, bulb type, addr_a, addr_b, logic slot), here we have
    // the first lamp (index 0) with default addresses (0, 0). Change these based on
    // the configuration of your lamps.
    InitLYT();
    SetLYT(0, 0, 0, LYTLIGHT1);

    // Define a logic to handle the bulb(s)
    SetLYTLamps(LYTLIGHT1); 
}

void loop()
{ 
    // Here we start to play
    EXECUTEFAST() {                     
        UPDATEFAST();   
        
        // Is an unsual approach, but to get fast response to color change we run the LYT logic and
        // basic communication processing at maximum speed.
        LogicLYTLamps(LYTLIGHT1);       
        ProcessCommunication();
        
        // Here we process all communication with other nodes
        FAST_1110ms() {
            LYTState(LYTLIGHT1);
        }
        
    }   
    
    EXECUTESLOW() {
        UPDATESLOW();
        
        SLOW_10s() {
            LYTStateRequest();              // Request the lamp state
            LYTSleepTimer(LYTLIGHT1);       // Slowly shut down the lamp
        }
    }
}

You should now be able to see two nodes and one (or more, based on your sketch) light bulb ready to be controlled.

Add multiple bulbs

If you have multiple bulbs the best option is to set for each one a dedicated address, this can be done using the } command as discussed before. Once you have your lamp with the relevant address you just need to copy/paste the relevant code and assigning a new slot and address, as example two bulbs with address 0, 1 and 0, 2 will looks like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include "bconf/StandardArduino.h"              // Use an Arduino board
#include "bconf/LYT88_LEDBulb_Radio.h"          // Define the board type
#include "conf/usart_fast.h"                    // Ethernet through Wiznet W5100

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

// Include Authometion libraries
#include <PL1167.h>
#include <Lytwifi.h>
#include <WiFiInterrupt.h>

// There are not used in this sketch, keep it just to pat the compiler
#include <EEPROM.h>
#include <SoftwareSerial.h>

#define LYTLIGHT1           0                   
#define LYTLIGHT2           4  // Each RGB lamp use 4 slots                   

void setup()
{   
    Initialize();
    
    // Set network parameters
    SetAddress(0xCE02, 0xFF00, 0xCE01);
    
    // Se the LYT bulbs (index, bulb type, addr_a, addr_b, logic slot), here we have
    // the first lamp (index 0) with default addresses (0, 0). Change these based on
    // the configuration of your lamps.
    InitLYT();
    SetLYT(0, 0, 1, LYTLIGHT1);
    SetLYT(1, 0, 2, LYTLIGHT2);

    // Define a logic to handle the bulb(s)
    SetLYTLamps(LYTLIGHT1); 
    SetLYTLamps(LYTLIGHT2); 

}

void loop()
{ 
    // Here we start to play
    EXECUTEFAST() {                     
        UPDATEFAST();   
        
        // Is an unsual approach, but to get fast response to color change we run the LYT logic and
        // basic communication processing at maximum speed.
        LogicLYTLamps(LYTLIGHT1);       
        LogicLYTLamps(LYTLIGHT2);       
        ProcessCommunication();
        
    }  
}

New LYT Led Bulb are Here!

2015-08-03T00:00:00+00:00

Just received from our friends at Authometion a sample kit with three LYT88 RGBW and a shield based on ESP8266. I’ve played in the past with the previous prototypes of LYT that has been in my home for almost a year with very good result.

The LYT bulb sells at 24,90 euros and are as far as I know are the only Arduino controllable LED bulb on the market.

Those will be officially included in the next Souliss release, so lets start to get your lamps on the Authometion store!

Have a look of what you can do using Souliss and LYT in the following video

Go to the step by step tutorial to get started with LYT88 Bulbs and Souliss!

Use ThingSpeak and Pushbullet with Souliss

2015-07-26T00:00:00+00:00

This tutorial will make your Souliss Node able to send notification to Pushbullet through Thinkspeak, in this example we will notify the state of lamp controlled by a relay.

This tutorial applies on all nodes that has internet connection via W5100 (for AVR based boards) or ESP8266, in case of W5100 is suggested to run the code on an Arduino Mega or any other AVR with larger RAM than a standard Arduino UNO or similar.

Start from a basic example like e01_HelloWorld for W5100 Ethernet based devices or e01_Hello_ESP8266 for ESP8266. Add the following code to your Arduino sketch, first we got to declare ThingSpeak API and ThingSpeak server, add this in top of your sketch

// ThingSpeak API
const char* apiKey = "Your ThingSpeak API key";
const char* serverTS = "api.thingspeak.com";

In your Souliss Node sketch you should have a code to push the output state, this can be added after the Logic_SimpleLight() call, your sketch will looks like:

FAST_50ms() {   // We process the logic and relevant input and output every 50 milliseconds
   Logic_SimpleLight(MYLEDLOGIC);
   DigOut(OUTPUTPIN, Souliss_T1n_Coil,MYLEDLOGIC);
   
   sendOutputState(MYLEDLOGIC);
}

Here we define the sendOutputState that will push your data, place this before void loop(){}

  // send data to ThingSpeak.com
  void sendOutputState(uint8_t slot){
       
	   // If there is nothing to show
	   if (!isTrigger())
         return;
		 
       WiFiClient client;
       if(!client.connect(serverTS,80)) {  //   "184.106.153.149" or api.thingspeak.com
          Serial.println("Connection Fail!");
        }
        else {
          String postStr = apiKey;
                 postStr +="&field1=";
                 postStr += String(mOutput(slot));
                 postStr += "\r\n";
 
                 client.print("POST /update HTTP/1.1\n");
                 client.print("Host: api.thingspeak.com\n");
                 client.print("Connection: close\n");
                 client.print("X-THINGSPEAKAPIKEY: "+apiKey+"\n");
                 client.print("Content-Type: application/x-www-form-urlencoded\n");
                 client.print("Content-Length: ");
                 client.print(postStr.length());
                 client.print("\n\n");
                 client.print(postStr);
                 Serial.println("Send Relay State to Thingspeak");
 
        }
  client.stop();
  Serial.println("Client to send Stoped");
  
}

Now we need to setup ThingSpeak Channel, ThingHTTP and React, but first you will need Pushbullet token, so create pushbullet account, then create ThingSpeak account. And follow those steps:

Create New Channel in ThingSpeak, name it as you wish, in my case “PushbulletTriggerKamar”. Make sure you have one field, use field 1 and name it as “Relay State”

Click APPS in ThingSpeak, and click ThingHTTP app, create new ThingHTTP, this will send http request to pushbullet if the Light ON, fill the field as the picture

Create another ThingHTTP for the Light OFF, follow the picture below..

You can change the text body to fit your need, but it must be in json format.. I suggest just change this line

` {“type”: “note”, “title”: “IoT Message”, “body”: “Lampu Teras ON”} `

into something like this :

` {“type”: “note”, “title”: “Message from Home”, “body”: “LIGHT ON”} `

Back to ThingSpeak APPS, now click React app, create new React, this will execute ThingHTTP is some condition meet.. we create a new React for Light ON

Last step, create another React for Light OFF

You are done, now everytime you pressing ON OFF button in SoulissApp you should get notification in Pushbullet.

How to load Souliss on ESP8266.

2015-07-21T00:00:00+00:00

This tutorial shows how to load custom code on the ESP8266 based modules, like Expressif ESP-01, ESP-12 or the Olimex ESP8266-EVB, this is based on the porting of Arduino cores for the ESP8266 microcontroller.

ESP-12

Even if we focus on ESP-12, but this tutorial applies for all breakout modules based on ESP8266, you just need to cross check the pin assignment on the PCB, to start you need:

ESP-12 module
USB to Serial Converter at 3v3 (FTDI PL2303 - CH340 and others)

Wiring

The are two main wiring schemes that you will need to use, those are referred as USART Mode and FLASH Mode. The former is used to load a new code and the latter to run that code, from this point on is assumed that the code will be loaded into the companion FLASH memory. The use of the external FLASH memory is not the only available option with the ESP8266, but all the commercial modules based on this SoC use this approach, so that the MTDO pin is always at GND.

The minimal setup required to load a new sketch on your ESP8266 based module is the following one

USART Mode ESP-01 and others

PIN	Resistor	Serial Adapter
VCC		VCC (3.3V)
GND		GND
TX or GPIO1		RX
RX or GPIO3		TX
GPIO0		GND
GPIO2		VCC (3.3V)
Reset		RTS*
GPIO15	PullDown
CH_PD	PullUp

Note
- if no RTS is used a manual toggle is needed

Once the sketch has been loaded, you can run your module using the following setup

Operating Mode ESP-01 and others

PIN	Resistor	Power supply
VCC		VCC (3.3V)
GND		GND
GPIO0	PullUp
GPIO15	PullDown
CH_PD	PullUp

Minimal

Improved Stability

Important Note

Before load the code in the module you need to start it in USART Mode, this is achieved following these steps:

Remove power from the module
Connect GPIO-0 to GND
Connect GPIO-2 to VCC
Power the module

At this point the module is in USART Mode and you can load the code from the Arduino IDE (see details below). Once completed the load of the code:

Remove power from the module
Connect GPIO-0 to VCC
Connect GPIO-2 to VCC
Power the module

The module will start using the code loaded in the external FLASH memory, once the boot has been completed the GPIO-0 and GPIO-2 can be used as standard I/O pins.

Olimex ESP8266-EVB

The Olimex ESP8266-EVB is an evaluation board for quick prototyping with ESP8266, it doesn’t require you any soldering action.

In order to start with this module you need

A regular 5V / 500 mA power supply with classic DC jack
USB to Serial Converter at 3v3 (FTDI PL2303 - CH340 and others)

You need to connect your USB to Serial converter according to the following table on the UEXT connector, the pinout that follow refers to a male connector

ESP8266-EVB	Serial Adapter
GND		GND
TX		RX
RX		TX

Is convenient to power the board from an external power-supply, because you need to remove power every time that you need to load a new code on the ESP8266 and because the USB to Serial converter is generally not able to provide enough power to on-board relay.

Before load the code in the module you need to start it in Bootloader Mode, this is achieved following these steps:

Remove power from the module
Press (keep pressed) the button on the board
Power the module and release the button after a couple of seconds

At this point the module is in Bootloader Mode and you can load the code from the Arduino IDE (see details below). Once completed the load of the code you just need to power-cycle the module to get your code executed.

Arduino IDE

The Arduino IDE allow an easy add-on of cores that has been developed by the community, this allow you reuse Arduino-like codes and libraries on non official boards. Perform the following steps to add the ESP8266 cores:

Install the latest Souliss’ supported Arduino IDE and have a general read of the Getting Started guide
Create a folder called portable inside the IDE main folder
Start Arduino and open Preferences window.
Refer to the latest supported core for Souliss in the wiki
Follow the installation instruction ESP8266 cores for Arduino, the cores are distributed via the Arduino IDE Board Manager and needs an URL for the distribution of the code. You can check the supported core here
As today, the URL to be used is http://arduino.esp8266.com/stable/package_esp8266com_index.json into Additional Board Manager URLs field. You can add multiple URLs, separating them with commas.
Open Boards Manager from Tools > Board menu and install ESP8266 platform (you will need to select your ESP8266 board from Tools > Board menu after installation).
Install Souliss library on Library Manager of Arduino IDE

At this point follow the procedure that has been reported previously to set the ESP8266 in Bootloader Mode and load the code from the Arduino IDE. Souliss include several examples, some are listed below:

Gateway code for generic ESP8266 e01_Hello_ESP8266
Peer code for generic ESP8266 e01_Peer_ESP8266
Gateway code for Olimex ESP8266-EVB e04_Olimex_ESP8266-EVB

The ESP8266 cores for Arduino are maintained by the ESP8266 Community.

First Prototypes are Ready!

2015-06-21T00:00:00+00:00

Just got an email from KMP Electronics in the Inbox with some nice picture attached.

This works with nRF24L01 radios and ESP8266 WiFi transceiver, has three sockets for Grove sensors and works on LiPo battery with onboard charger.

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.

Stand a year: By design all sensor can be switched off as long as the nRF24L01 radio to stay longer between charges. Using LiPo you can size the needed amount energy to keep the node running a year or more.

souliss

Souliss and Visual Studio 2019

SoulissApp Android 10 update

DST - Digital Souliss Thermostat

Use the KMP DINo WiFi (ESP8266)

Parliamo di SmartHome a Torino, Bologna, Milano e Roma!

Using Eclipse Arduino IDE with Souliss

Download and install

Download Arduino IDE Bundle

Unpack Eclipse Arduino IDE

Download Arduino IDE 1.6.5

Download make.exe

Configure Eclipse Arduino IDE

Configure Arduino plugin

Set the save before build option

Add .ino and .pde as C++ Source

Create and compile first Sketch

Create new Arduino Sketch based on blink example

Compile (Verify) your sketch

Upload your sketch

Create and compile Souliss sketch

Download Souliss

Unpack Souliss

Create new Arduino Sketch based on Souliss example

Add libraries to your sketch

Exclude some souliss file from compilation

Compile (Verify) your sketch

How much power a smart bulb need?

The new ESP8266 based ProDINo is coming!

Have fun with WiFiPixels

Smart Socket Hack Tutorial

In a Nutshell

Automate with Automate

Are you lazy enough? Automate and Tasker integration

SoulissApp Tasker and Automate integrations

Maker Faire Rome 2015

IONO Ethernet Relay Board

LYT8226: an Arduino LED Bulb based on ESP8266 WiFi

Multicolor WiFi Bulb, the first Arduino based one

SoulissApp 1.5.4 is out with Voice Recognition!

How to install OpenHAB on RaspberryPi2.

Purchasing the hardware

Configuring the RPi (headless)

Connecting

Setting a static IP Address

Installing JVM

Installing OpenHAB

Configure Souliss binding

Souliss binding basic configuration

items configuration

sitemaps configuration

using custom icons

Start OpenHAB manually

Configuring openHAB to Start Automatically at Boot

Installing HABmin

Enabling OpenHAB persistence

Create a persistence rule

General Tips

rpi-update

System memory

Swap file

Overclocking

The ESP8266 in Commercial Products!

Build your DIY Arduino compatible Philips Hue like LED Bulb, using LYT and Souliss

Overview

Lets start, unpack and have a first try

Address of the lamps

Load Souliss

Add multiple bulbs

New LYT Led Bulb are Here!

Use ThingSpeak and Pushbullet with Souliss

How to load Souliss on ESP8266.

ESP-12

Wiring

Minimal

Improved Stability

Olimex ESP8266-EVB

Arduino IDE

First Prototypes are Ready!

Add `.ino` and `.pde` as C++ Source