Added the (possibly modified) Espressif SDK to the project to avoid problems with building. This may not be OK license wise, but who cares

2017-05-28 17:39:17 +02:00
parent c04433b7f5
commit 13564727d9
171 changed files with 23154 additions and 1 deletions
@@ -0,0 +1,126 @@
+#############################################################
+# Required variables for each makefile
+# Discard this section from all parent makefiles
+# Expected variables (with automatic defaults):
+#   CSRCS (all "C" files in the dir)
+#   SUBDIRS (all subdirs with a Makefile)
+#   GEN_LIBS - list of libs to be generated ()
+#   GEN_IMAGES - list of object file images to be generated ()
+#   GEN_BINS - list of binaries to be generated ()
+#   COMPONENTS_xxx - a list of libs/objs in the form
+#     subdir/lib to be extracted and rolled up into
+#     a generated lib/image xxx.a ()
+#
+TARGET = eagle
+#FLAVOR = release
+FLAVOR = debug
+
+#EXTRA_CCFLAGS += -u
+
+ifndef PDIR # {
+GEN_IMAGES= eagle.app.v6.out
+GEN_BINS= eagle.app.v6.bin
+SPECIAL_MKTARGETS=$(APP_MKTARGETS)
+SUBDIRS=    \
+	user    \
+	driver
+
+endif # } PDIR
+
+APPDIR = .
+LDDIR = ../ld
+
+CCFLAGS += -Os
+
+TARGET_LDFLAGS =		\
+	-nostdlib		\
+	-Wl,-EL \
+	--longcalls \
+	--text-section-literals
+
+ifeq ($(FLAVOR),debug)
+    TARGET_LDFLAGS += -g -O2
+endif
+
+ifeq ($(FLAVOR),release)
+    TARGET_LDFLAGS += -g -O0
+endif
+
+COMPONENTS_eagle.app.v6 = \
+	user/libuser.a  \
+	driver/libdriver.a
+
+LINKFLAGS_eagle.app.v6 = \
+	-L../lib        \
+	-nostdlib	\
+    -T$(LD_FILE)   \
+	-Wl,--no-check-sections	\
+    -u call_user_start	\
+	-Wl,-static						\
+	-Wl,--start-group					\
+	-lc					\
+	-lgcc					\
+	-lhal					\
+	-lphy	\
+	-lpp	\
+	-lnet80211	\
+	-llwip	\
+	-lwpa	\
+	-lcrypto	\
+	-lmain	\
+	-ljson	\
+	-lupgrade\
+	-lssl	\
+	-lpwm	\
+	-lsmartconfig \
+	$(DEP_LIBS_eagle.app.v6)					\
+	-Wl,--end-group
+
+DEPENDS_eagle.app.v6 = \
+                $(LD_FILE) \
+                $(LDDIR)/eagle.rom.addr.v6.ld
+
+#############################################################
+# Configuration i.e. compile options etc.
+# Target specific stuff (defines etc.) goes in here!
+# Generally values applying to a tree are captured in the
+#   makefile at its root level - these are then overridden
+#   for a subtree within the makefile rooted therein
+#
+
+#UNIVERSAL_TARGET_DEFINES =		\
+
+# Other potential configuration flags include:
+#	-DTXRX_TXBUF_DEBUG
+#	-DTXRX_RXBUF_DEBUG
+#	-DWLAN_CONFIG_CCX
+CONFIGURATION_DEFINES =	-DICACHE_FLASH
+
+DEFINES +=				\
+	$(UNIVERSAL_TARGET_DEFINES)	\
+	$(CONFIGURATION_DEFINES)
+
+DDEFINES +=				\
+	$(UNIVERSAL_TARGET_DEFINES)	\
+	$(CONFIGURATION_DEFINES)
+
+
+#############################################################
+# Recursion Magic - Don't touch this!!
+#
+# Each subtree potentially has an include directory
+#   corresponding to the common APIs applicable to modules
+#   rooted at that subtree. Accordingly, the INCLUDE PATH
+#   of a module can only contain the include directories up
+#   its parent path, and not its siblings
+#
+# Required for each makefile to inherit from the parent
+#
+
+INCLUDES := $(INCLUDES) -I $(PDIR)include
+PDIR := ../$(PDIR)
+sinclude $(PDIR)Makefile
+
+.PHONY: FORCE
+FORCE:
+
@@ -0,0 +1,44 @@
+
+#############################################################
+# Required variables for each makefile
+# Discard this section from all parent makefiles
+# Expected variables (with automatic defaults):
+#   CSRCS (all "C" files in the dir)
+#   SUBDIRS (all subdirs with a Makefile)
+#   GEN_LIBS - list of libs to be generated ()
+#   GEN_IMAGES - list of images to be generated ()
+#   COMPONENTS_xxx - a list of libs/objs in the form
+#     subdir/lib to be extracted and rolled up into
+#     a generated lib/image xxx.a ()
+#
+ifndef PDIR
+GEN_LIBS = libdriver.a
+endif
+
+
+#############################################################
+# Configuration i.e. compile options etc.
+# Target specific stuff (defines etc.) goes in here!
+# Generally values applying to a tree are captured in the
+#   makefile at its root level - these are then overridden
+#   for a subtree within the makefile rooted therein
+#
+#DEFINES += 
+
+#############################################################
+# Recursion Magic - Don't touch this!!
+#
+# Each subtree potentially has an include directory
+#   corresponding to the common APIs applicable to modules
+#   rooted at that subtree. Accordingly, the INCLUDE PATH
+#   of a module can only contain the include directories up
+#   its parent path, and not its siblings
+#
+# Required for each makefile to inherit from the parent
+#
+
+INCLUDES := $(INCLUDES) -I $(PDIR)include
+INCLUDES += -I ./
+PDIR := ../$(PDIR)
+sinclude $(PDIR)Makefile
+
@@ -0,0 +1,316 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: i2c_master.c
+ *
+ * Description: i2c master API
+ *
+ * Modification history:
+ *     2014/3/12, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "osapi.h"
+#include "gpio.h"
+
+#include "driver/i2c_master.h"
+
+LOCAL uint8 m_nLastSDA;
+LOCAL uint8 m_nLastSCL;
+
+/******************************************************************************
+ * FunctionName : i2c_master_setDC
+ * Description  : Internal used function -
+ *                    set i2c SDA and SCL bit value for half clk cycle
+ * Parameters   : uint8 SDA
+ *                uint8 SCL
+ * Returns      : NONE
+*******************************************************************************/
+LOCAL void ICACHE_FLASH_ATTR
+i2c_master_setDC(uint8 SDA, uint8 SCL)
+{
+    SDA	&= 0x01;
+    SCL	&= 0x01;
+    m_nLastSDA = SDA;
+    m_nLastSCL = SCL;
+
+    if ((0 == SDA) && (0 == SCL)) {
+        I2C_MASTER_SDA_LOW_SCL_LOW();
+    } else if ((0 == SDA) && (1 == SCL)) {
+        I2C_MASTER_SDA_LOW_SCL_HIGH();
+    } else if ((1 == SDA) && (0 == SCL)) {
+        I2C_MASTER_SDA_HIGH_SCL_LOW();
+    } else {
+        I2C_MASTER_SDA_HIGH_SCL_HIGH();
+    }
+}
+
+/******************************************************************************
+ * FunctionName : i2c_master_getDC
+ * Description  : Internal used function -
+ *                    get i2c SDA bit value
+ * Parameters   : NONE
+ * Returns      : uint8 - SDA bit value
+*******************************************************************************/
+LOCAL uint8 ICACHE_FLASH_ATTR
+i2c_master_getDC(void)
+{
+    uint8 sda_out;
+    sda_out = GPIO_INPUT_GET(GPIO_ID_PIN(I2C_MASTER_SDA_GPIO));
+    return sda_out;
+}
+
+/******************************************************************************
+ * FunctionName : i2c_master_init
+ * Description  : initilize I2C bus to enable i2c operations
+ * Parameters   : NONE
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+i2c_master_init(void)
+{
+    uint8 i;
+
+    i2c_master_setDC(1, 0);
+    i2c_master_wait(5);
+
+    // when SCL = 0, toggle SDA to clear up
+    i2c_master_setDC(0, 0) ;
+    i2c_master_wait(5);
+    i2c_master_setDC(1, 0) ;
+    i2c_master_wait(5);
+
+    // set data_cnt to max value
+    for (i = 0; i < 28; i++) {
+        i2c_master_setDC(1, 0);
+        i2c_master_wait(5);	// sda 1, scl 0
+        i2c_master_setDC(1, 1);
+        i2c_master_wait(5);	// sda 1, scl 1
+    }
+
+    // reset all
+    i2c_master_stop();
+    return;
+}
+
+/******************************************************************************
+ * FunctionName : i2c_master_gpio_init
+ * Description  : config SDA and SCL gpio to open-drain output mode,
+ *                mux and gpio num defined in i2c_master.h
+ * Parameters   : NONE
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+i2c_master_gpio_init(void)
+{
+    ETS_GPIO_INTR_DISABLE() ;
+//    ETS_INTR_LOCK();
+
+    PIN_FUNC_SELECT(I2C_MASTER_SDA_MUX, I2C_MASTER_SDA_FUNC);
+    PIN_FUNC_SELECT(I2C_MASTER_SCL_MUX, I2C_MASTER_SCL_FUNC);
+
+    GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_MASTER_SDA_GPIO)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_MASTER_SDA_GPIO))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //open drain;
+    GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << I2C_MASTER_SDA_GPIO));
+    GPIO_REG_WRITE(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_MASTER_SCL_GPIO)), GPIO_REG_READ(GPIO_PIN_ADDR(GPIO_ID_PIN(I2C_MASTER_SCL_GPIO))) | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_ENABLE)); //open drain;
+    GPIO_REG_WRITE(GPIO_ENABLE_ADDRESS, GPIO_REG_READ(GPIO_ENABLE_ADDRESS) | (1 << I2C_MASTER_SCL_GPIO));
+
+    I2C_MASTER_SDA_HIGH_SCL_HIGH();
+
+    ETS_GPIO_INTR_ENABLE() ;
+//    ETS_INTR_UNLOCK();
+
+    i2c_master_init();
+}
+
+/******************************************************************************
+ * FunctionName : i2c_master_start
+ * Description  : set i2c to send state
+ * Parameters   : NONE
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+i2c_master_start(void)
+{
+    i2c_master_setDC(1, m_nLastSCL);
+    i2c_master_wait(5);
+    i2c_master_setDC(1, 1);
+    i2c_master_wait(5);	// sda 1, scl 1
+    i2c_master_setDC(0, 1);
+    i2c_master_wait(5);	// sda 0, scl 1
+}
+
+/******************************************************************************
+ * FunctionName : i2c_master_stop
+ * Description  : set i2c to stop sending state
+ * Parameters   : NONE
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+i2c_master_stop(void)
+{
+    i2c_master_wait(5);
+
+    i2c_master_setDC(0, m_nLastSCL);
+    i2c_master_wait(5);	// sda 0
+    i2c_master_setDC(0, 1);
+    i2c_master_wait(5);	// sda 0, scl 1
+    i2c_master_setDC(1, 1);
+    i2c_master_wait(5);	// sda 1, scl 1
+}
+
+/******************************************************************************
+ * FunctionName : i2c_master_setAck
+ * Description  : set ack to i2c bus as level value
+ * Parameters   : uint8 level - 0 or 1
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+i2c_master_setAck(uint8 level)
+{
+    i2c_master_setDC(m_nLastSDA, 0);
+    i2c_master_wait(5);
+    i2c_master_setDC(level, 0);
+    i2c_master_wait(5);	// sda level, scl 0
+    i2c_master_setDC(level, 1);
+    i2c_master_wait(8);	// sda level, scl 1
+    i2c_master_setDC(level, 0);
+    i2c_master_wait(5);	// sda level, scl 0
+    i2c_master_setDC(1, 0);
+    i2c_master_wait(5);
+}
+
+/******************************************************************************
+ * FunctionName : i2c_master_getAck
+ * Description  : confirm if peer send ack
+ * Parameters   : NONE
+ * Returns      : uint8 - ack value, 0 or 1
+*******************************************************************************/
+uint8 ICACHE_FLASH_ATTR
+i2c_master_getAck(void)
+{
+    uint8 retVal;
+    i2c_master_setDC(m_nLastSDA, 0);
+    i2c_master_wait(5);
+    i2c_master_setDC(1, 0);
+    i2c_master_wait(5);
+    i2c_master_setDC(1, 1);
+    i2c_master_wait(5);
+
+    retVal = i2c_master_getDC();
+    i2c_master_wait(5);
+    i2c_master_setDC(1, 0);
+    i2c_master_wait(5);
+
+    return retVal;
+}
+
+/******************************************************************************
+* FunctionName : i2c_master_checkAck
+* Description  : get dev response
+* Parameters   : NONE
+* Returns      : true : get ack ; false : get nack
+*******************************************************************************/
+bool ICACHE_FLASH_ATTR
+i2c_master_checkAck(void)
+{
+    if(i2c_master_getAck()){
+        return FALSE;
+    }else{
+        return TRUE;
+    }
+}
+
+/******************************************************************************
+* FunctionName : i2c_master_send_ack
+* Description  : response ack
+* Parameters   : NONE
+* Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+i2c_master_send_ack(void)
+{
+    i2c_master_setAck(0x0);
+}
+/******************************************************************************
+* FunctionName : i2c_master_send_nack
+* Description  : response nack
+* Parameters   : NONE
+* Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+i2c_master_send_nack(void)
+{
+    i2c_master_setAck(0x1);
+}
+
+/******************************************************************************
+ * FunctionName : i2c_master_readByte
+ * Description  : read Byte from i2c bus
+ * Parameters   : NONE
+ * Returns      : uint8 - readed value
+*******************************************************************************/
+uint8 ICACHE_FLASH_ATTR
+i2c_master_readByte(void)
+{
+    uint8 retVal = 0;
+    uint8 k, i;
+
+    i2c_master_wait(5);
+    i2c_master_setDC(m_nLastSDA, 0);
+    i2c_master_wait(5);	// sda 1, scl 0
+
+    for (i = 0; i < 8; i++) {
+        i2c_master_wait(5);
+        i2c_master_setDC(1, 0);
+        i2c_master_wait(5);	// sda 1, scl 0
+        i2c_master_setDC(1, 1);
+        i2c_master_wait(5);	// sda 1, scl 1
+
+        k = i2c_master_getDC();
+        i2c_master_wait(5);
+
+        if (i == 7) {
+            i2c_master_wait(3);   ////
+        }
+
+        k <<= (7 - i);
+        retVal |= k;
+    }
+
+    i2c_master_setDC(1, 0);
+    i2c_master_wait(5);	// sda 1, scl 0
+
+    return retVal;
+}
+
+/******************************************************************************
+ * FunctionName : i2c_master_writeByte
+ * Description  : write wrdata value(one byte) into i2c
+ * Parameters   : uint8 wrdata - write value
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+i2c_master_writeByte(uint8 wrdata)
+{
+    uint8 dat;
+    sint8 i;
+
+    i2c_master_wait(5);
+
+    i2c_master_setDC(m_nLastSDA, 0);
+    i2c_master_wait(5);
+
+    for (i = 7; i >= 0; i--) {
+        dat = wrdata >> i;
+        i2c_master_setDC(dat, 0);
+        i2c_master_wait(5);
+        i2c_master_setDC(dat, 1);
+        i2c_master_wait(5);
+
+        if (i == 0) {
+            i2c_master_wait(3);   ////
+        }
+
+        i2c_master_setDC(dat, 0);
+        i2c_master_wait(5);
+    }
+}
@@ -0,0 +1,162 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: key.c
+ *
+ * Description: key driver, now can use different gpio and install different function
+ *
+ * Modification history:
+ *     2014/5/1, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "os_type.h"
+#include "osapi.h"
+#include "mem.h"
+#include "gpio.h"
+#include "user_interface.h"
+
+#include "driver/key.h"
+
+LOCAL void key_intr_handler(struct keys_param *keys);
+
+/******************************************************************************
+ * FunctionName : key_init_single
+ * Description  : init single key's gpio and register function
+ * Parameters   : uint8 gpio_id - which gpio to use
+ *                uint32 gpio_name - gpio mux name
+ *                uint32 gpio_func - gpio function
+ *                key_function long_press - long press function, needed to install
+ *                key_function short_press - short press function, needed to install
+ * Returns      : single_key_param - single key parameter, needed by key init
+*******************************************************************************/
+struct single_key_param *ICACHE_FLASH_ATTR
+key_init_single(uint8 gpio_id, uint32 gpio_name, uint8 gpio_func, key_function long_press, key_function short_press)
+{
+    struct single_key_param *single_key = (struct single_key_param *)os_zalloc(sizeof(struct single_key_param));
+
+    single_key->gpio_id = gpio_id;
+    single_key->gpio_name = gpio_name;
+    single_key->gpio_func = gpio_func;
+    single_key->long_press = long_press;
+    single_key->short_press = short_press;
+
+    return single_key;
+}
+
+/******************************************************************************
+ * FunctionName : key_init
+ * Description  : init keys
+ * Parameters   : key_param *keys - keys parameter, which inited by key_init_single
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+key_init(struct keys_param *keys)
+{
+    uint8 i;
+
+    ETS_GPIO_INTR_ATTACH(key_intr_handler, keys);
+
+    ETS_GPIO_INTR_DISABLE();
+
+    for (i = 0; i < keys->key_num; i++) {
+        keys->single_key[i]->key_level = 1;
+
+        PIN_FUNC_SELECT(keys->single_key[i]->gpio_name, keys->single_key[i]->gpio_func);
+
+        gpio_output_set(0, 0, 0, GPIO_ID_PIN(keys->single_key[i]->gpio_id));
+
+        gpio_register_set(GPIO_PIN_ADDR(keys->single_key[i]->gpio_id), GPIO_PIN_INT_TYPE_SET(GPIO_PIN_INTR_DISABLE)
+                          | GPIO_PIN_PAD_DRIVER_SET(GPIO_PAD_DRIVER_DISABLE)
+                          | GPIO_PIN_SOURCE_SET(GPIO_AS_PIN_SOURCE));
+
+        //clear gpio14 status
+        GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, BIT(keys->single_key[i]->gpio_id));
+
+        //enable interrupt
+        gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_NEGEDGE);
+    }
+
+    ETS_GPIO_INTR_ENABLE();
+}
+
+/******************************************************************************
+ * FunctionName : key_5s_cb
+ * Description  : long press 5s timer callback
+ * Parameters   : single_key_param *single_key - single key parameter
+ * Returns      : none
+*******************************************************************************/
+LOCAL void ICACHE_FLASH_ATTR
+key_5s_cb(struct single_key_param *single_key)
+{
+    os_timer_disarm(&single_key->key_5s);
+
+    // low, then restart
+    if (0 == GPIO_INPUT_GET(GPIO_ID_PIN(single_key->gpio_id))) {
+        if (single_key->long_press) {
+            single_key->long_press();
+        }
+    }
+}
+
+/******************************************************************************
+ * FunctionName : key_50ms_cb
+ * Description  : 50ms timer callback to check it's a real key push
+ * Parameters   : single_key_param *single_key - single key parameter
+ * Returns      : none
+*******************************************************************************/
+LOCAL void ICACHE_FLASH_ATTR
+key_50ms_cb(struct single_key_param *single_key)
+{
+    os_timer_disarm(&single_key->key_50ms);
+
+    // high, then key is up
+    if (1 == GPIO_INPUT_GET(GPIO_ID_PIN(single_key->gpio_id))) {
+        os_timer_disarm(&single_key->key_5s);
+        single_key->key_level = 1;
+        gpio_pin_intr_state_set(GPIO_ID_PIN(single_key->gpio_id), GPIO_PIN_INTR_NEGEDGE);
+
+        if (single_key->short_press) {
+            single_key->short_press();
+        }
+    } else {
+        gpio_pin_intr_state_set(GPIO_ID_PIN(single_key->gpio_id), GPIO_PIN_INTR_POSEDGE);
+    }
+}
+
+/******************************************************************************
+ * FunctionName : key_intr_handler
+ * Description  : key interrupt handler
+ * Parameters   : key_param *keys - keys parameter, which inited by key_init_single
+ * Returns      : none
+*******************************************************************************/
+LOCAL void
+key_intr_handler(struct keys_param *keys)
+{
+    uint8 i;
+    uint32 gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
+
+    for (i = 0; i < keys->key_num; i++) {
+        if (gpio_status & BIT(keys->single_key[i]->gpio_id)) {
+            //disable interrupt
+            gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_DISABLE);
+
+            //clear interrupt status
+            GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status & BIT(keys->single_key[i]->gpio_id));
+
+            if (keys->single_key[i]->key_level == 1) {
+                // 5s, restart & enter softap mode
+                os_timer_disarm(&keys->single_key[i]->key_5s);
+                os_timer_setfn(&keys->single_key[i]->key_5s, (os_timer_func_t *)key_5s_cb, keys->single_key[i]);
+                os_timer_arm(&keys->single_key[i]->key_5s, 5000, 0);
+                keys->single_key[i]->key_level = 0;
+                gpio_pin_intr_state_set(GPIO_ID_PIN(keys->single_key[i]->gpio_id), GPIO_PIN_INTR_POSEDGE);
+            } else {
+                // 50ms, check if this is a real key up
+                os_timer_disarm(&keys->single_key[i]->key_50ms);
+                os_timer_setfn(&keys->single_key[i]->key_50ms, (os_timer_func_t *)key_50ms_cb, keys->single_key[i]);
+                os_timer_arm(&keys->single_key[i]->key_50ms, 50, 0);
+            }
+        }
+    }
+}
+
@@ -0,0 +1,147 @@
+@echo off
+
+echo gen_misc.bat version 20150511
+echo .
+
+echo Please follow below steps(1-5) to generate specific bin(s):
+echo STEP 1: choose boot version(0=boot_v1.1, 1=boot_v1.2+, 2=none)
+set input=default
+set /p input=enter(0/1/2, default 2):
+
+if %input% equ 0 (
+    set boot=old
+) else (
+if %input% equ 1 (
+    set boot=new
+) else (
+    set boot=none
+)
+)
+
+echo boot mode: %boot%
+echo.
+
+echo STEP 2: choose bin generate(0=eagle.flash.bin+eagle.irom0text.bin, 1=user1.bin, 2=user2.bin)
+set input=default
+set /p input=enter (0/1/2, default 0):
+
+if %input% equ 1 (
+    if %boot% equ none (
+        set app=0
+        echo choose no boot before
+        echo generate bin: eagle.flash.bin+eagle.irom0text.bin
+    ) else (
+        set app=1
+        echo generate bin: user1.bin
+    )
+) else (
+if %input% equ 2 (
+    if %boot% equ none (
+        set app=0
+        echo choose no boot before
+        echo generate bin: eagle.flash.bin+eagle.irom0text.bin
+    ) else (
+        set app=2
+        echo generate bin: user2.bin
+    )
+) else (
+    if %boot% neq none (
+        set boot=none
+        echo ignore boot
+    )
+    set app=0
+    echo generate bin: eagle.flash.bin+eagle.irom0text.bin
+))
+
+echo.
+
+echo STEP 3: choose spi speed(0=20MHz, 1=26.7MHz, 2=40MHz, 3=80MHz)
+set input=default
+set /p input=enter (0/1/2/3, default 2):
+
+if %input% equ 0 (
+    set spi_speed=20
+) else (
+if %input% equ 1 (
+    set spi_speed=26.7
+) else (
+if %input% equ 3 (
+    set spi_speed=80
+) else (
+    set spi_speed=40
+)))
+
+echo spi speed: %spi_speed% MHz
+echo.
+
+echo STEP 4: choose spi mode(0=QIO, 1=QOUT, 2=DIO, 3=DOUT)
+set input=default
+set /p input=enter (0/1/2/3, default 0):
+
+if %input% equ 1 (
+    set spi_mode=QOUT
+) else (
+if %input% equ 2 (
+    set spi_mode=DIO
+) else (
+if %input% equ 3 (
+    set spi_mode=DOUT
+) else (
+    set spi_mode=QIO
+)))
+
+echo spi mode: %spi_mode%
+echo.
+
+echo STEP 5: choose flash size and map
+echo     0= 512KB( 256KB+ 256KB)
+echo     2=1024KB( 512KB+ 512KB)
+echo     3=2048KB( 512KB+ 512KB)
+echo     4=4096KB( 512KB+ 512KB)
+echo     5=2048KB(1024KB+1024KB)
+echo     6=4096KB(1024KB+1024KB)
+set input=default
+set /p input=enter (0/1/2/3/4/5/6, default 0):
+
+if %input% equ 2 (
+  set spi_size_map=2
+  echo spi size: 1024KB
+  echo spi ota map: 512KB + 512KB
+) else (
+  if %input% equ 3 (
+    set spi_size_map=3
+    echo spi size: 2048KB
+    echo spi ota map: 512KB + 512KB
+  ) else (
+    if %input% equ 4 (
+      set spi_size_map=4
+      echo spi size: 4096KB
+      echo spi ota map: 512KB + 512KB
+    ) else (
+      if %input% equ 5 (
+        set spi_size_map=5
+        echo spi size: 2048KB
+        echo spi ota map: 1024KB + 1024KB
+      ) else (
+        if %input% equ 6 (
+          set spi_size_map=6
+          echo spi size: 4096KB
+          echo spi ota map: 1024KB + 1024KB
+        ) else (
+          set spi_size_map=0
+          echo spi size: 512KB
+          echo spi ota map: 256KB + 256KB
+        )
+      )
+    )
+  )
+)
+
+touch user/user_main.c
+
+echo.
+echo start...
+echo.
+
+make BOOT=%boot% APP=%app% SPI_SPEED=%spi_speed% SPI_MODE=%spi_mode% SPI_SIZE=%spi_size_map%
+
@@ -0,0 +1,150 @@
+#!/bin/bash
+
+echo "gen_misc.sh version 20150511"
+echo ""
+
+echo "Please follow below steps(1-5) to generate specific bin(s):"
+echo "STEP 1: choose boot version(0=boot_v1.1, 1=boot_v1.2+, 2=none)"
+echo "enter(0/1/2, default 2):"
+read input
+
+if [ -z "$input" ]; then
+    boot=none
+elif [ $input == 0 ]; then
+	boot=old
+elif [ $input == 1 ]; then
+    boot=new
+else
+    boot=none
+fi
+
+echo "boot mode: $boot"
+echo ""
+
+echo "STEP 2: choose bin generate(0=eagle.flash.bin+eagle.irom0text.bin, 1=user1.bin, 2=user2.bin)"
+echo "enter (0/1/2, default 0):"
+read input
+
+if [ -z "$input" ]; then
+    if [ $boot != none ]; then
+    	boot=none
+	echo "ignore boot"
+    fi
+    app=0
+    echo "generate bin: eagle.flash.bin+eagle.irom0text.bin"
+elif [ $input == 1 ]; then
+    if [ $boot == none ]; then
+    	app=0
+	echo "choose no boot before"
+	echo "generate bin: eagle.flash.bin+eagle.irom0text.bin"
+    else
+	app=1
+        echo "generate bin: user1.bin"
+    fi
+elif [ $input == 2 ]; then
+    if [ $boot == none ]; then
+    	app=0
+	echo "choose no boot before"
+	echo "generate bin: eagle.flash.bin+eagle.irom0text.bin"
+    else
+    	app=2
+    	echo "generate bin: user2.bin"
+    fi
+else
+    if [ $boot != none ]; then
+    	boot=none
+	echo "ignore boot"
+    fi
+    app=0
+    echo "generate bin: eagle.flash.bin+eagle.irom0text.bin"
+fi
+
+echo ""
+
+echo "STEP 3: choose spi speed(0=20MHz, 1=26.7MHz, 2=40MHz, 3=80MHz)"
+echo "enter (0/1/2/3, default 2):"
+read input
+
+if [ -z "$input" ]; then
+    spi_speed=40
+elif [ $input == 0 ]; then
+    spi_speed=20
+elif [ $input == 1 ]; then
+    spi_speed=26.7
+elif [ $input == 3 ]; then
+    spi_speed=80
+else
+    spi_speed=40
+fi
+
+echo "spi speed: $spi_speed MHz"
+echo ""
+
+echo "STEP 4: choose spi mode(0=QIO, 1=QOUT, 2=DIO, 3=DOUT)"
+echo "enter (0/1/2/3, default 0):"
+read input
+
+if [ -z "$input" ]; then
+    spi_mode=QIO
+elif [ $input == 1 ]; then
+    spi_mode=QOUT
+elif [ $input == 2 ]; then
+    spi_mode=DIO
+elif [ $input == 3 ]; then
+    spi_mode=DOUT
+else
+    spi_mode=QIO
+fi
+
+echo "spi mode: $spi_mode"
+echo ""
+
+echo "STEP 5: choose spi size and map"
+echo "    0= 512KB( 256KB+ 256KB)"
+echo "    2=1024KB( 512KB+ 512KB)"
+echo "    3=2048KB( 512KB+ 512KB)"
+echo "    4=4096KB( 512KB+ 512KB)"
+echo "    5=2048KB(1024KB+1024KB)"
+echo "    6=4096KB(1024KB+1024KB)"
+echo "enter (0/2/3/4/5/6, default 0):"
+read input
+
+if [ -z "$input" ]; then
+    spi_size_map=0
+    echo "spi size: 512KB"
+    echo "spi ota map:  256KB + 256KB"
+elif [ $input == 2 ]; then
+    spi_size_map=2
+    echo "spi size: 1024KB"
+    echo "spi ota map:  512KB + 512KB"
+elif [ $input == 3 ]; then
+    spi_size_map=3
+    echo "spi size: 2048KB"
+    echo "spi ota map:  512KB + 512KB"
+elif [ $input == 4 ]; then
+    spi_size_map=4
+    echo "spi size: 4096KB"
+    echo "spi ota map:  512KB + 512KB"
+elif [ $input == 5 ]; then
+    spi_size_map=5
+    echo "spi size: 2048KB"
+    echo "spi ota map:  1024KB + 1024KB"
+elif [ $input == 6 ]; then
+    spi_size_map=6
+    echo "spi size: 4096KB"
+    echo "spi ota map:  1024KB + 1024KB"
+else
+    spi_size_map=0
+    echo "spi size: 512KB"
+    echo "spi ota map:  256KB + 256KB"
+fi
+
+echo ""
+
+touch user/user_main.c
+
+echo ""
+echo "start..."
+echo ""
+
+make COMPILE=gcc BOOT=$boot APP=$app SPI_SPEED=$spi_speed SPI_MODE=$spi_mode SPI_SIZE_MAP=$spi_size_map
@@ -0,0 +1,57 @@
+#ifndef __I2C_MASTER_H__
+#define __I2C_MASTER_H__
+
+#define I2C_MASTER_SDA_MUX PERIPHS_IO_MUX_GPIO2_U
+#define I2C_MASTER_SCL_MUX PERIPHS_IO_MUX_MTMS_U
+#define I2C_MASTER_SDA_GPIO 2
+#define I2C_MASTER_SCL_GPIO 14
+#define I2C_MASTER_SDA_FUNC FUNC_GPIO2
+#define I2C_MASTER_SCL_FUNC FUNC_GPIO14
+
+//#define I2C_MASTER_SDA_MUX PERIPHS_IO_MUX_GPIO2_U
+//#define I2C_MASTER_SCL_MUX PERIPHS_IO_MUX_GPIO0_U
+//#define I2C_MASTER_SDA_GPIO 2
+//#define I2C_MASTER_SCL_GPIO 0
+//#define I2C_MASTER_SDA_FUNC FUNC_GPIO2
+//#define I2C_MASTER_SCL_FUNC FUNC_GPIO0
+
+#if 0
+#define I2C_MASTER_GPIO_SET(pin)  \
+    gpio_output_set(1<<pin,0,1<<pin,0)
+
+#define I2C_MASTER_GPIO_CLR(pin) \
+    gpio_output_set(0,1<<pin,1<<pin,0)
+
+#define I2C_MASTER_GPIO_OUT(pin,val) \
+    if(val) I2C_MASTER_GPIO_SET(pin);\
+    else I2C_MASTER_GPIO_CLR(pin)
+#endif
+
+#define I2C_MASTER_SDA_HIGH_SCL_HIGH()  \
+    gpio_output_set(1<<I2C_MASTER_SDA_GPIO | 1<<I2C_MASTER_SCL_GPIO, 0, 1<<I2C_MASTER_SDA_GPIO | 1<<I2C_MASTER_SCL_GPIO, 0)
+
+#define I2C_MASTER_SDA_HIGH_SCL_LOW()  \
+    gpio_output_set(1<<I2C_MASTER_SDA_GPIO, 1<<I2C_MASTER_SCL_GPIO, 1<<I2C_MASTER_SDA_GPIO | 1<<I2C_MASTER_SCL_GPIO, 0)
+
+#define I2C_MASTER_SDA_LOW_SCL_HIGH()  \
+    gpio_output_set(1<<I2C_MASTER_SCL_GPIO, 1<<I2C_MASTER_SDA_GPIO, 1<<I2C_MASTER_SDA_GPIO | 1<<I2C_MASTER_SCL_GPIO, 0)
+
+#define I2C_MASTER_SDA_LOW_SCL_LOW()  \
+    gpio_output_set(0, 1<<I2C_MASTER_SDA_GPIO | 1<<I2C_MASTER_SCL_GPIO, 1<<I2C_MASTER_SDA_GPIO | 1<<I2C_MASTER_SCL_GPIO, 0)
+
+void i2c_master_gpio_init(void);
+void i2c_master_init(void);
+
+#define i2c_master_wait    os_delay_us
+void i2c_master_stop(void);
+void i2c_master_start(void);
+void i2c_master_setAck(uint8 level);
+uint8 i2c_master_getAck(void);
+uint8 i2c_master_readByte(void);
+void i2c_master_writeByte(uint8 wrdata);
+
+bool i2c_master_checkAck(void);
+void i2c_master_send_ack(void);
+void i2c_master_send_nack(void);
+
+#endif
@@ -0,0 +1,27 @@
+#ifndef __KEY_H__
+#define __KEY_H__
+
+#include "gpio.h"
+
+typedef void (* key_function)(void);
+
+struct single_key_param {
+    uint8 key_level;
+    uint8 gpio_id;
+    uint8 gpio_func;
+    uint32 gpio_name;
+    os_timer_t key_5s;
+    os_timer_t key_50ms;
+    key_function short_press;
+    key_function long_press;
+};
+
+struct keys_param {
+    uint8 key_num;
+    struct single_key_param **single_key;
+};
+
+struct single_key_param *key_init_single(uint8 gpio_id, uint32 gpio_name, uint8 gpio_func, key_function long_press, key_function short_press);
+void key_init(struct keys_param *key);
+
+#endif
@@ -0,0 +1,36 @@
+unsigned char default_certificate[] = {
+  0x30, 0x82, 0x01, 0x82, 0x30, 0x81, 0xec, 0x02, 0x09, 0x00, 0x88, 0xf2,
+  0x5f, 0x46, 0x12, 0x2e, 0x3d, 0x3a, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86,
+  0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x30, 0x1c, 0x31,
+  0x1a, 0x30, 0x18, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x11, 0x77, 0x77,
+  0x77, 0x2e, 0x65, 0x73, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x66, 0x2e,
+  0x63, 0x6f, 0x6d, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x34, 0x30, 0x36, 0x32,
+  0x34, 0x31, 0x30, 0x32, 0x32, 0x33, 0x33, 0x5a, 0x17, 0x0d, 0x32, 0x38,
+  0x30, 0x33, 0x30, 0x32, 0x31, 0x30, 0x32, 0x32, 0x33, 0x33, 0x5a, 0x30,
+  0x34, 0x31, 0x12, 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x09,
+  0x65, 0x73, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x66, 0x31, 0x1e, 0x30,
+  0x1c, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x15, 0x65, 0x73, 0x70, 0x72,
+  0x65, 0x73, 0x73, 0x69, 0x66, 0x20, 0x49, 0x6f, 0x54, 0x20, 0x70, 0x72,
+  0x6f, 0x6a, 0x65, 0x63, 0x74, 0x30, 0x5c, 0x30, 0x0d, 0x06, 0x09, 0x2a,
+  0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x4b,
+  0x00, 0x30, 0x48, 0x02, 0x41, 0x00, 0xb9, 0x83, 0x30, 0xca, 0xfb, 0xec,
+  0x11, 0x9e, 0x94, 0xb7, 0x89, 0xf2, 0x84, 0x2c, 0xda, 0xe1, 0x9a, 0x53,
+  0x3a, 0x1b, 0x6e, 0xc9, 0x85, 0x81, 0xf9, 0xa3, 0x41, 0xdb, 0xe2, 0x82,
+  0x3b, 0xfa, 0x80, 0x22, 0x3b, 0x81, 0x6d, 0x25, 0x73, 0x7e, 0xf6, 0x49,
+  0xcc, 0x69, 0x3c, 0x6c, 0xd8, 0x05, 0xfb, 0x92, 0x02, 0xcf, 0x19, 0x2a,
+  0x10, 0x7d, 0x69, 0x7a, 0xd8, 0x9d, 0xd3, 0xcf, 0x6c, 0xef, 0x02, 0x03,
+  0x01, 0x00, 0x01, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
+  0x0d, 0x01, 0x01, 0x05, 0x05, 0x00, 0x03, 0x81, 0x81, 0x00, 0x2d, 0x63,
+  0x58, 0x21, 0xe3, 0x8b, 0x37, 0x0d, 0x28, 0x68, 0x11, 0x0e, 0x4d, 0xdd,
+  0xf3, 0xea, 0xdb, 0xec, 0xd7, 0x09, 0x47, 0x2c, 0xa1, 0xd8, 0xd1, 0x71,
+  0x83, 0x11, 0xb4, 0x17, 0xbc, 0x83, 0xea, 0x5a, 0xd6, 0x73, 0x02, 0x25,
+  0x87, 0x01, 0x76, 0xfc, 0x59, 0x1a, 0xcf, 0xd9, 0x49, 0xc9, 0xf9, 0x1f,
+  0x5c, 0x3b, 0x24, 0x6a, 0x5c, 0xa5, 0xca, 0xe6, 0x5d, 0x34, 0x5b, 0x5f,
+  0xcf, 0x56, 0x9c, 0x71, 0xd2, 0x6b, 0xdd, 0x1f, 0x15, 0xae, 0x4d, 0xf1,
+  0xca, 0x35, 0xc8, 0xdd, 0x93, 0x1b, 0x58, 0x1e, 0x94, 0x08, 0xcf, 0xa0,
+  0x20, 0xb9, 0x75, 0xa5, 0x4c, 0x77, 0xf5, 0x7f, 0xed, 0xd5, 0xcd, 0x53,
+  0xaa, 0x87, 0xa6, 0x3c, 0xf5, 0x72, 0xd8, 0xd2, 0xb0, 0xf7, 0x11, 0xb0,
+  0x0e, 0xe9, 0x41, 0xd6, 0x8e, 0xd9, 0x07, 0xf8, 0xed, 0xf8, 0x67, 0x7f,
+  0x28, 0x18, 0xf0, 0x1b, 0x29, 0x11
+};
+unsigned int default_certificate_len = 390;
@@ -0,0 +1,30 @@
+unsigned char default_private_key[] = {
+  0x30, 0x82, 0x01, 0x3a, 0x02, 0x01, 0x00, 0x02, 0x41, 0x00, 0xb9, 0x83,
+  0x30, 0xca, 0xfb, 0xec, 0x11, 0x9e, 0x94, 0xb7, 0x89, 0xf2, 0x84, 0x2c,
+  0xda, 0xe1, 0x9a, 0x53, 0x3a, 0x1b, 0x6e, 0xc9, 0x85, 0x81, 0xf9, 0xa3,
+  0x41, 0xdb, 0xe2, 0x82, 0x3b, 0xfa, 0x80, 0x22, 0x3b, 0x81, 0x6d, 0x25,
+  0x73, 0x7e, 0xf6, 0x49, 0xcc, 0x69, 0x3c, 0x6c, 0xd8, 0x05, 0xfb, 0x92,
+  0x02, 0xcf, 0x19, 0x2a, 0x10, 0x7d, 0x69, 0x7a, 0xd8, 0x9d, 0xd3, 0xcf,
+  0x6c, 0xef, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x40, 0x1d, 0x13, 0x92,
+  0xf2, 0x3d, 0xca, 0x22, 0x78, 0xd8, 0x96, 0x6b, 0xe8, 0xb7, 0x0e, 0xd0,
+  0xbf, 0xcb, 0x90, 0x7f, 0xeb, 0x0c, 0xd2, 0x49, 0x3a, 0xb6, 0x06, 0x00,
+  0xac, 0x96, 0x34, 0x13, 0x72, 0x4b, 0x8c, 0xd2, 0xb9, 0x35, 0xf5, 0x64,
+  0x18, 0xb2, 0x47, 0x5b, 0x9f, 0xbb, 0xf2, 0x5b, 0x2f, 0x66, 0x78, 0x2d,
+  0x0a, 0x76, 0x44, 0xc5, 0x4f, 0xdb, 0x7d, 0x13, 0xcf, 0xa5, 0x08, 0xdc,
+  0x01, 0x02, 0x21, 0x00, 0xdf, 0x9a, 0x89, 0xd0, 0xef, 0x23, 0xcf, 0x12,
+  0xac, 0x8a, 0x63, 0x1a, 0x8c, 0xc0, 0x3f, 0xf4, 0x38, 0x52, 0x3c, 0x9f,
+  0x19, 0x0a, 0x37, 0xd2, 0xcb, 0x5d, 0xeb, 0xb6, 0x2a, 0x33, 0xb0, 0x91,
+  0x02, 0x21, 0x00, 0xd4, 0x63, 0xd9, 0x6a, 0x18, 0x5b, 0xe8, 0xa8, 0x57,
+  0x4d, 0xd1, 0x9a, 0xa8, 0xd7, 0xe1, 0x65, 0x75, 0xb3, 0xb9, 0x5c, 0x94,
+  0x14, 0xca, 0x98, 0x41, 0x47, 0x9c, 0x0a, 0x22, 0x38, 0x05, 0x7f, 0x02,
+  0x20, 0x6a, 0xce, 0xfd, 0xef, 0xe0, 0x9b, 0x61, 0x49, 0x91, 0x43, 0x95,
+  0x6d, 0x54, 0x38, 0x6d, 0x14, 0x32, 0x67, 0x0d, 0xf0, 0x0d, 0x5c, 0xf5,
+  0x27, 0x6a, 0xdf, 0x55, 0x3d, 0xb1, 0xd0, 0xf9, 0x11, 0x02, 0x21, 0x00,
+  0xba, 0x94, 0xa0, 0xf9, 0xb0, 0x3e, 0x85, 0x8b, 0xe5, 0x6e, 0x4a, 0x95,
+  0x88, 0x80, 0x65, 0xd5, 0x00, 0xea, 0x8b, 0x0b, 0x46, 0x57, 0x61, 0x87,
+  0x11, 0xc9, 0xfb, 0xcd, 0x77, 0x34, 0x29, 0xb7, 0x02, 0x20, 0x06, 0x8d,
+  0x41, 0x11, 0x47, 0x93, 0xcb, 0xad, 0xda, 0x5d, 0xe1, 0x9d, 0x49, 0x8d,
+  0xe0, 0xab, 0x48, 0xe6, 0x18, 0x28, 0x4a, 0x94, 0xae, 0xf9, 0xad, 0xc5,
+  0x5b, 0x0b, 0x15, 0xc6, 0x73, 0x17
+};
+unsigned int default_private_key_len = 318;
@@ -0,0 +1,64 @@
+#ifndef __USER_CONFIG_H__
+#define __USER_CONFIG_H__
+
+#define ESP_PLATFORM        1
+#define LEWEI_PLATFORM      0
+
+#define USE_OPTIMIZE_PRINTF
+
+#if ESP_PLATFORM
+#define PLUG_DEVICE             0
+#define LIGHT_DEVICE            1
+#define SENSOR_DEVICE			0
+
+#if SENSOR_DEVICE
+#define HUMITURE_SUB_DEVICE         1
+#define FLAMMABLE_GAS_SUB_DEVICE    0
+#endif
+
+//#define SERVER_SSL_ENABLE
+//#define CLIENT_SSL_ENABLE
+//#define UPGRADE_SSL_ENABLE
+
+#define USE_DNS
+
+#ifdef USE_DNS
+#define ESP_DOMAIN      "iot.espressif.cn"
+#endif
+
+//#define SOFTAP_ENCRYPT
+
+#ifdef SOFTAP_ENCRYPT
+#define PASSWORD	"v*%W>L<@i&Nxe!"
+#endif
+
+#if SENSOR_DEVICE
+#define SENSOR_DEEP_SLEEP
+
+#if HUMITURE_SUB_DEVICE
+#define SENSOR_DEEP_SLEEP_TIME    30000000
+#elif FLAMMABLE_GAS_SUB_DEVICE
+#define SENSOR_DEEP_SLEEP_TIME    60000000
+#endif
+#endif
+
+#if LIGHT_DEVICE
+#define USE_US_TIMER
+#endif
+
+#if PLUG_DEVICE || LIGHT_DEVICE
+#define BEACON_TIMEOUT  150000000
+#define BEACON_TIME     50000
+#endif
+
+#define AP_CACHE           1
+
+#if AP_CACHE
+#define AP_CACHE_NUMBER    5
+#endif
+
+#elif LEWEI_PLATFORM
+#endif
+
+#endif
+
@@ -0,0 +1,6 @@
+#ifndef __USER_DEVICEFIND_H__
+#define __USER_DEVICEFIND_H__
+
+void user_devicefind_init(void);
+
+#endif
@@ -0,0 +1,33 @@
+#ifndef __USER_DEVICE_H__
+#define __USER_DEVICE_H__
+
+/* NOTICE---this is for 512KB spi flash.
+ * you can change to other sector if you use other size spi flash. */
+#define ESP_PARAM_START_SEC		0x3D
+
+#define packet_size   (2 * 1024)
+
+#define token_size 41
+
+struct esp_platform_saved_param {
+    uint8 devkey[40];
+    uint8 token[40];
+    uint8 activeflag;
+    uint8 pad[3];
+};
+
+enum {
+    DEVICE_CONNECTING = 40,
+    DEVICE_ACTIVE_DONE,
+    DEVICE_ACTIVE_FAIL,
+    DEVICE_CONNECT_SERVER_FAIL
+};
+
+struct dhcp_client_info {
+	ip_addr_t ip_addr;
+	ip_addr_t netmask;
+	ip_addr_t gw;
+	uint8 flag;
+	uint8 pad[3];
+};
+#endif
@@ -0,0 +1,6 @@
+#ifndef __USER_DEVICEFIND_H__
+#define __USER_DEVICEFIND_H__
+
+void user_platform_timer_start(char* pbuffer, struct espconn *pespconn);
+
+#endif
@@ -0,0 +1,43 @@
+#ifndef __USER_IOT_VERSION_H__
+#define __USER_IOT_VERSION_H__
+
+#include "user_config.h"
+
+#define IOT_VERSION_MAJOR		1U
+#define IOT_VERSION_MINOR		0U
+#define IOT_VERSION_REVISION	5U
+
+#define VERSION_NUM   (IOT_VERSION_MAJOR * 1000 + IOT_VERSION_MINOR * 100 + IOT_VERSION_REVISION)
+
+//#define VERSION_TYPE      "b"
+#define VERSION_TYPE   	  "v"
+
+#if LIGHT_DEVICE
+#define device_type       45772
+#elif PLUG_DEVICE
+#define device_type       23701
+#elif SENSOR_DEVICE
+#define device_type       12335
+#endif
+
+
+#define ONLINE_UPGRADE    0
+#define LOCAL_UPGRADE     0
+#define ALL_UPGRADE       1
+#define NONE_UPGRADE      0
+
+#if	ONLINE_UPGRADE
+#define UPGRADE_FALG	"O"
+#elif  LOCAL_UPGRADE
+#define UPGRADE_FALG	"l"
+#elif  ALL_UPGRADE
+#define UPGRADE_FALG	"a"
+#elif NONE_UPGRADE
+#define UPGRADE_FALG	"n"
+#endif
+
+#define IOT_VERSION
+
+
+#endif
+
@@ -0,0 +1,17 @@
+#ifndef __USER_JSON_H__
+#define __USER_JSON_H__
+
+#include "json/jsonparse.h"
+#include "json/jsontree.h"
+
+#define jsonSize   2*1024
+
+void json_parse(struct jsontree_context *json, char *ptrJSONMessage);
+
+void json_ws_send(struct jsontree_value *tree, const char *path, char *pbuf);
+
+int json_putchar(int c);
+
+struct jsontree_value *find_json_path(struct jsontree_context *json, const char *path);
+
+#endif
@@ -0,0 +1,64 @@
+#ifndef __USER_LIGHT_H__
+#define __USER_LIGHT_H__
+/*pwm.h: function and macro definition of PWM API , driver level */
+/*user_light.h: user interface for light API, user level*/
+/*user_light_adj: API for color changing and lighting effects, user level*/
+
+
+#include "pwm.h"
+
+
+/* NOTICE !!! ---this is for 512KB spi flash.*/
+/* You can change to other sector if you use other size spi flash. */
+/* Refer to the documentation about OTA support and flash mapping*/
+#define PRIV_PARAM_START_SEC		0x3C
+#define PRIV_PARAM_SAVE     0
+
+
+
+/*Define the channel number of PWM*/
+/*In this demo, we can set 3 for 3 PWM channels: RED, GREEN, BLUE*/
+/*Or , we can choose 5 channels : RED,GREEN,BLUE,COLD-WHITE,WARM-WHITE*/
+#define PWM_CHANNEL	5  //  5:5channel ; 3:3channel
+
+#define LIGHT_RED       0
+#define LIGHT_GREEN     1
+#define LIGHT_BLUE      2
+#define LIGHT_COLD_WHITE      3
+#define LIGHT_WARM_WHITE      4
+
+
+/*Definition of GPIO PIN params, for GPIO initialization*/
+#define PWM_0_OUT_IO_MUX PERIPHS_IO_MUX_MTDI_U
+#define PWM_0_OUT_IO_NUM 12
+#define PWM_0_OUT_IO_FUNC  FUNC_GPIO12
+
+#define PWM_1_OUT_IO_MUX PERIPHS_IO_MUX_MTDO_U
+#define PWM_1_OUT_IO_NUM 15
+#define PWM_1_OUT_IO_FUNC  FUNC_GPIO15
+
+#define PWM_2_OUT_IO_MUX PERIPHS_IO_MUX_MTCK_U
+#define PWM_2_OUT_IO_NUM 13
+#define PWM_2_OUT_IO_FUNC  FUNC_GPIO13
+
+#define PWM_3_OUT_IO_MUX PERIPHS_IO_MUX_MTMS_U
+#define PWM_3_OUT_IO_NUM 14
+#define PWM_3_OUT_IO_FUNC  FUNC_GPIO14
+
+#define PWM_4_OUT_IO_MUX PERIPHS_IO_MUX_GPIO5_U
+#define PWM_4_OUT_IO_NUM 5
+#define PWM_4_OUT_IO_FUNC  FUNC_GPIO5
+
+struct light_saved_param {
+    uint32  pwm_period;
+    uint32  pwm_duty[PWM_CHANNEL];
+};
+
+void user_light_init(void);
+uint32 user_light_get_duty(uint8 channel);
+void user_light_set_duty(uint32 duty, uint8 channel);
+uint32 user_light_get_period(void);
+void user_light_set_period(uint32 period);
+
+#endif
+
@@ -0,0 +1,33 @@
+#ifndef __USER_LIGHT_ADJ_H__
+#define __USER_LIGHT_ADJ_H__
+/*pwm.h: function and macro definition of PWM API , driver level */
+/*user_light.h: user interface for light setting, user level*/
+/*user_light_adj: API for color changing and lighting effects, user level*/
+
+
+
+
+/*save RGB params to flash when calling light_set_aim*/
+#define SAVE_LIGHT_PARAM  0  //set to 0: do not save color params
+
+/*check current consumption and limit the total current for LED driver IC*/
+/*NOTE: YOU SHOULD REPLACE WIHT THE LIMIT CURRENT OF YOUR OWN APPLICATION*/
+#define LIGHT_CURRENT_LIMIT  0 //set to 0: do not limit total current
+#if LIGHT_CURRENT_LIMIT
+#define LIGHT_TOTAL_CURRENT_MAX  (450*1000) //450000/1000 MA AT MOST
+#define LIGHT_CURRENT_MARGIN  (80*1000) //80000/1000 MA CURRENT RAISES WHILE TEMPERATURE INCREASING
+#define LIGHT_CURRENT_MARGIN_L2  (110*1000) //110000/1000 MA 
+#define LIGHT_CURRENT_MARGIN_L3  (140*1000) //140000/1000 MA 
+#endif
+
+
+/*set target duty for PWM channels, change each channel duty gradually */
+void  light_set_aim(uint32 r,uint32 g,uint32 b,uint32 cw,uint32 ww,uint32 period);//'white' channel is not used in default demo
+void light_set_aim_r(uint32 r);
+void light_set_aim_g(uint32 g);
+void light_set_aim_b(uint32 b);
+void light_set_aim_cw(uint32 cw);
+void light_set_aim_ww(uint32 ww);
+
+#endif
+
@@ -0,0 +1,43 @@
+#ifndef __USER_ESPSWITCH_H__
+#define __USER_ESPSWITCH_H__
+
+#include "driver/key.h"
+
+/* NOTICE---this is for 512KB spi flash.
+ * you can change to other sector if you use other size spi flash. */
+#define PRIV_PARAM_START_SEC		0x3C
+
+#define PRIV_PARAM_SAVE     0
+
+#define PLUG_KEY_NUM            1
+
+#define PLUG_KEY_0_IO_MUX     PERIPHS_IO_MUX_MTCK_U
+#define PLUG_KEY_0_IO_NUM     13
+#define PLUG_KEY_0_IO_FUNC    FUNC_GPIO13
+
+#define PLUG_WIFI_LED_IO_MUX     PERIPHS_IO_MUX_GPIO0_U
+#define PLUG_WIFI_LED_IO_NUM     0
+#define PLUG_WIFI_LED_IO_FUNC    FUNC_GPIO0
+
+#define PLUG_LINK_LED_IO_MUX     PERIPHS_IO_MUX_MTDI_U
+#define PLUG_LINK_LED_IO_NUM     12
+#define PLUG_LINK_LED_IO_FUNC    FUNC_GPIO12
+
+#define PLUG_RELAY_LED_IO_MUX     PERIPHS_IO_MUX_MTDO_U
+#define PLUG_RELAY_LED_IO_NUM     15
+#define PLUG_RELAY_LED_IO_FUNC    FUNC_GPIO15
+
+#define PLUG_STATUS_OUTPUT(pin, on)     GPIO_OUTPUT_SET(pin, on)
+
+struct plug_saved_param {
+    uint8_t status;
+    uint8_t pad[3];
+};
+
+void user_plug_init(void);
+uint8 user_plug_get_status(void);
+void user_plug_set_status(bool status);
+
+
+#endif
+
@@ -0,0 +1,32 @@
+#ifndef __USER_SENSOR_H__
+#define __USER_SENSOR_H__
+
+#include "user_config.h"
+#include "driver/key.h"
+
+#define SENSOR_KEY_NUM    1
+
+#define SENSOR_KEY_IO_MUX     PERIPHS_IO_MUX_MTCK_U
+#define SENSOR_KEY_IO_NUM     13
+#define SENSOR_KEY_IO_FUNC    FUNC_GPIO13
+
+#define SENSOR_WIFI_LED_IO_MUX     PERIPHS_IO_MUX_GPIO0_U
+#define SENSOR_WIFI_LED_IO_NUM     0
+#define SENSOR_WIFI_LED_IO_FUNC    FUNC_GPIO0
+
+#define SENSOR_LINK_LED_IO_MUX     PERIPHS_IO_MUX_MTDI_U
+#define SENSOR_LINK_LED_IO_NUM     12
+#define SENSOR_LINK_LED_IO_FUNC    FUNC_GPIO12
+
+#define SENSOR_UNUSED_LED_IO_MUX     PERIPHS_IO_MUX_MTDO_U
+#define SENSOR_UNUSED_LED_IO_NUM     15
+#define SENSOR_UNUSED_LED_IO_FUNC    FUNC_GPIO15
+
+#if HUMITURE_SUB_DEVICE
+bool user_mvh3004_read_th(uint8 *data);
+void user_mvh3004_init(void);
+#endif
+
+void user_sensor_init(uint8 active);
+
+#endif
@@ -0,0 +1,45 @@
+#ifndef __USER_WEBSERVER_H__
+#define __USER_WEBSERVER_H__
+
+#define SERVER_PORT 80
+#define SERVER_SSL_PORT 443
+
+#define URLSize 10
+
+typedef enum Result_Resp {
+    RespFail = 0,
+    RespSuc,
+} Result_Resp;
+
+typedef enum ProtocolType {
+    GET = 0,
+    POST,
+} ProtocolType;
+
+typedef enum _ParmType {
+    SWITCH_STATUS = 0,
+    INFOMATION,
+    WIFI,
+    SCAN,
+	REBOOT,
+    DEEP_SLEEP,
+    LIGHT_STATUS,
+    CONNECT_STATUS,
+    USER_BIN
+} ParmType;
+
+typedef struct URL_Frame {
+    enum ProtocolType Type;
+    char pSelect[URLSize];
+    char pCommand[URLSize];
+    char pFilename[URLSize];
+} URL_Frame;
+
+typedef struct _rst_parm {
+    ParmType parmtype;
+    struct espconn *pespconn;
+} rst_parm;
+
+void user_webserver_init(uint32 port);
+
+#endif
@@ -0,0 +1,45 @@
+
+#############################################################
+# Required variables for each makefile
+# Discard this section from all parent makefiles
+# Expected variables (with automatic defaults):
+#   CSRCS (all "C" files in the dir)
+#   SUBDIRS (all subdirs with a Makefile)
+#   GEN_LIBS - list of libs to be generated ()
+#   GEN_IMAGES - list of images to be generated ()
+#   COMPONENTS_xxx - a list of libs/objs in the form
+#     subdir/lib to be extracted and rolled up into
+#     a generated lib/image xxx.a ()
+#
+ifndef PDIR
+GEN_LIBS = libuser.a
+endif
+
+
+#############################################################
+# Configuration i.e. compile options etc.
+# Target specific stuff (defines etc.) goes in here!
+# Generally values applying to a tree are captured in the
+#   makefile at its root level - these are then overridden
+#   for a subtree within the makefile rooted therein
+#
+#DEFINES += 
+
+#############################################################
+# Recursion Magic - Don't touch this!!
+#
+# Each subtree potentially has an include directory
+#   corresponding to the common APIs applicable to modules
+#   rooted at that subtree. Accordingly, the INCLUDE PATH
+#   of a module can only contain the include directories up
+#   its parent path, and not its siblings
+#
+# Required for each makefile to inherit from the parent
+#
+
+INCLUDES := $(INCLUDES) -I $(PDIR)include
+INCLUDES += -I ./
+INCLUDES += -I ../../include/ets
+PDIR := ../$(PDIR)
+sinclude $(PDIR)Makefile
+
@@ -0,0 +1,120 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: user_devicefind.c
+ *
+ * Description: Find your hardware's information while working any mode.
+ *
+ * Modification history:
+ *     2014/3/12, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "os_type.h"
+#include "osapi.h"
+#include "mem.h"
+#include "user_interface.h"
+
+#include "espconn.h"
+#include "user_json.h"
+#include "user_devicefind.h"
+
+const char *device_find_request = "Are You Espressif IOT Smart Device?";
+#if PLUG_DEVICE
+const char *device_find_response_ok = "I'm Plug.";
+#elif LIGHT_DEVICE
+const char *device_find_response_ok = "I'm Light.";
+#elif SENSOR_DEVICE
+#if HUMITURE_SUB_DEVICE
+const char *device_find_response_ok = "I'm Humiture.";
+#elif FLAMMABLE_GAS_SUB_DEVICE
+const char *device_find_response_ok = "I'm Flammable Gas.";
+#endif
+#endif
+
+/*---------------------------------------------------------------------------*/
+LOCAL struct espconn ptrespconn;
+
+/******************************************************************************
+ * FunctionName : user_devicefind_recv
+ * Description  : Processing the received data from the host
+ * Parameters   : arg -- Additional argument to pass to the callback function
+ *                pusrdata -- The received data (or NULL when the connection has been closed!)
+ *                length -- The length of received data
+ * Returns      : none
+*******************************************************************************/
+LOCAL void ICACHE_FLASH_ATTR
+user_devicefind_recv(void *arg, char *pusrdata, unsigned short length)
+{
+    char DeviceBuffer[40] = {0};
+    char Device_mac_buffer[60] = {0};
+    char hwaddr[6];
+    remot_info *premot = NULL;
+    struct ip_info ipconfig;
+
+    if (wifi_get_opmode() != STATION_MODE) {
+        wifi_get_ip_info(SOFTAP_IF, &ipconfig);
+        wifi_get_macaddr(SOFTAP_IF, hwaddr);
+
+        if (!ip_addr_netcmp((struct ip_addr *)ptrespconn.proto.udp->remote_ip, &ipconfig.ip, &ipconfig.netmask)) {
+            wifi_get_ip_info(STATION_IF, &ipconfig);
+            wifi_get_macaddr(STATION_IF, hwaddr);
+        }
+    } else {
+        wifi_get_ip_info(STATION_IF, &ipconfig);
+        wifi_get_macaddr(STATION_IF, hwaddr);
+    }
+
+    if (pusrdata == NULL) {
+        return;
+    }
+
+    if (length == os_strlen(device_find_request) &&
+            os_strncmp(pusrdata, device_find_request, os_strlen(device_find_request)) == 0) {
+        os_sprintf(DeviceBuffer, "%s" MACSTR " " IPSTR, device_find_response_ok,
+                   MAC2STR(hwaddr), IP2STR(&ipconfig.ip));
+
+        os_printf("%s\n", DeviceBuffer);
+        length = os_strlen(DeviceBuffer);
+        if (espconn_get_connection_info(&ptrespconn, &premot, 0) != ESPCONN_OK)
+        	return;
+        os_memcpy(ptrespconn.proto.udp->remote_ip, premot->remote_ip, 4);
+        ptrespconn.proto.udp->remote_port = premot->remote_port;
+        espconn_sent(&ptrespconn, DeviceBuffer, length);
+    } else if (length == (os_strlen(device_find_request) + 18)) {
+        os_sprintf(Device_mac_buffer, "%s " MACSTR , device_find_request, MAC2STR(hwaddr));
+        os_printf("%s", Device_mac_buffer);
+
+        if (os_strncmp(Device_mac_buffer, pusrdata, os_strlen(device_find_request) + 18) == 0) {
+            //os_printf("%s\n", Device_mac_buffer);
+            length = os_strlen(DeviceBuffer);
+            os_sprintf(DeviceBuffer, "%s" MACSTR " " IPSTR, device_find_response_ok,
+                       MAC2STR(hwaddr), IP2STR(&ipconfig.ip));
+
+            os_printf("%s\n", DeviceBuffer);
+            length = os_strlen(DeviceBuffer);
+			if (espconn_get_connection_info(&ptrespconn, &premot, 0) != ESPCONN_OK)
+				return;
+			os_memcpy(ptrespconn.proto.udp->remote_ip, premot->remote_ip, 4);
+			ptrespconn.proto.udp->remote_port = premot->remote_port;
+            espconn_sent(&ptrespconn, DeviceBuffer, length);
+        } else {
+            return;
+        }
+    }
+}
+
+/******************************************************************************
+ * FunctionName : user_devicefind_init
+ * Description  : the espconn struct parame init
+ * Parameters   : none
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_devicefind_init(void)
+{
+    ptrespconn.type = ESPCONN_UDP;
+    ptrespconn.proto.udp = (esp_udp *)os_zalloc(sizeof(esp_udp));
+    ptrespconn.proto.udp->local_port = 1025;
+    espconn_regist_recvcb(&ptrespconn, user_devicefind_recv);
+    espconn_create(&ptrespconn);
+}
@@ -0,0 +1,344 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: esp_platform_user_timer.c
+ *
+ * Description:
+ *
+ * Modification history:
+ *     2014/5/09, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "os_type.h"
+#include "mem.h"
+#include "osapi.h"
+#include "user_interface.h"
+
+#include "espconn.h"
+#include "user_esp_platform.h"
+
+#define ESP_DEBUG
+
+#ifdef ESP_DEBUG
+#define ESP_DBG os_printf
+#else
+#define ESP_DBG
+#endif
+
+LOCAL os_timer_t device_timer;
+uint32 min_wait_second;
+char timestamp_str[11];
+int timestamp = 0;
+char *timer_splits[20] = {NULL};
+
+struct esp_platform_wait_timer_param {
+    uint8 wait_time_param[11];
+    uint8 wait_action[15];
+    int wait_time_second;
+};
+
+struct wait_param {
+    uint8 action[20][15];
+    uint16 action_number;
+    uint16 count;
+    uint32 min_time_backup;
+};
+
+void esp_platform_timer_action(struct esp_platform_wait_timer_param   *timer_wait_param, uint16 count);
+
+/******************************************************************************
+ * FunctionName : split
+ * Description  : split string p1 according to sting p2 and save the splits
+ * Parameters   : p1 , p2 ,splits[]
+ * Returns      : the number of splits
+*******************************************************************************/
+uint16 ICACHE_FLASH_ATTR
+split(char *p1, char *p2, char *splits[])
+{
+    int i = 0;
+    int j = 0;
+
+    while (i != -1) {
+        int start = i;
+        int end = indexof(p1, p2, start);
+
+        if (end == -1) {
+            end = os_strlen(p1);
+        }
+
+        char *p = (char *) os_zalloc(100);
+        os_memcpy(p, p1 + start, end - start);
+        p[end - start] = '\0';
+        splits[j] = p;
+        j++;
+        i = end + 1;
+
+        if (i > os_strlen(p1)) {
+            break;
+        }
+    }
+
+    return j;
+}
+
+/******************************************************************************
+ * FunctionName : indexof
+ * Description  : calculate the offset of p2 relate to start of p1
+ * Parameters   : p1,p1,start
+ * Returns      : the offset of p2 relate to the start
+*******************************************************************************/
+int ICACHE_FLASH_ATTR
+indexof(char *p1, char *p2, int start)
+{
+    char *find = (char *)os_strstr(p1 + start, p2);
+
+    if (find != NULL) {
+        return (find - p1);
+    }
+
+    return -1;
+}
+
+/******************************************************************************
+ * FunctionName : esp_platform_find_min_time
+ * Description  : find the minimum wait second in timer list
+ * Parameters   : timer_wait_param -- param of timer action and wait time param
+ *                count -- The number of timers given by server
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+esp_platform_find_min_time(struct esp_platform_wait_timer_param *timer_wait_param , uint16 count)
+{
+    uint16 i = 0;
+    min_wait_second = 0xFFFFFFF;
+
+    for (i = 0; i < count ; i++) {
+        if (timer_wait_param[i].wait_time_second < min_wait_second && timer_wait_param[i].wait_time_second >= 0) {
+            min_wait_second = timer_wait_param[i].wait_time_second;
+        }
+    }
+}
+
+/******************************************************************************
+ * FunctionName : user_platform_timer_first_start
+ * Description  : calculate the wait time of each timer
+ * Parameters   : count -- The number of timers given by server
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_platform_timer_first_start(uint16 count)
+{
+    int i = 0;
+    struct esp_platform_wait_timer_param timer_wait_param[100] = {0};
+
+    ESP_DBG("current timestamp= %ds\n", timestamp);
+
+    timestamp = timestamp + min_wait_second;
+
+    for (i = 0 ; i < count ; i++) {
+        char *str = timer_splits[i];
+
+        if (indexof(str, "f", 0) == 0) {
+            char *fixed_wait[2];
+
+            ESP_DBG("timer is fixed mode\n");
+
+            split(str, "=", fixed_wait);
+            os_memcpy(timer_wait_param[i].wait_time_param, fixed_wait[0] + 1, os_strlen(fixed_wait[0]) - 1);
+            os_memcpy(timer_wait_param[i].wait_action, fixed_wait[1], os_strlen(fixed_wait[1]));
+            timer_wait_param[i].wait_time_second = atoi(timer_wait_param[i].wait_time_param) - timestamp;
+            os_free(fixed_wait[0]);
+            os_free(fixed_wait[1]);
+        }
+
+        else if (indexof(str, "l", 0) == 0) {
+            char *loop_wait[2];
+
+            ESP_DBG("timer is loop mode\n");
+
+            split(str, "=", loop_wait);
+            os_memcpy(timer_wait_param[i].wait_time_param, loop_wait[0] + 1, os_strlen(loop_wait[0]) - 1);
+            os_memcpy(timer_wait_param[i].wait_action, loop_wait[1], os_strlen(loop_wait[1]));
+            timer_wait_param[i].wait_time_second = atoi(timer_wait_param[i].wait_time_param) - (timestamp % atoi(timer_wait_param[i].wait_time_param));
+            os_free(loop_wait[0]);
+            os_free(loop_wait[1]);
+        } else if (indexof(str, "w", 0) == 0) {
+            char *week_wait[2];
+            int monday_wait_time = 0;
+
+            ESP_DBG("timer is weekend mode\n");
+
+            split(str, "=", week_wait);
+            os_memcpy(timer_wait_param[i].wait_time_param, week_wait[0] + 1, os_strlen(week_wait[0]) - 1);
+            os_memcpy(timer_wait_param[i].wait_action, week_wait[1], os_strlen(week_wait[1]));
+            monday_wait_time = (timestamp - 1388937600) % (7 * 24 * 3600);
+
+            ESP_DBG("monday_wait_time == %d", monday_wait_time);
+
+            if (atoi(timer_wait_param[i].wait_time_param) > monday_wait_time) {
+                timer_wait_param[i].wait_time_second = atoi(timer_wait_param[i].wait_time_param) - monday_wait_time;
+            } else {
+                timer_wait_param[i].wait_time_second = 7 * 24 * 3600 - monday_wait_time + atoi(timer_wait_param[i].wait_time_param);
+            }
+
+            os_free(week_wait[0]);
+            os_free(week_wait[1]);
+        }
+    }
+
+    esp_platform_find_min_time(timer_wait_param, count);
+    if(min_wait_second == 0) {
+    	return;
+    }
+
+    esp_platform_timer_action(timer_wait_param, count);
+}
+
+/******************************************************************************
+ * FunctionName : user_esp_platform_device_action
+ * Description  : Execute the actions of minimum wait time
+ * Parameters   : pwait_action -- point the list of actions which need execute
+ *
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_esp_platform_device_action(struct wait_param *pwait_action)
+{
+    uint8 i = 0;
+    uint16 count = pwait_action->count;
+    uint16 action_number = pwait_action->action_number;
+
+    ESP_DBG("there is %d action at the same time\n", pwait_action->action_number);
+
+#if PLUG_DEVICE
+    for (i = 0; i < action_number && pwait_action->action[i][0] != '0'; i++) {
+        ESP_DBG("%s\n",pwait_action->action[i]);
+
+        if (os_strcmp(pwait_action->action[i], "on_switch", 9) == 0) {
+            user_plug_set_status(0x01);
+        } else if (os_strcmp(pwait_action->action[i], "off_switch", 10) == 0) {
+            user_plug_set_status(0x00);
+        } else if (os_strcmp(pwait_action->action[i], "on_off_switch", 13) == 0) {
+            if (user_plug_get_status() == 0) {
+                user_plug_set_status(0x01);
+            } else {
+                user_plug_set_status(0x00);
+            }
+        } else {
+            return;
+        }
+    }
+    user_platform_timer_first_start(count);
+#endif
+}
+
+/******************************************************************************
+ * FunctionName : user_platform_timer_start
+ * Description  : Processing the message about timer from the server
+ * Parameters   : timer_wait_param -- The received data from the server
+ *                count -- the espconn used to connetion with the host
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_esp_platform_wait_time_overflow_check(struct wait_param *pwait_action)
+{
+    ESP_DBG("min_wait_second = %d", min_wait_second);
+
+    if (pwait_action->min_time_backup >= 3600) {
+        os_timer_disarm(&device_timer);
+        os_timer_setfn(&device_timer, (os_timer_func_t *)user_esp_platform_wait_time_overflow_check, pwait_action);
+        os_timer_arm(&device_timer, 3600000, 0);
+        ESP_DBG("min_wait_second is extended\n");
+    } else {
+        os_timer_disarm(&device_timer);
+        os_timer_setfn(&device_timer, (os_timer_func_t *)user_esp_platform_device_action, pwait_action);
+        os_timer_arm(&device_timer, pwait_action->min_time_backup * 1000, 0);
+        ESP_DBG("min_wait_second is = %dms\n", pwait_action->min_time_backup * 1000);
+    }
+
+    pwait_action->min_time_backup -= 3600;
+}
+
+/******************************************************************************
+ * FunctionName : user_platform_timer_start
+ * Description  : Processing the message about timer from the server
+ * Parameters   : timer_wait_param -- The received data from the server
+ *                count -- the espconn used to connetion with the host
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+esp_platform_timer_action(struct esp_platform_wait_timer_param *timer_wait_param, uint16 count)
+{
+    uint16 i = 0;
+    uint16 action_number;
+    struct wait_param pwait_action = {0};
+
+    pwait_action.count = count;
+    action_number = 0;
+
+    for (i = 0; i < count ; i++) {
+        if (timer_wait_param[i].wait_time_second == min_wait_second) {
+            os_memcpy(pwait_action.action[action_number], timer_wait_param[i].wait_action, os_strlen(timer_wait_param[i].wait_action));
+            ESP_DBG("*****%s*****\n", timer_wait_param[i].wait_action);
+            action_number++;
+        }
+    }
+
+    pwait_action.action_number = action_number;
+    pwait_action.min_time_backup = min_wait_second;
+    user_esp_platform_wait_time_overflow_check(&pwait_action);
+}
+
+/******************************************************************************
+ * FunctionName : user_platform_timer_start
+ * Description  : Processing the message about timer from the server
+ * Parameters   : pbuffer -- The received data from the server
+
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_platform_timer_start(char *pbuffer)
+{
+    int str_begin = 0;
+    int str_end = 0;
+    uint8 i = 0;
+    char *pstr_start = NULL;
+    char *pstr_end = NULL;
+    struct esp_platform_wait_timer_param timer_wait_param[20];
+    char *pstr = NULL;
+
+    min_wait_second  = 0;
+
+    if ((pstr = (char *)os_strstr(pbuffer, "\"timestamp\":")) != NULL) {
+        pstr_start = pstr + 13;
+        pstr_end = (char *)os_strstr(pstr_start, ",");
+
+        if (pstr != NULL) {
+            os_memcpy(timestamp_str, pstr_start, pstr_end - pstr_start);
+            timestamp = atoi(timestamp_str);
+        }
+    }
+
+    for (i = 0 ; i < 20 ; i++) {
+        if (timer_splits[i] != NULL) {
+            os_free(timer_splits[i]);
+            timer_splits[i] = NULL;
+        }
+    }
+
+    if ((pstr_start = (char *)os_strstr(pbuffer, "\"timers\": \"")) != NULL) {
+        str_begin = 11;
+        str_end = indexof(pstr_start, "\"", str_begin);
+
+        if (str_begin == str_end) {
+        	os_timer_disarm(&device_timer);
+            return;
+        }
+
+        char *split_buffer = (char *)os_zalloc(str_end - str_begin + 1);
+        os_memcpy(split_buffer, pstr_start + str_begin, str_end - str_begin);
+        uint16 count = split(split_buffer , ";" , timer_splits);
+        os_free(split_buffer);
+        user_platform_timer_first_start(count);
+    }
+}
@@ -0,0 +1,164 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: user_json.c
+ *
+ * Description: JSON format set up and parse.
+ *              Check your hardware transmation while use this data format.
+ *
+ * Modification history:
+ *     2014/5/09, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "osapi.h"
+#include "os_type.h"
+#include "mem.h"
+
+#include "user_json.h"
+
+LOCAL char *json_buf;
+LOCAL int pos;
+LOCAL int size;
+
+/******************************************************************************
+ * FunctionName : find_json_path
+ * Description  : find the JSON format tree's path
+ * Parameters   : json -- A pointer to a JSON set up
+ *                path -- A pointer to the JSON format tree's path
+ * Returns      : A pointer to the JSON format tree
+*******************************************************************************/
+struct jsontree_value *ICACHE_FLASH_ATTR
+find_json_path(struct jsontree_context *json, const char *path)
+{
+    struct jsontree_value *v;
+    const char *start;
+    const char *end;
+    int len;
+
+    v = json->values[0];
+    start = path;
+
+    do {
+        end = (const char *)os_strstr(start, "/");
+
+        if (end == start) {
+            break;
+        }
+
+        if (end != NULL) {
+            len = end - start;
+            end++;
+        } else {
+            len = os_strlen(start);
+        }
+
+        if (v->type != JSON_TYPE_OBJECT) {
+            v = NULL;
+        } else {
+            struct jsontree_object *o;
+            int i;
+
+            o = (struct jsontree_object *)v;
+            v = NULL;
+
+            for (i = 0; i < o->count; i++) {
+                if (os_strncmp(start, o->pairs[i].name, len) == 0) {
+                    v = o->pairs[i].value;
+                    json->index[json->depth] = i;
+                    json->depth++;
+                    json->values[json->depth] = v;
+                    json->index[json->depth] = 0;
+                    break;
+                }
+            }
+        }
+
+        start = end;
+    } while (end != NULL && *end != '\0' && v != NULL);
+
+    json->callback_state = 0;
+    return v;
+}
+
+/******************************************************************************
+ * FunctionName : json_putchar
+ * Description  : write the value to the JSON  format tree
+ * Parameters   : c -- the value which write the JSON format tree
+ * Returns      : result
+*******************************************************************************/
+int ICACHE_FLASH_ATTR
+json_putchar(int c)
+{
+    if (json_buf != NULL && pos <= size) {
+        json_buf[pos++] = c;
+        return c;
+    }
+
+    return 0;
+}
+
+/******************************************************************************
+ * FunctionName : json_ws_send
+ * Description  : set up the JSON format tree for string
+ * Parameters   : tree -- A pointer to the JSON format tree
+ *                path -- A pointer to the JSON format tree's path
+ *                pbuf -- A pointer for the data sent
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+json_ws_send(struct jsontree_value *tree, const char *path, char *pbuf)
+{
+    struct jsontree_context json;
+    /* maxsize = 128 bytes */
+    json_buf = (char *)os_malloc(jsonSize);
+
+    /* reset state and set max-size */
+    /* NOTE: packet will be truncated at 512 bytes */
+    pos = 0;
+    size = jsonSize;
+
+    json.values[0] = (struct jsontree_value *)tree;
+    jsontree_reset(&json);
+    find_json_path(&json, path);
+    json.path = json.depth;
+    json.putchar = json_putchar;
+
+    while (jsontree_print_next(&json) && json.path <= json.depth);
+
+    json_buf[pos] = 0;
+    os_memcpy(pbuf, json_buf, pos);
+    os_free(json_buf);
+}
+
+/******************************************************************************
+ * FunctionName : json_parse
+ * Description  : parse the data as a JSON format
+ * Parameters   : js_ctx -- A pointer to a JSON set up
+ *                ptrJSONMessage -- A pointer to the data
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+json_parse(struct jsontree_context *json, char *ptrJSONMessage)
+{
+    /* Set value */
+    struct jsontree_value *v;
+    struct jsontree_callback *c;
+    struct jsontree_callback *c_bak = NULL;
+
+    while ((v = jsontree_find_next(json, JSON_TYPE_CALLBACK)) != NULL) {
+        c = (struct jsontree_callback *)v;
+
+        if (c == c_bak) {
+            continue;
+        }
+
+        c_bak = c;
+
+        if (c->set != NULL) {
+            struct jsonparse_state js;
+
+            jsonparse_setup(&js, ptrJSONMessage, os_strlen(ptrJSONMessage));
+            c->set(json, &js);
+        }
+    }
+}
@@ -0,0 +1,141 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: user_light.c
+ *
+ * Description: light demo's function realization
+ *
+ * Modification history:
+ *     2014/5/1, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "osapi.h"
+#include "os_type.h"
+#include "mem.h"
+#include "user_interface.h"
+
+#include "user_light.h"
+#include "pwm.h"
+
+#if LIGHT_DEVICE
+
+struct light_saved_param light_param;
+
+/******************************************************************************
+ * FunctionName : user_light_get_duty
+ * Description  : get duty of each channel
+ * Parameters   : uint8 channel : LIGHT_RED/LIGHT_GREEN/LIGHT_BLUE
+ * Returns      : NONE
+*******************************************************************************/
+uint32 ICACHE_FLASH_ATTR
+user_light_get_duty(uint8 channel)
+{
+    return light_param.pwm_duty[channel];
+}
+
+/******************************************************************************
+ * FunctionName : user_light_set_duty
+ * Description  : set each channel's duty params
+ * Parameters   : uint8 duty    : 0 ~ PWM_DEPTH
+ *                uint8 channel : LIGHT_RED/LIGHT_GREEN/LIGHT_BLUE
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_light_set_duty(uint32 duty, uint8 channel)
+{
+    if (duty != light_param.pwm_duty[channel]) {
+        pwm_set_duty(duty, channel);
+
+        light_param.pwm_duty[channel] = pwm_get_duty(channel);
+    }
+}
+
+/******************************************************************************
+ * FunctionName : user_light_get_period
+ * Description  : get pwm period
+ * Parameters   : NONE
+ * Returns      : uint32 : pwm period
+*******************************************************************************/
+uint32 ICACHE_FLASH_ATTR
+user_light_get_period(void)
+{
+    return light_param.pwm_period;
+}
+
+/******************************************************************************
+ * FunctionName : user_light_set_duty
+ * Description  : set pwm frequency
+ * Parameters   : uint16 freq : 100hz typically
+ * Returns      : NONE
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_light_set_period(uint32 period)
+{
+    if (period != light_param.pwm_period) {
+        pwm_set_period(period);
+
+        light_param.pwm_period = pwm_get_period();
+    }
+}
+
+void ICACHE_FLASH_ATTR
+user_light_restart(void)
+{
+	spi_flash_erase_sector(PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE);
+	spi_flash_write((PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE) * SPI_FLASH_SEC_SIZE,
+	    		(uint32 *)&light_param, sizeof(struct light_saved_param));
+
+	pwm_start();
+}
+
+/******************************************************************************
+ * FunctionName : user_light_init
+ * Description  : light demo init, mainy init pwm
+ * Parameters   : none
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_light_init(void)
+{
+    spi_flash_read((PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE) * SPI_FLASH_SEC_SIZE,
+                               (uint32 *)&light_param, sizeof(struct light_saved_param));
+    if(light_param.pwm_period>10000 || light_param.pwm_period <1000){
+            light_param.pwm_period = 1000;
+    }
+
+	uint32 io_info[][3] = {   {PWM_0_OUT_IO_MUX,PWM_0_OUT_IO_FUNC,PWM_0_OUT_IO_NUM},
+		                      {PWM_1_OUT_IO_MUX,PWM_1_OUT_IO_FUNC,PWM_1_OUT_IO_NUM},
+		                      {PWM_2_OUT_IO_MUX,PWM_2_OUT_IO_FUNC,PWM_2_OUT_IO_NUM},
+		                      {PWM_3_OUT_IO_MUX,PWM_3_OUT_IO_FUNC,PWM_3_OUT_IO_NUM},
+		                      {PWM_4_OUT_IO_MUX,PWM_4_OUT_IO_FUNC,PWM_4_OUT_IO_NUM},
+		                      };
+	
+    uint32 pwm_duty_init[PWM_CHANNEL] = {0};
+	
+    /*PIN FUNCTION INIT FOR PWM OUTPUT*/
+    pwm_init(light_param.pwm_period,  pwm_duty_init ,PWM_CHANNEL,io_info);
+    
+    os_printf("LIGHT PARAM: R: %d \r\n",light_param.pwm_duty[LIGHT_RED]);
+    os_printf("LIGHT PARAM: G: %d \r\n",light_param.pwm_duty[LIGHT_GREEN]);
+    os_printf("LIGHT PARAM: B: %d \r\n",light_param.pwm_duty[LIGHT_BLUE]);
+    if(PWM_CHANNEL>LIGHT_COLD_WHITE){
+        os_printf("LIGHT PARAM: CW: %d \r\n",light_param.pwm_duty[LIGHT_COLD_WHITE]);
+        os_printf("LIGHT PARAM: WW: %d \r\n",light_param.pwm_duty[LIGHT_WARM_WHITE]);
+    }
+    os_printf("LIGHT PARAM: P: %d \r\n",light_param.pwm_period);
+
+    uint32 light_init_target[8]={0};
+    os_memcpy(light_init_target,light_param.pwm_duty,sizeof(light_param.pwm_duty));
+
+    light_set_aim(      
+		         light_init_target[LIGHT_RED],
+    	                light_init_target[LIGHT_GREEN],
+    	                light_init_target[LIGHT_BLUE], 
+    	                light_init_target[LIGHT_COLD_WHITE],
+    	                light_init_target[LIGHT_WARM_WHITE],
+    	                light_param.pwm_period);
+    set_pwm_debug_en(0);//disable debug print in pwm driver
+    os_printf("PWM version : %08x \r\n",get_pwm_version());
+}
+#endif
+
@@ -0,0 +1,334 @@
+
+#include "ets_sys.h"
+#include "osapi.h"
+#include "os_type.h"
+#include "mem.h"
+#include "user_interface.h"
+
+#include "user_light.h"
+#include "user_light_adj.h"
+#include "pwm.h"
+
+#define ABS_MINUS(x,y) (x<y?(y-x):(x-y))
+uint8 light_sleep_flg = 0;
+
+uint16  min_ms = 15;
+uint32  current_duty[PWM_CHANNEL] = {0};
+
+bool change_finish=true;
+os_timer_t timer_pwm_adj;
+
+static u32 duty_now[PWM_CHANNEL] = {0};
+
+
+
+
+//-----------------------------------Light para storage---------------------------
+#define LIGHT_EVT_QNUM (40) 
+
+static struct pwm_param LightEvtArr[LIGHT_EVT_QNUM];
+
+static u8 CurFreeLightEvtIdx = 0;
+static u8 TotalUsedLightEvtNum = 0;
+static u8  CurEvtIdxToBeUse = 0;
+
+static struct pwm_param *LightEvtMalloc(void)
+{
+    struct pwm_param *tmp = NULL;
+    TotalUsedLightEvtNum++;
+    if(TotalUsedLightEvtNum > LIGHT_EVT_QNUM ){
+        TotalUsedLightEvtNum--;
+    }
+    else{
+        tmp = &(LightEvtArr[CurFreeLightEvtIdx]);
+        CurFreeLightEvtIdx++;
+        if( CurFreeLightEvtIdx > (LIGHT_EVT_QNUM-1) )
+        CurFreeLightEvtIdx = 0;
+    }
+    os_printf("malloc:%u\n",TotalUsedLightEvtNum);
+    return tmp;
+}
+
+static void ICACHE_FLASH_ATTR LightEvtFree(void)
+{
+    TotalUsedLightEvtNum--;
+os_printf("free:%u\n",TotalUsedLightEvtNum);
+}
+//------------------------------------------------------------------------------------
+
+static void ICACHE_FLASH_ATTR light_pwm_smooth_adj_proc(void);
+
+
+void ICACHE_FLASH_ATTR
+	light_save_target_duty()
+{
+	extern struct light_saved_param light_param;
+
+	os_memcpy(light_param.pwm_duty,current_duty,sizeof(light_param.pwm_duty));
+	light_param.pwm_period =  pwm_get_period();
+
+#if SAVE_LIGHT_PARAM
+	spi_flash_erase_sector(PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE);
+	spi_flash_write((PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE) * SPI_FLASH_SEC_SIZE,
+	    		(uint32 *)&light_param, sizeof(struct light_saved_param));
+#endif
+
+}
+
+
+void ICACHE_FLASH_ATTR
+light_set_aim_r(uint32 r)
+{
+    current_duty[LIGHT_RED]=r;
+    light_pwm_smooth_adj_proc();
+}
+
+void ICACHE_FLASH_ATTR
+light_set_aim_g(uint32 g)
+{
+    current_duty[LIGHT_GREEN]=g;
+    light_pwm_smooth_adj_proc();
+}
+
+void ICACHE_FLASH_ATTR
+light_set_aim_b(uint32 b)
+{
+    current_duty[LIGHT_BLUE]=b;
+    light_pwm_smooth_adj_proc();
+}
+
+void ICACHE_FLASH_ATTR
+light_set_aim_cw(uint32 cw)
+{
+    current_duty[LIGHT_COLD_WHITE]=cw;
+    light_pwm_smooth_adj_proc();
+}
+
+void ICACHE_FLASH_ATTR
+light_set_aim_ww(uint32 ww)
+{
+    current_duty[LIGHT_WARM_WHITE]=ww;
+    light_pwm_smooth_adj_proc();
+}
+
+LOCAL bool ICACHE_FLASH_ATTR
+	check_pwm_current_duty_diff()
+{
+	int i;
+	
+	for(i=0;i<PWM_CHANNEL;i++){
+		if(pwm_get_duty(i) != current_duty[i]){
+			return true;
+		}
+	}
+	return false;
+
+}
+
+
+void light_dh_pwm_adj_proc(void *Targ)
+{
+    uint8 i;
+    for(i=0;i<PWM_CHANNEL;i++){	
+          duty_now[i] = (duty_now[i]*15 + current_duty[i])>>4;
+          if( ABS_MINUS(duty_now[i],current_duty[i])<20 )
+            duty_now[i] = current_duty[i];
+          user_light_set_duty(duty_now[i],i);
+    }
+    
+    //os_printf("duty:%u,%u,%u\r\n", pwm.duty[0],pwm.duty[1],pwm.duty[2] );
+    pwm_start();	
+
+    if(check_pwm_current_duty_diff()){
+        change_finish = 0;		
+        os_timer_disarm(&timer_pwm_adj);
+        os_timer_setfn(&timer_pwm_adj, (os_timer_func_t *)light_dh_pwm_adj_proc, NULL);
+        os_timer_arm(&timer_pwm_adj, min_ms, 0);	
+    }
+    else{
+	os_printf("finish\n");
+        change_finish = 1;	
+	 //light_save_target_duty();
+        os_timer_disarm(&timer_pwm_adj);
+	 light_pwm_smooth_adj_proc();
+    }
+
+}
+
+LOCAL bool ICACHE_FLASH_ATTR
+	check_pwm_duty_zero()
+{
+    int i;
+	for(i=0;i<PWM_CHANNEL;i++){
+        if(pwm_get_duty(i) != 0){
+            return false;
+     	}
+    }
+	return true;
+}
+
+
+static void ICACHE_FLASH_ATTR light_pwm_smooth_adj_proc(void)
+{
+    if( TotalUsedLightEvtNum>0 ){
+        user_light_set_period( LightEvtArr[CurEvtIdxToBeUse].period );
+
+        os_memcpy(current_duty,LightEvtArr[CurEvtIdxToBeUse].duty,sizeof(current_duty));
+        CurEvtIdxToBeUse++;
+        if(CurEvtIdxToBeUse > (LIGHT_EVT_QNUM-1) ){
+            CurEvtIdxToBeUse = 0;
+        }
+        LightEvtFree();
+ 
+        if(change_finish){
+            light_dh_pwm_adj_proc(NULL);
+        }
+    }
+
+    if(change_finish){
+           light_save_target_duty();
+	    if(check_pwm_duty_zero()){
+            if(light_sleep_flg==0){
+                os_printf("light sleep en\r\n");
+                wifi_set_sleep_type(LIGHT_SLEEP_T);
+                light_sleep_flg = 1;
+            }
+        }
+    }
+}
+
+
+
+#if LIGHT_CURRENT_LIMIT
+uint32 light_get_cur(uint32 duty , uint8 channel, uint32 period)
+{
+    uint32 duty_max_limit = (period*1000/45);
+    uint32 duty_mapped = duty*22727/duty_max_limit;
+    switch(channel){
+
+    case LIGHT_RED : 
+        if(duty_mapped>=0 && duty_mapped<23000){
+            return (duty_mapped*151000/22727);
+        }
+    
+        break;
+
+    case LIGHT_GREEN:
+        if(duty_mapped>=0 && duty_mapped<23000){
+            return (duty_mapped*82000/22727);
+        }
+        break;
+    
+    case LIGHT_BLUE:
+        if(duty_mapped>=0 && duty_mapped<23000){
+            return (duty_mapped*70000/22727);
+        }
+        break;
+    
+    case LIGHT_COLD_WHITE:
+    case LIGHT_WARM_WHITE:
+        if(duty_mapped>=0 && duty_mapped<23000){
+            return (duty_mapped*115000/22727);
+        }
+        break;
+		
+    default:
+       os_printf("CHANNEL ERROR IN GET_CUR\r\n");
+       break;
+
+
+
+    }
+
+}
+
+#endif
+
+
+
+void ICACHE_FLASH_ATTR
+light_set_aim(uint32 r,uint32 g,uint32 b,uint32 cw,uint32 ww,uint32 period)
+{
+    struct pwm_param *tmp = LightEvtMalloc();    
+    if(tmp != NULL){
+        tmp->period = (period<10000?period:10000);
+	uint32 duty_max_limit = (period*1000/45);
+		
+        tmp->duty[LIGHT_RED] = (r<duty_max_limit?r:duty_max_limit);
+        tmp->duty[LIGHT_GREEN] = (g<duty_max_limit?g:duty_max_limit);
+        tmp->duty[LIGHT_BLUE] = (b<duty_max_limit?b:duty_max_limit);
+        tmp->duty[LIGHT_COLD_WHITE] = (cw<duty_max_limit?cw:duty_max_limit);
+        tmp->duty[LIGHT_WARM_WHITE] = (ww<duty_max_limit?ww:duty_max_limit);//chg
+
+#if LIGHT_CURRENT_LIMIT
+        uint32 cur_r,cur_g,cur_b,cur_rgb;
+        
+        //if(cw>0 || ww>0){
+        cur_r = light_get_cur(tmp->duty[LIGHT_RED] , LIGHT_RED, tmp->period);
+		
+        cur_g =  light_get_cur(tmp->duty[LIGHT_GREEN] , LIGHT_GREEN, tmp->period);
+        cur_b =  light_get_cur(tmp->duty[LIGHT_BLUE] , LIGHT_BLUE, tmp->period);
+        cur_rgb = (cur_r+cur_g+cur_b);
+        //}
+        uint32 cur_cw = light_get_cur( tmp->duty[LIGHT_COLD_WHITE],LIGHT_COLD_WHITE, tmp->period);
+        uint32 cur_ww = light_get_cur( tmp->duty[LIGHT_WARM_WHITE],LIGHT_WARM_WHITE, tmp->period);
+	 uint32 cur_remain,cur_mar;
+	        cur_remain = (LIGHT_TOTAL_CURRENT_MAX - cur_rgb -LIGHT_CURRENT_MARGIN);
+		cur_mar = LIGHT_CURRENT_MARGIN;
+
+/*
+	 if((cur_cw < 50000) || (cur_ww < 50000)){
+	        cur_remain = (LIGHT_TOTAL_CURRENT_MAX - cur_rgb -LIGHT_CURRENT_MARGIN);
+		cur_mar = LIGHT_CURRENT_MARGIN;
+ 	}else if((cur_cw < 99000) || (cur_ww < 99000)){
+	        cur_remain = (LIGHT_TOTAL_CURRENT_MAX - cur_rgb -LIGHT_CURRENT_MARGIN_L2);
+		cur_mar = LIGHT_CURRENT_MARGIN_L2;
+	}else{
+	        cur_remain = (LIGHT_TOTAL_CURRENT_MAX - cur_rgb -LIGHT_CURRENT_MARGIN_L3);
+		cur_mar = LIGHT_CURRENT_MARGIN_L2;
+	}
+
+	*/
+	 
+	 /*
+	 if((LIGHT_TOTAL_CURRENT_MAX-cur_rgb)>120){
+	        cur_remain = (LIGHT_TOTAL_CURRENT_MAX - cur_rgb -LIGHT_CURRENT_MARGIN);
+		cur_mar = LIGHT_CURRENT_MARGIN;
+ 	}else if((LIGHT_TOTAL_CURRENT_MAX-cur_rgb)>100){
+	        cur_remain = (LIGHT_TOTAL_CURRENT_MAX - cur_rgb -LIGHT_CURRENT_MARGIN_L2);
+		cur_mar = LIGHT_CURRENT_MARGIN_L2;
+	}else{
+	        cur_remain = (LIGHT_TOTAL_CURRENT_MAX - cur_rgb -LIGHT_CURRENT_MARGIN_L3);
+		cur_mar = LIGHT_CURRENT_MARGIN_L2;
+	}
+	*/
+
+
+		
+        os_printf("cur_remain: %d \r\n",cur_remain);
+        while((cur_cw+cur_ww) > cur_remain){
+            tmp->duty[LIGHT_COLD_WHITE] =  tmp->duty[LIGHT_COLD_WHITE] * 9 / 10;
+            tmp->duty[LIGHT_WARM_WHITE] =  tmp->duty[LIGHT_WARM_WHITE] * 9 / 10;
+            cur_cw = light_get_cur( tmp->duty[LIGHT_COLD_WHITE],LIGHT_COLD_WHITE, tmp->period);
+            cur_ww = light_get_cur( tmp->duty[LIGHT_WARM_WHITE],LIGHT_WARM_WHITE, tmp->period);
+        }	    
+	os_printf("debug : %d %d %d %d %d\r\n",cur_r/1000,cur_g/1000,cur_b/1000,cur_cw/1000,cur_ww/1000);
+	
+	os_printf("debug:total current after adj : %d + %d mA \r\n",(cur_cw+cur_ww+cur_r+cur_g+cur_b)/1000,cur_mar/1000);
+#endif
+
+
+
+		
+	os_printf("prd:%u  r : %u  g: %u  b: %u  cw: %u  ww: %u \r\n",period,
+		         tmp->duty[0],tmp->duty[1],tmp->duty[2],tmp->duty[3],tmp->duty[4]);
+        light_pwm_smooth_adj_proc();
+    }
+    else{
+        os_printf("light para full\n");
+    }
+}
+
+
+
+
@@ -0,0 +1,59 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: user_main.c
+ *
+ * Description: entry file of user application
+ *
+ * Modification history:
+ *     2014/1/1, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "osapi.h"
+
+#include "user_interface.h"
+
+#include "user_devicefind.h"
+#include "user_webserver.h"
+
+#if ESP_PLATFORM
+#include "user_esp_platform.h"
+#endif
+
+void user_rf_pre_init(void)
+{
+}
+
+/******************************************************************************
+ * FunctionName : user_init
+ * Description  : entry of user application, init user function here
+ * Parameters   : none
+ * Returns      : none
+*******************************************************************************/
+void user_init(void)
+{
+    os_printf("SDK version:%s\n", system_get_sdk_version());
+
+#if ESP_PLATFORM
+    /*Initialization of the peripheral drivers*/
+    /*For light demo , it is user_light_init();*/
+    /* Also check whether assigned ip addr by the router.If so, connect to ESP-server  */
+    user_esp_platform_init();
+#endif
+    /*Establish a udp socket to receive local device detect info.*/
+    /*Listen to the port 1025, as well as udp broadcast.
+    /*If receive a string of device_find_request, it rely its IP address and MAC.*/
+    user_devicefind_init();
+
+    /*Establish a TCP server for http(with JSON) POST or GET command to communicate with the device.*/
+    /*You can find the command in "2B-SDK-Espressif IoT Demo.pdf" to see the details.*/
+    /*the JSON command for curl is like:*/
+    /*3 Channel mode: curl -X POST -H "Content-Type:application/json" -d "{\"period\":1000,\"rgb\":{\"red\":16000,\"green\":16000,\"blue\":16000}}" http://192.168.4.1/config?command=light      */
+    /*5 Channel mode: curl -X POST -H "Content-Type:application/json" -d "{\"period\":1000,\"rgb\":{\"red\":16000,\"green\":16000,\"blue\":16000,\"cwhite\":3000,\"wwhite\",3000}}" http://192.168.4.1/config?command=light      */
+#ifdef SERVER_SSL_ENABLE
+    user_webserver_init(SERVER_SSL_PORT);
+#else
+    user_webserver_init(SERVER_PORT);
+#endif
+}
+
@@ -0,0 +1,159 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: user_plug.c
+ *
+ * Description: plug demo's function realization
+ *
+ * Modification history:
+ *     2014/5/1, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "osapi.h"
+#include "os_type.h"
+#include "mem.h"
+#include "user_interface.h"
+
+#include "user_plug.h"
+
+#if PLUG_DEVICE
+
+LOCAL struct plug_saved_param plug_param;
+LOCAL struct keys_param keys;
+LOCAL struct single_key_param *single_key[PLUG_KEY_NUM];
+LOCAL os_timer_t link_led_timer;
+LOCAL uint8 link_led_level = 0;
+
+/******************************************************************************
+ * FunctionName : user_plug_get_status
+ * Description  : get plug's status, 0x00 or 0x01
+ * Parameters   : none
+ * Returns      : uint8 - plug's status
+*******************************************************************************/
+uint8 ICACHE_FLASH_ATTR
+user_plug_get_status(void)
+{
+    return plug_param.status;
+}
+
+/******************************************************************************
+ * FunctionName : user_plug_set_status
+ * Description  : set plug's status, 0x00 or 0x01
+ * Parameters   : uint8 - status
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_plug_set_status(bool status)
+{
+    if (status != plug_param.status) {
+        if (status > 1) {
+            os_printf("error status input!\n");
+            return;
+        }
+
+        plug_param.status = status;
+        PLUG_STATUS_OUTPUT(PLUG_RELAY_LED_IO_NUM, status);
+    }
+}
+
+/******************************************************************************
+ * FunctionName : user_plug_short_press
+ * Description  : key's short press function, needed to be installed
+ * Parameters   : none
+ * Returns      : none
+*******************************************************************************/
+LOCAL void ICACHE_FLASH_ATTR
+user_plug_short_press(void)
+{
+    user_plug_set_status((~plug_param.status) & 0x01);
+
+    spi_flash_erase_sector(PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE);
+    spi_flash_write((PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE) * SPI_FLASH_SEC_SIZE,
+        		(uint32 *)&plug_param, sizeof(struct plug_saved_param));
+}
+
+/******************************************************************************
+ * FunctionName : user_plug_long_press
+ * Description  : key's long press function, needed to be installed
+ * Parameters   : none
+ * Returns      : none
+*******************************************************************************/
+LOCAL void ICACHE_FLASH_ATTR
+user_plug_long_press(void)
+{
+	user_esp_platform_set_active(0);
+    system_restore();
+    system_restart();
+}
+
+LOCAL void ICACHE_FLASH_ATTR
+user_link_led_init(void)
+{
+    PIN_FUNC_SELECT(PLUG_LINK_LED_IO_MUX, PLUG_LINK_LED_IO_FUNC);
+}
+
+void ICACHE_FLASH_ATTR
+user_link_led_output(uint8 level)
+{
+    GPIO_OUTPUT_SET(GPIO_ID_PIN(PLUG_LINK_LED_IO_NUM), level);
+}
+
+LOCAL void ICACHE_FLASH_ATTR
+user_link_led_timer_cb(void)
+{
+    link_led_level = (~link_led_level) & 0x01;
+    GPIO_OUTPUT_SET(GPIO_ID_PIN(PLUG_LINK_LED_IO_NUM), link_led_level);
+}
+
+void ICACHE_FLASH_ATTR
+user_link_led_timer_init(void)
+{
+    os_timer_disarm(&link_led_timer);
+    os_timer_setfn(&link_led_timer, (os_timer_func_t *)user_link_led_timer_cb, NULL);
+    os_timer_arm(&link_led_timer, 50, 1);
+    link_led_level = 0;
+    GPIO_OUTPUT_SET(GPIO_ID_PIN(PLUG_LINK_LED_IO_NUM), link_led_level);
+}
+
+void ICACHE_FLASH_ATTR
+user_link_led_timer_done(void)
+{
+    os_timer_disarm(&link_led_timer);
+    GPIO_OUTPUT_SET(GPIO_ID_PIN(PLUG_LINK_LED_IO_NUM), 0);
+}
+
+/******************************************************************************
+ * FunctionName : user_plug_init
+ * Description  : init plug's key function and relay output
+ * Parameters   : none
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_plug_init(void)
+{
+    user_link_led_init();
+
+    wifi_status_led_install(PLUG_WIFI_LED_IO_NUM, PLUG_WIFI_LED_IO_MUX, PLUG_WIFI_LED_IO_FUNC);
+
+    single_key[0] = key_init_single(PLUG_KEY_0_IO_NUM, PLUG_KEY_0_IO_MUX, PLUG_KEY_0_IO_FUNC,
+                                    user_plug_long_press, user_plug_short_press);
+
+    keys.key_num = PLUG_KEY_NUM;
+    keys.single_key = single_key;
+
+    key_init(&keys);
+
+    spi_flash_read((PRIV_PARAM_START_SEC + PRIV_PARAM_SAVE) * SPI_FLASH_SEC_SIZE,
+        		(uint32 *)&plug_param, sizeof(struct plug_saved_param));
+
+    PIN_FUNC_SELECT(PLUG_RELAY_LED_IO_MUX, PLUG_RELAY_LED_IO_FUNC);
+
+    // no used SPI Flash
+    if (plug_param.status == 0xff) {
+        plug_param.status = 1;
+    }
+
+    PLUG_STATUS_OUTPUT(PLUG_RELAY_LED_IO_NUM, plug_param.status);
+}
+#endif
+
@@ -0,0 +1,230 @@
+/******************************************************************************
+ * Copyright 2013-2014 Espressif Systems (Wuxi)
+ *
+ * FileName: user_humiture.c
+ *
+ * Description: humiture demo's function realization
+ *
+ * Modification history:
+ *     2014/5/1, v1.0 create this file.
+*******************************************************************************/
+#include "ets_sys.h"
+#include "osapi.h"
+#include "os_type.h"
+#include "user_interface.h"
+
+#if SENSOR_DEVICE
+#include "user_sensor.h"
+
+LOCAL struct keys_param keys;
+LOCAL struct single_key_param *single_key[SENSOR_KEY_NUM];
+LOCAL os_timer_t sensor_sleep_timer;
+LOCAL os_timer_t link_led_timer;
+LOCAL uint8 link_led_level = 0;
+LOCAL uint32 link_start_time;
+
+#if HUMITURE_SUB_DEVICE
+#include "driver/i2c_master.h"
+
+#define MVH3004_Addr    0x88
+
+LOCAL uint8 humiture_data[4];
+
+/******************************************************************************
+ * FunctionName : user_mvh3004_burst_read
+ * Description  : burst read mvh3004's internal data
+ * Parameters   : uint8 addr - mvh3004's address
+ *                uint8 *pData - data point to put read data
+ *                uint16 len - read length
+ * Returns      : bool - true or false
+*******************************************************************************/
+LOCAL bool ICACHE_FLASH_ATTR
+user_mvh3004_burst_read(uint8 addr, uint8 *pData, uint16 len)
+{
+    uint8 ack;
+    uint16 i;
+
+    i2c_master_start();
+    i2c_master_writeByte(addr);
+    ack = i2c_master_getAck();
+
+    if (ack) {
+        os_printf("addr not ack when tx write cmd \n");
+        i2c_master_stop();
+        return false;
+    }
+
+    i2c_master_stop();
+    i2c_master_wait(40000);
+
+    i2c_master_start();
+    i2c_master_writeByte(addr + 1);
+    ack = i2c_master_getAck();
+
+    if (ack) {
+        os_printf("addr not ack when tx write cmd \n");
+        i2c_master_stop();
+        return false;
+    }
+
+    for (i = 0; i < len; i++) {
+        pData[i] = i2c_master_readByte();
+
+        i2c_master_setAck((i == (len - 1)) ? 1 : 0);
+    }
+
+    i2c_master_stop();
+
+    return true;
+}
+
+/******************************************************************************
+ * FunctionName : user_mvh3004_read_th
+ * Description  : read mvh3004's humiture data
+ * Parameters   : uint8 *data - where data to put
+ * Returns      : bool - ture or false
+*******************************************************************************/
+bool ICACHE_FLASH_ATTR
+user_mvh3004_read_th(uint8 *data)
+{
+    return user_mvh3004_burst_read(MVH3004_Addr, data, 4);
+}
+
+/******************************************************************************
+ * FunctionName : user_mvh3004_init
+ * Description  : init mvh3004, mainly i2c master gpio
+ * Parameters   : none
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_mvh3004_init(void)
+{
+    i2c_master_gpio_init();
+}
+
+uint8 *ICACHE_FLASH_ATTR
+user_mvh3004_get_poweron_th(void)
+{
+    return humiture_data;
+}
+#endif
+
+/******************************************************************************
+ * FunctionName : user_humiture_long_press
+ * Description  : humiture key's function, needed to be installed
+ * Parameters   : none
+ * Returns      : none
+*******************************************************************************/
+LOCAL void ICACHE_FLASH_ATTR
+user_sensor_long_press(void)
+{
+    user_esp_platform_set_active(0);
+    system_restore();
+    system_restart();
+}
+
+LOCAL void ICACHE_FLASH_ATTR
+user_link_led_init(void)
+{
+    PIN_FUNC_SELECT(SENSOR_LINK_LED_IO_MUX, SENSOR_LINK_LED_IO_FUNC);
+    PIN_FUNC_SELECT(SENSOR_UNUSED_LED_IO_MUX, SENSOR_UNUSED_LED_IO_FUNC);
+    GPIO_OUTPUT_SET(GPIO_ID_PIN(SENSOR_UNUSED_LED_IO_NUM), 0);
+}
+
+void ICACHE_FLASH_ATTR
+user_link_led_output(uint8 level)
+{
+    GPIO_OUTPUT_SET(GPIO_ID_PIN(SENSOR_LINK_LED_IO_NUM), level);
+}
+
+LOCAL void ICACHE_FLASH_ATTR
+user_link_led_timer_cb(void)
+{
+    link_led_level = (~link_led_level) & 0x01;
+    GPIO_OUTPUT_SET(GPIO_ID_PIN(SENSOR_LINK_LED_IO_NUM), link_led_level);
+}
+
+void ICACHE_FLASH_ATTR
+user_link_led_timer_init(void)
+{
+    link_start_time = system_get_time();
+
+    os_timer_disarm(&link_led_timer);
+    os_timer_setfn(&link_led_timer, (os_timer_func_t *)user_link_led_timer_cb, NULL);
+    os_timer_arm(&link_led_timer, 50, 1);
+    link_led_level = 0;
+    GPIO_OUTPUT_SET(GPIO_ID_PIN(SENSOR_LINK_LED_IO_NUM), link_led_level);
+}
+
+void ICACHE_FLASH_ATTR
+user_link_led_timer_done(void)
+{
+    os_timer_disarm(&link_led_timer);
+    GPIO_OUTPUT_SET(GPIO_ID_PIN(SENSOR_LINK_LED_IO_NUM), 0);
+}
+
+void ICACHE_FLASH_ATTR
+user_sensor_deep_sleep_enter(void)
+{
+    system_deep_sleep(SENSOR_DEEP_SLEEP_TIME > link_start_time \
+    ? SENSOR_DEEP_SLEEP_TIME - link_start_time : 30000000);
+}
+
+void ICACHE_FLASH_ATTR
+user_sensor_deep_sleep_disable(void)
+{
+    os_timer_disarm(&sensor_sleep_timer);
+}
+
+void ICACHE_FLASH_ATTR
+user_sensor_deep_sleep_init(uint32 time)
+{
+    os_timer_disarm(&sensor_sleep_timer);
+    os_timer_setfn(&sensor_sleep_timer, (os_timer_func_t *)user_sensor_deep_sleep_enter, NULL);
+    os_timer_arm(&sensor_sleep_timer, time, 0);
+}
+
+/******************************************************************************
+ * FunctionName : user_humiture_init
+ * Description  : init humiture function, include key and mvh3004
+ * Parameters   : none
+ * Returns      : none
+*******************************************************************************/
+void ICACHE_FLASH_ATTR
+user_sensor_init(uint8 active)
+{
+    user_link_led_init();
+
+    wifi_status_led_install(SENSOR_WIFI_LED_IO_NUM, SENSOR_WIFI_LED_IO_MUX, SENSOR_WIFI_LED_IO_FUNC);
+
+    if (wifi_get_opmode() != SOFTAP_MODE) {
+        single_key[0] = key_init_single(SENSOR_KEY_IO_NUM, SENSOR_KEY_IO_MUX, SENSOR_KEY_IO_FUNC,
+                                        user_sensor_long_press, NULL);
+
+        keys.key_num = SENSOR_KEY_NUM;
+        keys.single_key = single_key;
+
+        key_init(&keys);
+
+        if (GPIO_INPUT_GET(GPIO_ID_PIN(SENSOR_KEY_IO_NUM)) == 0) {
+            user_sensor_long_press();
+        }
+    }
+
+#if HUMITURE_SUB_DEVICE
+    user_mvh3004_init();
+    user_mvh3004_read_th(humiture_data);
+#endif
+
+#ifdef SENSOR_DEEP_SLEEP
+    if (wifi_get_opmode() != STATIONAP_MODE) {
+        if (active == 1) {
+            user_sensor_deep_sleep_init(SENSOR_DEEP_SLEEP_TIME / 1000 );
+        } else {
+            user_sensor_deep_sleep_init(SENSOR_DEEP_SLEEP_TIME / 1000 / 3 * 2);
+        }
+    }
+#endif
+}
+#endif
+