diff --git a/app/include/sections.h b/app/include/sections.h
index d09c576e..58613c90 100644
--- a/app/include/sections.h
+++ b/app/include/sections.h
@@ -2,5 +2,6 @@
 #define _SECTIONS_H_
 
 #define TEXT_SECTION_ATTR __attribute__((section(".text")))
+#define RAM_CONST_SECTION_ATTR __attribute((section(".data")))
 
 #endif
diff --git a/app/include/user_modules.h b/app/include/user_modules.h
index 40b6dbb6..f34285f7 100644
--- a/app/include/user_modules.h
+++ b/app/include/user_modules.h
@@ -53,6 +53,7 @@
 //#define LUA_USE_MODULES_RTCTIME
 //#define LUA_USE_MODULES_SIGMA_DELTA
 //#define LUA_USE_MODULES_SNTP
+//#define LUA_USE_MODULES_SOMFY
 #define LUA_USE_MODULES_SPI
 //#define LUA_USE_MODULES_STRUCT
 //#define LUA_USE_MODULES_SWITEC
diff --git a/app/modules/somfy.c b/app/modules/somfy.c
new file mode 100644
index 00000000..4266aa6e
--- /dev/null
+++ b/app/modules/somfy.c
@@ -0,0 +1,248 @@
+// ***************************************************************************
+// Somfy module for ESP8266 with NodeMCU
+// 
+// Written by Lukas Voborsky, @voborsky
+// based on https://github.com/Nickduino/Somfy_Remote
+// Somfy protocol description: https://pushstack.wordpress.com/somfy-rts-protocol/
+// and discussion: https://forum.arduino.cc/index.php?topic=208346.0
+// 
+// MIT license, http://opensource.org/licenses/MIT
+// ***************************************************************************
+
+//#define NODE_DEBUG
+
+#include "os_type.h"
+#include "osapi.h"
+#include "sections.h"
+
+#include "module.h"
+#include "lauxlib.h"
+#include "lmem.h"
+#include "platform.h"
+#include "hw_timer.h"
+#include "user_interface.h"
+
+#define SYMBOL 640 // symbol width in microseconds
+#define SOMFY_UP    0x2
+#define SOMFY_STOP  0x1
+#define SOMFY_DOWN  0x4
+#define SOMFY_PROG  0x8
+
+#define DIRECT_WRITE_LOW(pin)    (GPIO_OUTPUT_SET(GPIO_ID_PIN(pin_num[pin]), 0))
+#define DIRECT_WRITE_HIGH(pin)   (GPIO_OUTPUT_SET(GPIO_ID_PIN(pin_num[pin]), 1))
+
+static const os_param_t TIMER_OWNER = 0x736f6d66; // "somf"
+static task_handle_t done_taskid;
+
+static uint8_t    pin;
+static uint8_t    frame[7];
+static uint8_t    sync;
+static uint8_t    repeat;
+
+//static uint32_t   delay[10] = {9415, 89565, 4*SYMBOL, 4*SYMBOL, 4*SYMBOL, 4550, SYMBOL, SYMBOL, SYMBOL, 30415}; // in us
+// the `delay` array of constants must be in RAM as it is accessed from the timer interrupt
+static const RAM_CONST_SECTION_ATTR uint32_t delay[10] = {US_TO_RTC_TIMER_TICKS(9415), US_TO_RTC_TIMER_TICKS(89565), US_TO_RTC_TIMER_TICKS(4*SYMBOL), US_TO_RTC_TIMER_TICKS(4*SYMBOL), US_TO_RTC_TIMER_TICKS(4*SYMBOL), US_TO_RTC_TIMER_TICKS(4550), US_TO_RTC_TIMER_TICKS(SYMBOL), US_TO_RTC_TIMER_TICKS(SYMBOL), US_TO_RTC_TIMER_TICKS(SYMBOL), US_TO_RTC_TIMER_TICKS(30415)}; // in ticks (no need to recalculate)
+
+static uint8_t    repeatindex;
+static uint8_t    signalindex;
+static uint8_t    subindex;
+static uint8_t    bitcondition;
+
+int lua_done_ref; // callback when transmission is done
+
+void buildFrame(uint8_t *frame, uint64_t remote, uint8_t button, uint16_t code) {
+    // NODE_DBG("remote: %x\n", remote);
+    // NODE_DBG("button: %x\n", button);
+    // NODE_DBG("rolling code: %x\n", code);
+    frame[0] = 0xA7; // Encryption key. Doesn't matter much
+    frame[1] = button << 4; // Which button did you press? The 4 LSB will be the checksum
+    frame[2] = code >> 8; // Rolling code (big endian)
+    frame[3] = code;         // Rolling code
+    frame[4] = remote >> 16; // Remote address
+    frame[5] = remote >> 8; // Remote address
+    frame[6] = remote;         // Remote address
+    // frame[7] = 0x80;
+    // frame[8] = 0x0;
+    // frame[9] = 0x0;
+
+    // NODE_DBG("Frame:\t\t\t%02x %02x %02x %02x %02x %02x %02x\n", frame[0], frame[1], frame[2], frame[3], frame[4], frame[5], frame[6]);
+    // Checksum calculation: a XOR of all the nibbles
+    uint8_t checksum = 0;
+    for(uint8_t i = 0; i < 7; i++) {
+        checksum = checksum ^ frame[i] ^ (frame[i] >> 4);
+    }
+    checksum &= 0b1111; // We keep the last 4 bits only
+
+    //Checksum integration
+    frame[1] |= checksum; //    If a XOR of all the nibbles is equal to 0, the blinds will consider the checksum ok.
+    // NODE_DBG("With checksum:\t%02x %02x %02x %02x %02x %02x %02x\n", frame[0], frame[1], frame[2], frame[3], frame[4], frame[5], frame[6]);
+
+    // Obfuscation: a XOR of all the uint8_ts
+    for(uint8_t i = 1; i < 7; i++) {
+        frame[i] ^= frame[i-1];
+    }
+    // NODE_DBG("Obfuscated:\t\t%02x %02x %02x %02x %02x %02x %02x\n", frame[0], frame[1], frame[2], frame[3], frame[4], frame[5], frame[6]);
+}
+
+static void somfy_transmissionDone (task_param_t arg)
+{
+    lua_State *L = lua_getstate();
+    lua_rawgeti (L, LUA_REGISTRYINDEX, lua_done_ref);
+    luaL_unref (L, LUA_REGISTRYINDEX, lua_done_ref);
+    lua_done_ref = LUA_NOREF;
+    lua_call (L, 0, 0);
+}
+
+static void ICACHE_RAM_ATTR sendCommand(os_param_t p) {
+    (void) p;
+    //  NODE_DBG("%d\t%d\n", signalindex, subindex);
+    switch (signalindex) {
+        case 0:
+            subindex = 0;
+            if(sync == 2) { // Only with the first frame.
+                //Wake-up pulse & Silence
+                DIRECT_WRITE_HIGH(pin);
+                signalindex++;
+                // delayMicroseconds(9415);
+                break;
+            } else {
+                signalindex++; signalindex++; //no break means: go directly to step 3
+            }
+        case 1:
+            //Wake-up pulse & Silence
+            DIRECT_WRITE_LOW(pin);
+            signalindex++;
+            // delayMicroseconds(89565);
+            break;
+        case 2:
+            signalindex++; 
+            // no break means go directly to step 3
+            // a "useless" step to allow repeating the hardware sync w/o the silence after wake-up pulse
+        case 3:
+            // Hardware sync: two sync for the first frame, seven for the following ones.
+            DIRECT_WRITE_HIGH(pin);
+            signalindex++;
+            // delayMicroseconds(4*SYMBOL);
+            break;
+        case 4:
+            DIRECT_WRITE_LOW(pin);
+            subindex++;
+            if (subindex < sync) {signalindex--;} else {signalindex++;}
+            // delayMicroseconds(4*SYMBOL);
+            break;
+        case 5:
+            // Software sync
+            DIRECT_WRITE_HIGH(pin);
+            signalindex++;
+            // delayMicroseconds(4550);
+            break;
+        case 6:
+            DIRECT_WRITE_LOW(pin);
+            signalindex++;
+            subindex=0;
+            // delayMicroseconds(SYMBOL);
+            break;
+        case 7:
+            //Data: bits are sent one by one, starting with the MSB.
+            bitcondition = ((frame[subindex/8] >> (7 - (subindex%8))) & 1) == 1;
+            if(bitcondition) {
+                DIRECT_WRITE_LOW(pin);
+            }
+            else {
+                DIRECT_WRITE_HIGH(pin);
+            }
+            signalindex++;
+            // delayMicroseconds(SYMBOL);
+            break;
+        case 8:
+            //Data: bits are sent one by one, starting with the MSB.
+            if(bitcondition) {
+                DIRECT_WRITE_HIGH(pin);
+            }
+            else {
+                DIRECT_WRITE_LOW(pin);
+            }
+            
+            if (subindex<56) {
+                subindex++;
+                signalindex--;
+            }
+            else {
+                signalindex++;
+            }
+            // delayMicroseconds(SYMBOL);
+            break;
+        case 9:
+            DIRECT_WRITE_LOW(pin);
+            signalindex++;
+            // delayMicroseconds(30415); // Inter-frame silence
+            break;
+        case 10:
+            repeatindex++;
+            if (repeatindex<repeat) {
+                DIRECT_WRITE_HIGH(pin); //start repeat from step 3, but don't wait as after step 1
+                signalindex=4; subindex=0; sync=7;
+            } else {
+                platform_hw_timer_close(TIMER_OWNER);
+                if (lua_done_ref != LUA_NOREF) {
+                    task_post_low (done_taskid, (task_param_t)0);
+                }
+            }
+            break;
+    }
+    if (signalindex<10) {
+        platform_hw_timer_arm_ticks(TIMER_OWNER, delay[signalindex-1]);
+    }
+}
+
+static int somfy_lua_sendcommand(lua_State* L) { // pin, remote, command, rolling_code, num_repeat, callback
+    if (!lua_isnumber(L, 4)) {
+        return luaL_error(L, "wrong arg range");
+    }
+    pin = luaL_checkinteger(L, 1);
+    uint64_t remote = luaL_checkinteger(L, 2);
+    uint8_t cmd = luaL_checkinteger(L, 3);
+    uint16_t code = luaL_checkinteger(L, 4);
+    repeat=luaL_optint( L, 5, 2 );
+
+    luaL_argcheck(L, platform_gpio_exists(pin), 1, "Invalid pin");
+
+    luaL_unref(L, LUA_REGISTRYINDEX, lua_done_ref);
+    if (!lua_isnoneornil(L, 6)) {
+        lua_pushvalue(L, 6);
+        lua_done_ref = luaL_ref(L, LUA_REGISTRYINDEX);
+    } else {
+        lua_done_ref = LUA_NOREF;
+    }
+
+    MOD_CHECK_ID(gpio, pin);
+    platform_gpio_mode(pin, PLATFORM_GPIO_OUTPUT, PLATFORM_GPIO_PULLUP);
+
+    buildFrame(frame, remote, cmd, code);
+    
+    if (!platform_hw_timer_init(TIMER_OWNER, FRC1_SOURCE, TRUE)) {
+        // Failed to init the timer
+        luaL_error(L, "Unable to initialize timer");
+    }
+    platform_hw_timer_set_func(TIMER_OWNER, sendCommand, 0);
+    sync=2;
+    signalindex=0; repeatindex=0;
+    sendCommand(0);
+    return 0;
+}
+
+static const LUA_REG_TYPE somfy_map[] = {
+    { LSTRKEY( "UP" ),    LNUMVAL( SOMFY_UP ) },
+    { LSTRKEY( "DOWN" ),    LNUMVAL( SOMFY_DOWN ) },
+    { LSTRKEY( "PROG" ),    LNUMVAL( SOMFY_PROG ) },
+    { LSTRKEY( "STOP" ),    LNUMVAL( SOMFY_STOP ) },
+    { LSTRKEY( "sendcommand" ), LFUNCVAL(somfy_lua_sendcommand)},
+    { LNILKEY, LNILVAL}
+};
+
+int luaopen_somfy( lua_State *L ) {
+    done_taskid = task_get_id((task_callback_t) somfy_transmissionDone);
+    return 0;
+}
+
+NODEMCU_MODULE(SOMFY, "somfy", somfy_map, luaopen_somfy);
\ No newline at end of file
diff --git a/docs/en/modules/somfy.md b/docs/en/modules/somfy.md
new file mode 100644
index 00000000..07fe0a41
--- /dev/null
+++ b/docs/en/modules/somfy.md
@@ -0,0 +1,44 @@
+# Somfy module
+| Since  | Origin / Contributor  | Maintainer  | Source  |
+| :----- | :-------------------- | :---------- | :------ |
+| 2016-09-27 | [vsky279](https://github.com/vsky279) | [vsky279](https://github.com/vsky279) | [somfy.c](../../../app/modules/somfy.c)|
+
+This module provides a simple interface to control Somfy blinds via an RF transmitter (433.42 MHz). It is based on [Nickduino Somfy Remote Arduino skecth](https://github.com/Nickduino/Somfy_Remote). 
+
+The hardware used is the standard 433 MHz RF transmitter. Unfortunately these chips are usually transmitting at he frequency of 433.92MHz so the crystal resonator should be replaced with the 433.42 MHz resonator though some reporting that it is working even with the original crystal.
+
+To understand details of the Somfy protocol please refer to [Somfy RTS protocol](https://pushstack.wordpress.com/somfy-rts-protocol/) and also discussion [here](https://forum.arduino.cc/index.php?topic=208346.0).
+
+The module is using hardware timer so it cannot be used at the same time with other NodeMCU modules using the hardware timer, i.e. `sigma delta`, `pcm`, `perf`, or `pwm` modules.
+
+## somfy.sendcommand()
+
+Builds an frame defined by Somfy protocol and sends it to the RF transmitter.
+
+#### Syntax
+`somfy.sendcommand(pin, remote_address, command, rolling_code, repeat_count, call_back)`
+
+#### Parameters
+- `pin` GPIO pin the RF transmitter is connected to.
+- `remote_address` address of the remote control. The device to be controlled is programmed with the addresses of the remote controls it should listen to.
+- `command` command to be transmitted. Can be one of `somfy.SOMFY_UP`, `somfy.SOMFY_DOWN`, `somfy.SOMFY_PROG`, `somfy.SOMFY_STOP`
+- `rolling_code` The rolling code is increased every time a button is pressed. The receiver only accepts command if the rolling code is above the last received code and is not to far ahead of the last received code. This window is in the order of a 100 big. The rolling code needs to be stored in the EEPROM (i.e. filesystem) to survive the ESP8266 reset.
+- `repeat_count` how many times the command is repeated
+- `call_back` a function to be called after the command is transmitted. Allows chaining commands to set the blinds to a defined position.
+
+My original remote is [TELIS 4 MODULIS RTS](https://www.somfy.co.uk/products/1810765/telis-4-modulis-rts). This remote is working with the additional info - additional 56 bits that follow data (shortening the Inter-frame gap). It seems that the scrumbling alhorithm has not been revealed yet.
+
+When I send the `somfy.DOWN` command, repeating the frame twice (which seems to be the standard for a short button press), i.e. `repeat_count` equal to 2, the blinds go only 1 step down. This corresponds to the movement of the wheel on the original remote. The down button on the original remote sends also `somfy.DOWN` command but the additional info is different and this makes the blinds go full down. Fortunately it seems that repeating the frame 16 times makes the blinds go fully down.
+
+#### Returns  
+nil
+
+#### Example
+To start with controlling your Somfy blinds you need to
+- Choose an arbitrary remote address (different from your existing remote) - `123` in this example
+- Choose a starting point for the rolling code. Any unsigned int works, 1 is a good start
+- Long-press the program button of your existing remote control until your blind goes up and down slightly
+- execute `somfy.sendcommand(4, 123, somfy.PROG, 1, 2)` - the blinds will react and your ESP8266 remote control is now registered
+- running `somfy.sendcommand(4, 123, somfy.DOWN, 2, 16)` - fully closes the blinds
+
+For more elaborated example please refer to [`somfy.lua`](../../../lua_examples/somfy.lua).
diff --git a/lua_examples/somfy.lua b/lua_examples/somfy.lua
new file mode 100644
index 00000000..f3baa3ed
--- /dev/null
+++ b/lua_examples/somfy.lua
@@ -0,0 +1,145 @@
+-- Somfy module example (beside somfy module requires also CJSON module)
+-- The rolling code number is stored in the file somfy.cfg. A cached write of the somfy.cfg file is implemented in order to reduce the number of write to the EEPROM memory. Together with the logic of the file module it should allow long lasting operation.
+
+config_file = "somfy."
+-- somfy.cfg looks like
+-- {"window1":{"rc":1,"address":123},"window2":{"rc":1,"address":124}}
+
+local tmr_cache = tmr.create()
+local tmr_delay = tmr.create()
+
+pin = 4
+gpio.mode(pin, gpio.OUTPUT, gpio.PULLUP)
+
+function deepcopy(orig)
+    local orig_type = type(orig)
+    local copy
+    if orig_type == 'table' then
+        copy = {}
+        for orig_key, orig_value in next, orig, nil do
+            copy[deepcopy(orig_key)] = deepcopy(orig_value)
+        end
+        setmetatable(copy, deepcopy(getmetatable(orig)))
+    else -- number, string, boolean, etc
+        copy = orig
+    end
+    return copy
+end
+
+function readconfig()
+    local cfg, ok, ln
+    if file.exists(config_file.."cfg") then
+        print("Reading config from "..config_file.."cfg")
+        file.open(config_file.."cfg", "r+")
+        ln = file.readline()
+        file.close()
+    else
+        if file.exists(config_file.."bak") then
+            print("Reading config from "..config_file.."bak")
+            file.open(config_file.."bak", "r+")
+            ln = file.readline()
+            file.close()
+        end
+    end
+    if not ln then ln = "{}" end
+    print("Configuration: "..ln)
+    config = cjson.decode(ln)
+    config_saved = deepcopy(config)
+end
+
+function writeconfighard()
+    print("Saving config")
+    file.remove(config_file.."bak")
+    file.rename(config_file.."cfg", config_file.."bak")
+    file.open(config_file.."cfg", "w+")
+    local ok, cfg = pcall(cjson.encode, config)
+    if ok then
+        file.writeline(cfg)
+    else
+        print("Config not saved!")
+    end
+    file.close()
+
+    config_saved = deepcopy(config)
+end
+
+function writeconfig()
+    tmr.stop(tmr_cache)
+    local savenow = false
+    local savelater = false
+
+--print("Config: "..cjson.encode(config))
+--print("Config saved: "..cjson.encode(config))
+ 
+    local count = 0
+    for _ in pairs(config_saved) do count = count + 1 end
+    if count == 0 then
+        config_saved = readconfig()
+    end
+    for remote,cfg in pairs(config_saved) do
+        savelater = savelater or not config[remote] or config[remote].rc > cfg.rc
+        savenow = savenow or not config[remote] or config[remote].rc > cfg.rc + 10
+    end
+    savelater = savelater and not savenow
+    if savenow then
+        print("Saving config now!")
+        writeconfighard()
+    end
+    if savelater then
+        print("Saving config later")
+        tmr.alarm(tmr_cache, 65000, tmr.ALARM_SINGLE, writeconfighard)
+    end
+end
+
+--======================================================================================================--
+function down(remote, cb, par)
+    par = par or {}
+    print("down: ".. remote)
+    config[remote].rc=config[remote].rc+1
+    somfy.sendcommand(pin, config[remote].address, somfy.DOWN, config[remote].rc, 16, function() wait(100, cb, par) end)
+    writeconfig()
+end
+
+function up(remote, cb, par)
+    par = par or {}
+    print("up: ".. remote)
+    config[remote].rc=config[remote].rc+1
+    somfy.sendcommand(pin, config[remote].address, somfy.UP, config[remote].rc, 16, function() wait(100, cb, par) end)
+    writeconfig()
+end
+
+function downStep(remote, cb, par)
+    par = par or {}
+    print("downStep: ".. remote)
+    config[remote].rc=config[remote].rc+1
+    somfy.sendcommand(pin, config[remote].address, somfy.DOWN, config[remote].rc, 2,  function() wait(300, cb, par) end)
+    writeconfig()
+end
+
+function upStep(remote, cb, par)
+    par = par or {}
+    print("upStep: ".. remote)
+    config[remote].rc=config[remote].rc+1
+    somfy.sendcommand(pin, config[remote].address, somfy.UP, config[remote].rc, 2, function() wait(300, cb, par) end)
+    writeconfig()
+end
+
+function wait(ms, cb, par)
+    par = par or {}
+    print("wait: ".. ms)
+    if cb then tmr.alarm(tmr_delay, ms, tmr.ALARM_SINGLE, function () cb(unpack(par)) end) end
+end
+
+
+--======================================================================================================--
+if not config then readconfig() end
+if #config == 0 then -- somfy.cfg does not exist
+    config = cjson.decode([[{"window1":{"rc":1,"address":123},"window2":{"rc":1,"address":124}}]])
+    config_saved = deepcopy(config)
+end
+down('window1', 
+    wait, {60000, 
+    up, {'window1', 
+    wait, {9000, 
+    downStep, {'window1', downStep, {'window1', downStep, {'window1', downStep, {'window1', downStep, {'window1', downStep, {'window1', downStep, {'window1'
+}}}}}}}}}})