Commit 4911d2db authored by Arnim Läuger's avatar Arnim Läuger
Browse files

Merge pull request #1336 from nodemcu/dev

1.5.1 master drop
parents c8037568 2e109686
#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
#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
#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
#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
#############################################################
# 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
/******************************************************************************
* 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);
}
/******************************************************************************
* Copyright 2013-2014 Espressif Systems (Wuxi)
*
* FileName: user_esp_platform.c
*
* Description: The client mode configration.
* Check your hardware connection with the host while use this mode.
*
* 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"
#include "user_iot_version.h"
#include "upgrade.h"
#if ESP_PLATFORM
#define ESP_DEBUG
#ifdef ESP_DEBUG
#define ESP_DBG os_printf
#else
#define ESP_DBG
#endif
#define ACTIVE_FRAME "{\"nonce\": %d,\"path\": \"/v1/device/activate/\", \"method\": \"POST\", \"body\": {\"encrypt_method\": \"PLAIN\", \"token\": \"%s\", \"bssid\": \""MACSTR"\",\"rom_version\":\"%s\"}, \"meta\": {\"Authorization\": \"token %s\"}}\n"
#if PLUG_DEVICE
#include "user_plug.h"
#define RESPONSE_FRAME "{\"status\": 200, \"datapoint\": {\"x\": %d}, \"nonce\": %d, \"deliver_to_device\": true}\n"
#define FIRST_FRAME "{\"nonce\": %d, \"path\": \"/v1/device/identify\", \"method\": \"GET\",\"meta\": {\"Authorization\": \"token %s\"}}\n"
#elif LIGHT_DEVICE
#include "user_light.h"
#define RESPONSE_FRAME "{\"status\": 200,\"nonce\": %d, \"datapoint\": {\"x\": %d,\"y\": %d,\"z\": %d,\"k\": %d,\"l\": %d},\"deliver_to_device\":true}\n"
#define FIRST_FRAME "{\"nonce\": %d, \"path\": \"/v1/device/identify\", \"method\": \"GET\",\"meta\": {\"Authorization\": \"token %s\"}}\n"
#elif SENSOR_DEVICE
#include "user_sensor.h"
#if HUMITURE_SUB_DEVICE
#define UPLOAD_FRAME "{\"nonce\": %d, \"path\": \"/v1/datastreams/tem_hum/datapoint/\", \"method\": \"POST\", \
\"body\": {\"datapoint\": {\"x\": %s%d.%02d,\"y\": %d.%02d}}, \"meta\": {\"Authorization\": \"token %s\"}}\n"
#elif FLAMMABLE_GAS_SUB_DEVICE
#define UPLOAD_FRAME "{\"nonce\": %d, \"path\": \"/v1/datastreams/flammable_gas/datapoint/\", \"method\": \"POST\", \
\"body\": {\"datapoint\": {\"x\": %d.%03d}}, \"meta\": {\"Authorization\": \"token %s\"}}\n"
#endif
LOCAL uint32 count = 0;
#endif
#define UPGRADE_FRAME "{\"path\": \"/v1/messages/\", \"method\": \"POST\", \"meta\": {\"Authorization\": \"token %s\"},\
\"get\":{\"action\":\"%s\"},\"body\":{\"pre_rom_version\":\"%s\",\"rom_version\":\"%s\"}}\n"
#if PLUG_DEVICE || LIGHT_DEVICE
#define BEACON_FRAME "{\"path\": \"/v1/ping/\", \"method\": \"POST\",\"meta\": {\"Authorization\": \"token %s\"}}\n"
#define RPC_RESPONSE_FRAME "{\"status\": 200, \"nonce\": %d, \"deliver_to_device\": true}\n"
#define TIMER_FRAME "{\"body\": {}, \"get\":{\"is_humanize_format_simple\":\"true\"},\"meta\": {\"Authorization\": \"Token %s\"},\"path\": \"/v1/device/timers/\",\"post\":{},\"method\": \"GET\"}\n"
#define pheadbuffer "Connection: keep-alive\r\n\
Cache-Control: no-cache\r\n\
User-Agent: Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.101 Safari/537.36 \r\n\
Accept: */*\r\n\
Authorization: token %s\r\n\
Accept-Encoding: gzip,deflate,sdch\r\n\
Accept-Language: zh-CN,zh;q=0.8\r\n\r\n"
LOCAL uint8 ping_status;
LOCAL os_timer_t beacon_timer;
#endif
#ifdef USE_DNS
ip_addr_t esp_server_ip;
#endif
LOCAL struct espconn user_conn;
LOCAL struct _esp_tcp user_tcp;
LOCAL os_timer_t client_timer;
struct esp_platform_saved_param esp_param;
LOCAL uint8 device_status;
LOCAL uint8 device_recon_count = 0;
LOCAL uint32 active_nonce = 0;
LOCAL uint8 iot_version[20] = {0};
struct rst_info rtc_info;
void user_esp_platform_check_ip(uint8 reset_flag);
/******************************************************************************
* FunctionName : user_esp_platform_get_token
* Description : get the espressif's device token
* Parameters : token -- the parame point which write the flash
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_get_token(uint8_t *token)
{
if (token == NULL) {
return;
}
os_memcpy(token, esp_param.token, sizeof(esp_param.token));
}
/******************************************************************************
* FunctionName : user_esp_platform_set_token
* Description : save the token for the espressif's device
* Parameters : token -- the parame point which write the flash
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_set_token(uint8_t *token)
{
if (token == NULL) {
return;
}
esp_param.activeflag = 0;
os_memcpy(esp_param.token, token, os_strlen(token));
system_param_save_with_protect(ESP_PARAM_START_SEC, &esp_param, sizeof(esp_param));
}
/******************************************************************************
* FunctionName : user_esp_platform_set_active
* Description : set active flag
* Parameters : activeflag -- 0 or 1
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_set_active(uint8 activeflag)
{
esp_param.activeflag = activeflag;
system_param_save_with_protect(ESP_PARAM_START_SEC, &esp_param, sizeof(esp_param));
}
void ICACHE_FLASH_ATTR
user_esp_platform_set_connect_status(uint8 status)
{
device_status = status;
}
/******************************************************************************
* FunctionName : user_esp_platform_get_connect_status
* Description : get each connection step's status
* Parameters : none
* Returns : status
*******************************************************************************/
uint8 ICACHE_FLASH_ATTR
user_esp_platform_get_connect_status(void)
{
uint8 status = wifi_station_get_connect_status();
if (status == STATION_GOT_IP) {
status = (device_status == 0) ? DEVICE_CONNECTING : device_status;
}
ESP_DBG("status %d\n", status);
return status;
}
/******************************************************************************
* FunctionName : user_esp_platform_parse_nonce
* Description : parse the device nonce
* Parameters : pbuffer -- the recivce data point
* Returns : the nonce
*******************************************************************************/
int ICACHE_FLASH_ATTR
user_esp_platform_parse_nonce(char *pbuffer)
{
char *pstr = NULL;
char *pparse = NULL;
char noncestr[11] = {0};
int nonce = 0;
pstr = (char *)os_strstr(pbuffer, "\"nonce\": ");
if (pstr != NULL) {
pstr += 9;
pparse = (char *)os_strstr(pstr, ",");
if (pparse != NULL) {
os_memcpy(noncestr, pstr, pparse - pstr);
} else {
pparse = (char *)os_strstr(pstr, "}");
if (pparse != NULL) {
os_memcpy(noncestr, pstr, pparse - pstr);
} else {
pparse = (char *)os_strstr(pstr, "]");
if (pparse != NULL) {
os_memcpy(noncestr, pstr, pparse - pstr);
} else {
return 0;
}
}
}
nonce = atoi(noncestr);
}
return nonce;
}
/******************************************************************************
* FunctionName : user_esp_platform_get_info
* Description : get and update the espressif's device status
* Parameters : pespconn -- the espconn used to connect with host
* pbuffer -- prossing the data point
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_get_info(struct espconn *pconn, uint8 *pbuffer)
{
char *pbuf = NULL;
int nonce = 0;
pbuf = (char *)os_zalloc(packet_size);
nonce = user_esp_platform_parse_nonce(pbuffer);
if (pbuf != NULL) {
#if PLUG_DEVICE
os_sprintf(pbuf, RESPONSE_FRAME, user_plug_get_status(), nonce);
#elif LIGHT_DEVICE
uint32 white_val;
white_val = (PWM_CHANNEL>LIGHT_COLD_WHITE?user_light_get_duty(LIGHT_COLD_WHITE):0);
os_sprintf(pbuf, RESPONSE_FRAME, nonce, user_light_get_period(),
user_light_get_duty(LIGHT_RED), user_light_get_duty(LIGHT_GREEN),
user_light_get_duty(LIGHT_BLUE),white_val );//50);
#endif
ESP_DBG("%s\n", pbuf);
#ifdef CLIENT_SSL_ENABLE
espconn_secure_sent(pconn, pbuf, os_strlen(pbuf));
#else
espconn_sent(pconn, pbuf, os_strlen(pbuf));
#endif
os_free(pbuf);
pbuf = NULL;
}
}
/******************************************************************************
* FunctionName : user_esp_platform_set_info
* Description : prossing the data and controling the espressif's device
* Parameters : pespconn -- the espconn used to connect with host
* pbuffer -- prossing the data point
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_set_info(struct espconn *pconn, uint8 *pbuffer)
{
#if PLUG_DEVICE
char *pstr = NULL;
pstr = (char *)os_strstr(pbuffer, "plug-status");
if (pstr != NULL) {
pstr = (char *)os_strstr(pbuffer, "body");
if (pstr != NULL) {
if (os_strncmp(pstr + 27, "1", 1) == 0) {
user_plug_set_status(0x01);
} else if (os_strncmp(pstr + 27, "0", 1) == 0) {
user_plug_set_status(0x00);
}
}
}
#elif LIGHT_DEVICE
char *pstr = NULL;
char *pdata = NULL;
char *pbuf = NULL;
char recvbuf[10];
uint16 length = 0;
uint32 data = 0;
static uint32 rr,gg,bb,cw,ww,period;
ww=0;
cw=0;
extern uint8 light_sleep_flg;
pstr = (char *)os_strstr(pbuffer, "\"path\": \"/v1/datastreams/light/datapoint/\"");
if (pstr != NULL) {
pstr = (char *)os_strstr(pbuffer, "{\"datapoint\": ");
if (pstr != NULL) {
pbuf = (char *)os_strstr(pbuffer, "}}");
length = pbuf - pstr;
length += 2;
pdata = (char *)os_zalloc(length + 1);
os_memcpy(pdata, pstr, length);
pstr = (char *)os_strchr(pdata, 'x');
if (pstr != NULL) {
pstr += 4;
pbuf = (char *)os_strchr(pstr, ',');
if (pbuf != NULL) {
length = pbuf - pstr;
os_memset(recvbuf, 0, 10);
os_memcpy(recvbuf, pstr, length);
data = atoi(recvbuf);
period = data;
//user_light_set_period(data);
}
}
pstr = (char *)os_strchr(pdata, 'y');
if (pstr != NULL) {
pstr += 4;
pbuf = (char *)os_strchr(pstr, ',');
if (pbuf != NULL) {
length = pbuf - pstr;
os_memset(recvbuf, 0, 10);
os_memcpy(recvbuf, pstr, length);
data = atoi(recvbuf);
rr=data;
os_printf("r: %d\r\n",rr);
//user_light_set_duty(data, 0);
}
}
pstr = (char *)os_strchr(pdata, 'z');
if (pstr != NULL) {
pstr += 4;
pbuf = (char *)os_strchr(pstr, ',');
if (pbuf != NULL) {
length = pbuf - pstr;
os_memset(recvbuf, 0, 10);
os_memcpy(recvbuf, pstr, length);
data = atoi(recvbuf);
gg=data;
os_printf("g: %d\r\n",gg);
//user_light_set_duty(data, 1);
}
}
pstr = (char *)os_strchr(pdata, 'k');
if (pstr != NULL) {
pstr += 4;;
pbuf = (char *)os_strchr(pstr, ',');
if (pbuf != NULL) {
length = pbuf - pstr;
os_memset(recvbuf, 0, 10);
os_memcpy(recvbuf, pstr, length);
data = atoi(recvbuf);
bb=data;
os_printf("b: %d\r\n",bb);
//user_light_set_duty(data, 2);
}
}
pstr = (char *)os_strchr(pdata, 'l');
if (pstr != NULL) {
pstr += 4;;
pbuf = (char *)os_strchr(pstr, ',');
if (pbuf != NULL) {
length = pbuf - pstr;
os_memset(recvbuf, 0, 10);
os_memcpy(recvbuf, pstr, length);
data = atoi(recvbuf);
cw=data;
ww=data;
os_printf("cw: %d\r\n",cw);
os_printf("ww:%d\r\n",ww); //chg
//user_light_set_duty(data, 2);
}
}
os_free(pdata);
}
}
if((rr|gg|bb|cw|ww) == 0){
if(light_sleep_flg==0){
}
}else{
if(light_sleep_flg==1){
os_printf("modem sleep en\r\n");
wifi_set_sleep_type(MODEM_SLEEP_T);
light_sleep_flg =0;
}
}
light_set_aim(rr,gg,bb,cw,ww,period);
//user_light_restart();
#endif
user_esp_platform_get_info(pconn, pbuffer);
}
/******************************************************************************
* FunctionName : user_esp_platform_reconnect
* Description : reconnect with host after get ip
* Parameters : pespconn -- the espconn used to reconnect with host
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_reconnect(struct espconn *pespconn)
{
ESP_DBG("user_esp_platform_reconnect\n");
user_esp_platform_check_ip(0);
}
/******************************************************************************
* FunctionName : user_esp_platform_discon_cb
* Description : disconnect successfully with the host
* Parameters : arg -- Additional argument to pass to the callback function
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_discon_cb(void *arg)
{
struct espconn *pespconn = arg;
struct ip_info ipconfig;
struct dhcp_client_info dhcp_info;
ESP_DBG("user_esp_platform_discon_cb\n");
#if (PLUG_DEVICE || LIGHT_DEVICE)
os_timer_disarm(&beacon_timer);
#endif
if (pespconn == NULL) {
return;
}
pespconn->proto.tcp->local_port = espconn_port();
#if (PLUG_DEVICE || SENSOR_DEVICE)
user_link_led_output(1);
#endif
#if SENSOR_DEVICE
#ifdef SENSOR_DEEP_SLEEP
if (wifi_get_opmode() == STATION_MODE) {
/***add by tzx for saving ip_info to avoid dhcp_client start****/
wifi_get_ip_info(STATION_IF, &ipconfig);
dhcp_info.ip_addr = ipconfig.ip;
dhcp_info.netmask = ipconfig.netmask;
dhcp_info.gw = ipconfig.gw ;
dhcp_info.flag = 0x01;
os_printf("dhcp_info.ip_addr = %d\n",dhcp_info.ip_addr);
system_rtc_mem_write(64,&dhcp_info,sizeof(struct dhcp_client_info));
user_sensor_deep_sleep_enter();
} else {
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_reconnect, pespconn);
os_timer_arm(&client_timer, SENSOR_DEEP_SLEEP_TIME / 1000, 0);
}
#else
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_reconnect, pespconn);
os_timer_arm(&client_timer, 1000, 0);
#endif
#else
user_esp_platform_reconnect(pespconn);
#endif
}
/******************************************************************************
* FunctionName : user_esp_platform_discon
* Description : A new incoming connection has been disconnected.
* Parameters : espconn -- the espconn used to disconnect with host
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_discon(struct espconn *pespconn)
{
ESP_DBG("user_esp_platform_discon\n");
#if (PLUG_DEVICE || SENSOR_DEVICE)
user_link_led_output(1);
#endif
#ifdef CLIENT_SSL_ENABLE
espconn_secure_disconnect(pespconn);
#else
espconn_disconnect(pespconn);
#endif
}
/******************************************************************************
* FunctionName : user_esp_platform_sent_cb
* Description : Data has been sent successfully and acknowledged by the remote host.
* Parameters : arg -- Additional argument to pass to the callback function
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_sent_cb(void *arg)
{
struct espconn *pespconn = arg;
ESP_DBG("user_esp_platform_sent_cb\n");
}
/******************************************************************************
* FunctionName : user_esp_platform_sent
* Description : Processing the application data and sending it to the host
* Parameters : pespconn -- the espconn used to connetion with the host
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_sent(struct espconn *pespconn)
{
uint8 devkey[token_size] = {0};
uint32 nonce;
char *pbuf = (char *)os_zalloc(packet_size);
os_memcpy(devkey, esp_param.devkey, 40);
if (esp_param.activeflag == 0xFF) {
esp_param.activeflag = 0;
}
if (pbuf != NULL) {
if (esp_param.activeflag == 0) {
uint8 token[token_size] = {0};
uint8 bssid[6];
active_nonce = os_random() & 0x7FFFFFFF;
os_memcpy(token, esp_param.token, 40);
wifi_get_macaddr(STATION_IF, bssid);
os_sprintf(pbuf, ACTIVE_FRAME, active_nonce, token, MAC2STR(bssid),iot_version, devkey);
}
#if SENSOR_DEVICE
#if HUMITURE_SUB_DEVICE
else {
#if 0
uint16 tp, rh;
uint8 data[4];
if (user_mvh3004_read_th(data)) {
rh = data[0] << 8 | data[1];
tp = data[2] << 8 | data[3];
}
#else
uint16 tp, rh;
uint8 *data;
uint32 tp_t, rh_t;
data = (uint8 *)user_mvh3004_get_poweron_th();
rh = data[0] << 8 | data[1];
tp = data[2] << 8 | data[3];
#endif
tp_t = (tp >> 2) * 165 * 100 / (16384 - 1);
rh_t = (rh & 0x3fff) * 100 * 100 / (16384 - 1);
if (tp_t >= 4000) {
os_sprintf(pbuf, UPLOAD_FRAME, count, "", tp_t / 100 - 40, tp_t % 100, rh_t / 100, rh_t % 100, devkey);
} else {
tp_t = 4000 - tp_t;
os_sprintf(pbuf, UPLOAD_FRAME, count, "-", tp_t / 100, tp_t % 100, rh_t / 100, rh_t % 100, devkey);
}
}
#elif FLAMMABLE_GAS_SUB_DEVICE
else {
uint32 adc_value = system_adc_read();
os_sprintf(pbuf, UPLOAD_FRAME, count, adc_value / 1024, adc_value * 1000 / 1024, devkey);
}
#endif
#else
else {
nonce = os_random() & 0x7FFFFFFF;
os_sprintf(pbuf, FIRST_FRAME, nonce , devkey);
}
#endif
ESP_DBG("%s\n", pbuf);
#ifdef CLIENT_SSL_ENABLE
espconn_secure_sent(pespconn, pbuf, os_strlen(pbuf));
#else
espconn_sent(pespconn, pbuf, os_strlen(pbuf));
#endif
os_free(pbuf);
}
}
#if PLUG_DEVICE || LIGHT_DEVICE
/******************************************************************************
* FunctionName : user_esp_platform_sent_beacon
* Description : sent beacon frame for connection with the host is activate
* Parameters : pespconn -- the espconn used to connetion with the host
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_sent_beacon(struct espconn *pespconn)
{
if (pespconn == NULL) {
return;
}
if (pespconn->state == ESPCONN_CONNECT) {
if (esp_param.activeflag == 0) {
ESP_DBG("please check device is activated.\n");
user_esp_platform_sent(pespconn);
} else {
uint8 devkey[token_size] = {0};
os_memcpy(devkey, esp_param.devkey, 40);
ESP_DBG("user_esp_platform_sent_beacon %u\n", system_get_time());
if (ping_status == 0) {
ESP_DBG("user_esp_platform_sent_beacon sent fail!\n");
user_esp_platform_discon(pespconn);
} else {
char *pbuf = (char *)os_zalloc(packet_size);
if (pbuf != NULL) {
os_sprintf(pbuf, BEACON_FRAME, devkey);
#ifdef CLIENT_SSL_ENABLE
espconn_secure_sent(pespconn, pbuf, os_strlen(pbuf));
#else
espconn_sent(pespconn, pbuf, os_strlen(pbuf));
#endif
ping_status = 0;
os_timer_arm(&beacon_timer, BEACON_TIME, 0);
os_free(pbuf);
}
}
}
} else {
ESP_DBG("user_esp_platform_sent_beacon sent fail!\n");
user_esp_platform_discon(pespconn);
}
}
/******************************************************************************
* FunctionName : user_platform_rpc_set_rsp
* Description : response the message to server to show setting info is received
* Parameters : pespconn -- the espconn used to connetion with the host
* nonce -- mark the message received from server
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_platform_rpc_set_rsp(struct espconn *pespconn, int nonce)
{
char *pbuf = (char *)os_zalloc(packet_size);
if (pespconn == NULL) {
return;
}
os_sprintf(pbuf, RPC_RESPONSE_FRAME, nonce);
ESP_DBG("%s\n", pbuf);
#ifdef CLIENT_SSL_ENABLE
espconn_secure_sent(pespconn, pbuf, os_strlen(pbuf));
#else
espconn_sent(pespconn, pbuf, os_strlen(pbuf));
#endif
os_free(pbuf);
}
/******************************************************************************
* FunctionName : user_platform_timer_get
* Description : get the timers from server
* Parameters : pespconn -- the espconn used to connetion with the host
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_platform_timer_get(struct espconn *pespconn)
{
uint8 devkey[token_size] = {0};
char *pbuf = (char *)os_zalloc(packet_size);
os_memcpy(devkey, esp_param.devkey, 40);
if (pespconn == NULL) {
return;
}
os_sprintf(pbuf, TIMER_FRAME, devkey);
ESP_DBG("%s\n", pbuf);
#ifdef CLIENT_SSL_ENABLE
espconn_secure_sent(pespconn, pbuf, os_strlen(pbuf));
#else
espconn_sent(pespconn, pbuf, os_strlen(pbuf));
#endif
os_free(pbuf);
}
/******************************************************************************
* FunctionName : user_esp_platform_upgrade_cb
* Description : Processing the downloaded data from the server
* Parameters : pespconn -- the espconn used to connetion with the host
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_upgrade_rsp(void *arg)
{
struct upgrade_server_info *server = arg;
struct espconn *pespconn = server->pespconn;
uint8 devkey[41] = {0};
uint8 *pbuf = NULL;
char *action = NULL;
os_memcpy(devkey, esp_param.devkey, 40);
pbuf = (char *)os_zalloc(packet_size);
if (server->upgrade_flag == true) {
ESP_DBG("user_esp_platform_upgarde_successfully\n");
action = "device_upgrade_success";
os_sprintf(pbuf, UPGRADE_FRAME, devkey, action, server->pre_version, server->upgrade_version);
ESP_DBG("%s\n",pbuf);
#ifdef CLIENT_SSL_ENABLE
espconn_secure_sent(pespconn, pbuf, os_strlen(pbuf));
#else
espconn_sent(pespconn, pbuf, os_strlen(pbuf));
#endif
if (pbuf != NULL) {
os_free(pbuf);
pbuf = NULL;
}
} else {
ESP_DBG("user_esp_platform_upgrade_failed\n");
action = "device_upgrade_failed";
os_sprintf(pbuf, UPGRADE_FRAME, devkey, action,server->pre_version, server->upgrade_version);
ESP_DBG("%s\n",pbuf);
#ifdef CLIENT_SSL_ENABLE
espconn_secure_sent(pespconn, pbuf, os_strlen(pbuf));
#else
espconn_sent(pespconn, pbuf, os_strlen(pbuf));
#endif
if (pbuf != NULL) {
os_free(pbuf);
pbuf = NULL;
}
}
os_free(server->url);
server->url = NULL;
os_free(server);
server = NULL;
}
/******************************************************************************
* FunctionName : user_esp_platform_upgrade_begin
* Description : Processing the received data from the server
* Parameters : pespconn -- the espconn used to connetion with the host
* server -- upgrade param
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_upgrade_begin(struct espconn *pespconn, struct upgrade_server_info *server)
{
uint8 user_bin[9] = {0};
uint8 devkey[41] = {0};
server->pespconn = pespconn;
os_memcpy(devkey, esp_param.devkey, 40);
os_memcpy(server->ip, pespconn->proto.tcp->remote_ip, 4);
#ifdef UPGRADE_SSL_ENABLE
server->port = 443;
#else
server->port = 80;
#endif
server->check_cb = user_esp_platform_upgrade_rsp;
server->check_times = 120000;
if (server->url == NULL) {
server->url = (uint8 *)os_zalloc(512);
}
if (system_upgrade_userbin_check() == UPGRADE_FW_BIN1) {
os_memcpy(user_bin, "user2.bin", 10);
} else if (system_upgrade_userbin_check() == UPGRADE_FW_BIN2) {
os_memcpy(user_bin, "user1.bin", 10);
}
os_sprintf(server->url, "GET /v1/device/rom/?action=download_rom&version=%s&filename=%s HTTP/1.0\r\nHost: "IPSTR":%d\r\n"pheadbuffer"",
server->upgrade_version, user_bin, IP2STR(server->ip),
server->port, devkey);
ESP_DBG("%s\n",server->url);
#ifdef UPGRADE_SSL_ENABLE
if (system_upgrade_start_ssl(server) == false) {
#else
if (system_upgrade_start(server) == false) {
#endif
ESP_DBG("upgrade is already started\n");
}
}
#endif
/******************************************************************************
* FunctionName : user_esp_platform_recv_cb
* Description : Processing the received data from the server
* 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_esp_platform_recv_cb(void *arg, char *pusrdata, unsigned short length)
{
char *pstr = NULL;
LOCAL char pbuffer[1024 * 2] = {0};
struct espconn *pespconn = arg;
ESP_DBG("user_esp_platform_recv_cb %s\n", pusrdata);
#if (PLUG_DEVICE || LIGHT_DEVICE)
os_timer_disarm(&beacon_timer);
#endif
if (length == 1460) {
os_memcpy(pbuffer, pusrdata, length);
} else {
struct espconn *pespconn = (struct espconn *)arg;
os_memcpy(pbuffer + os_strlen(pbuffer), pusrdata, length);
if ((pstr = (char *)os_strstr(pbuffer, "\"activate_status\": ")) != NULL &&
user_esp_platform_parse_nonce(pbuffer) == active_nonce) {
if (os_strncmp(pstr + 19, "1", 1) == 0) {
ESP_DBG("device activates successful.\n");
device_status = DEVICE_ACTIVE_DONE;
esp_param.activeflag = 1;
system_param_save_with_protect(ESP_PARAM_START_SEC, &esp_param, sizeof(esp_param));
user_esp_platform_sent(pespconn);
if(LIGHT_DEVICE){
system_restart();
}
} else {
ESP_DBG("device activates failed.\n");
device_status = DEVICE_ACTIVE_FAIL;
}
}
#if (PLUG_DEVICE || LIGHT_DEVICE)
else if ((pstr = (char *)os_strstr(pbuffer, "\"action\": \"sys_upgrade\"")) != NULL) {
if ((pstr = (char *)os_strstr(pbuffer, "\"version\":")) != NULL) {
struct upgrade_server_info *server = NULL;
int nonce = user_esp_platform_parse_nonce(pbuffer);
user_platform_rpc_set_rsp(pespconn, nonce);
server = (struct upgrade_server_info *)os_zalloc(sizeof(struct upgrade_server_info));
os_memcpy(server->upgrade_version, pstr + 12, 16);
server->upgrade_version[15] = '\0';
os_sprintf(server->pre_version,"%s%d.%d.%dt%d(%s)",VERSION_TYPE,IOT_VERSION_MAJOR,\
IOT_VERSION_MINOR,IOT_VERSION_REVISION,device_type,UPGRADE_FALG);
user_esp_platform_upgrade_begin(pespconn, server);
}
} else if ((pstr = (char *)os_strstr(pbuffer, "\"action\": \"sys_reboot\"")) != NULL) {
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)system_upgrade_reboot, NULL);
os_timer_arm(&client_timer, 1000, 0);
} else if ((pstr = (char *)os_strstr(pbuffer, "/v1/device/timers/")) != NULL) {
int nonce = user_esp_platform_parse_nonce(pbuffer);
user_platform_rpc_set_rsp(pespconn, nonce);
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_platform_timer_get, pespconn);
os_timer_arm(&client_timer, 2000, 0);
} else if ((pstr = (char *)os_strstr(pbuffer, "\"method\": ")) != NULL) {
if (os_strncmp(pstr + 11, "GET", 3) == 0) {
user_esp_platform_get_info(pespconn, pbuffer);
} else if (os_strncmp(pstr + 11, "POST", 4) == 0) {
user_esp_platform_set_info(pespconn, pbuffer);
}
} else if ((pstr = (char *)os_strstr(pbuffer, "ping success")) != NULL) {
ESP_DBG("ping success\n");
ping_status = 1;
} else if ((pstr = (char *)os_strstr(pbuffer, "send message success")) != NULL) {
} else if ((pstr = (char *)os_strstr(pbuffer, "timers")) != NULL) {
user_platform_timer_start(pusrdata , pespconn);
}
#elif SENSOR_DEVICE
else if ((pstr = (char *)os_strstr(pbuffer, "\"status\":")) != NULL) {
if (os_strncmp(pstr + 10, "200", 3) != 0) {
ESP_DBG("message upload failed.\n");
} else {
count++;
ESP_DBG("message upload sucessful.\n");
}
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_discon, pespconn);
os_timer_arm(&client_timer, 10, 0);
}
#endif
else if ((pstr = (char *)os_strstr(pbuffer, "device")) != NULL) {
#if PLUG_DEVICE || LIGHT_DEVICE
user_platform_timer_get(pespconn);
#elif SENSOR_DEVICE
#endif
}
os_memset(pbuffer, 0, sizeof(pbuffer));
}
#if (PLUG_DEVICE || LIGHT_DEVICE)
os_timer_arm(&beacon_timer, BEACON_TIME, 0);
#endif
}
#if AP_CACHE
/******************************************************************************
* FunctionName : user_esp_platform_ap_change
* Description : add the user interface for changing to next ap ID.
* Parameters :
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_ap_change(void)
{
uint8 current_id;
uint8 i = 0;
ESP_DBG("user_esp_platform_ap_is_changing\n");
current_id = wifi_station_get_current_ap_id();
ESP_DBG("current ap id =%d\n", current_id);
if (current_id == AP_CACHE_NUMBER - 1) {
i = 0;
} else {
i = current_id + 1;
}
while (wifi_station_ap_change(i) != true) {
i++;
if (i == AP_CACHE_NUMBER - 1) {
i = 0;
}
}
/* just need to re-check ip while change AP */
device_recon_count = 0;
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_check_ip, NULL);
os_timer_arm(&client_timer, 100, 0);
}
#endif
LOCAL bool ICACHE_FLASH_ATTR
user_esp_platform_reset_mode(void)
{
if (wifi_get_opmode() == STATION_MODE) {
wifi_set_opmode(STATIONAP_MODE);
}
#if AP_CACHE
/* delay 5s to change AP */
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_ap_change, NULL);
os_timer_arm(&client_timer, 5000, 0);
return true;
#endif
return false;
}
/******************************************************************************
* FunctionName : user_esp_platform_recon_cb
* Description : The connection had an error and is already deallocated.
* Parameters : arg -- Additional argument to pass to the callback function
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_recon_cb(void *arg, sint8 err)
{
struct espconn *pespconn = (struct espconn *)arg;
ESP_DBG("user_esp_platform_recon_cb\n");
#if (PLUG_DEVICE || LIGHT_DEVICE)
os_timer_disarm(&beacon_timer);
#endif
#if (PLUG_DEVICE || SENSOR_DEVICE)
user_link_led_output(1);
#endif
if (++device_recon_count == 5) {
device_status = DEVICE_CONNECT_SERVER_FAIL;
if (user_esp_platform_reset_mode()) {
return;
}
}
#if SENSOR_DEVICE
#ifdef SENSOR_DEEP_SLEEP
if (wifi_get_opmode() == STATION_MODE) {
user_esp_platform_reset_mode();
//user_sensor_deep_sleep_enter();
} else {
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_reconnect, pespconn);
os_timer_arm(&client_timer, 1000, 0);
}
#else
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_reconnect, pespconn);
os_timer_arm(&client_timer, 1000, 0);
#endif
#else
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_reconnect, pespconn);
os_timer_arm(&client_timer, 1000, 0);
#endif
}
/******************************************************************************
* FunctionName : user_esp_platform_connect_cb
* Description : A new incoming connection has been connected.
* Parameters : arg -- Additional argument to pass to the callback function
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_connect_cb(void *arg)
{
struct espconn *pespconn = arg;
ESP_DBG("user_esp_platform_connect_cb\n");
if (wifi_get_opmode() == STATIONAP_MODE ) {
wifi_set_opmode(STATION_MODE);
}
#if (PLUG_DEVICE || SENSOR_DEVICE)
user_link_led_timer_done();
#endif
device_recon_count = 0;
espconn_regist_recvcb(pespconn, user_esp_platform_recv_cb);
espconn_regist_sentcb(pespconn, user_esp_platform_sent_cb);
user_esp_platform_sent(pespconn);
}
/******************************************************************************
* FunctionName : user_esp_platform_connect
* Description : The function given as the connect with the host
* Parameters : espconn -- the espconn used to connect the connection
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_connect(struct espconn *pespconn)
{
ESP_DBG("user_esp_platform_connect\n");
#ifdef CLIENT_SSL_ENABLE
espconn_secure_connect(pespconn);
#else
espconn_connect(pespconn);
#endif
}
#ifdef USE_DNS
/******************************************************************************
* FunctionName : user_esp_platform_dns_found
* Description : dns found callback
* Parameters : name -- pointer to the name that was looked up.
* ipaddr -- pointer to an ip_addr_t containing the IP address of
* the hostname, or NULL if the name could not be found (or on any
* other error).
* callback_arg -- a user-specified callback argument passed to
* dns_gethostbyname
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_dns_found(const char *name, ip_addr_t *ipaddr, void *arg)
{
struct espconn *pespconn = (struct espconn *)arg;
if (ipaddr == NULL) {
ESP_DBG("user_esp_platform_dns_found NULL\n");
if (++device_recon_count == 5) {
device_status = DEVICE_CONNECT_SERVER_FAIL;
user_esp_platform_reset_mode();
}
return;
}
ESP_DBG("user_esp_platform_dns_found %d.%d.%d.%d\n",
*((uint8 *)&ipaddr->addr), *((uint8 *)&ipaddr->addr + 1),
*((uint8 *)&ipaddr->addr + 2), *((uint8 *)&ipaddr->addr + 3));
if (esp_server_ip.addr == 0 && ipaddr->addr != 0) {
os_timer_disarm(&client_timer);
esp_server_ip.addr = ipaddr->addr;
os_memcpy(pespconn->proto.tcp->remote_ip, &ipaddr->addr, 4);
pespconn->proto.tcp->local_port = espconn_port();
#ifdef CLIENT_SSL_ENABLE
pespconn->proto.tcp->remote_port = 8443;
#else
pespconn->proto.tcp->remote_port = 8000;
#endif
#if (PLUG_DEVICE || LIGHT_DEVICE)
ping_status = 1;
#endif
espconn_regist_connectcb(pespconn, user_esp_platform_connect_cb);
espconn_regist_disconcb(pespconn, user_esp_platform_discon_cb);
espconn_regist_reconcb(pespconn, user_esp_platform_recon_cb);
user_esp_platform_connect(pespconn);
}
}
/******************************************************************************
* FunctionName : user_esp_platform_dns_check_cb
* Description : 1s time callback to check dns found
* Parameters : arg -- Additional argument to pass to the callback function
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_dns_check_cb(void *arg)
{
struct espconn *pespconn = arg;
ESP_DBG("user_esp_platform_dns_check_cb\n");
espconn_gethostbyname(pespconn, ESP_DOMAIN, &esp_server_ip, user_esp_platform_dns_found);
os_timer_arm(&client_timer, 1000, 0);
}
LOCAL void ICACHE_FLASH_ATTR
user_esp_platform_start_dns(struct espconn *pespconn)
{
esp_server_ip.addr = 0;
espconn_gethostbyname(pespconn, ESP_DOMAIN, &esp_server_ip, user_esp_platform_dns_found);
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_dns_check_cb, pespconn);
os_timer_arm(&client_timer, 1000, 0);
}
#endif
#if LIGHT_DEVICE
void user_mdns_conf()
{
struct ip_info ipconfig;
wifi_get_ip_info(STATION_IF, &ipconfig);
struct mdns_info *info = (struct mdns_info *)os_zalloc(sizeof(struct mdns_info));
info->host_name = "espressif_light_demo";
info->ipAddr= ipconfig.ip.addr; //sation ip
info->server_name = "espLight";
info->server_port = 80;
info->txt_data[0] = "version = 1.0.1";
espconn_mdns_init(info);
}
#endif
/******************************************************************************
* FunctionName : user_esp_platform_check_ip
* Description : espconn struct parame init when get ip addr
* Parameters : none
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_check_ip(uint8 reset_flag)
{
struct ip_info ipconfig;
os_timer_disarm(&client_timer);
wifi_get_ip_info(STATION_IF, &ipconfig);
if (wifi_station_get_connect_status() == STATION_GOT_IP && ipconfig.ip.addr != 0) {
#if (PLUG_DEVICE || SENSOR_DEVICE)
user_link_led_timer_init();
#endif
//***************************
#if LIGHT_DEVICE
user_mdns_conf();
#endif
//***************************
user_conn.proto.tcp = &user_tcp;
user_conn.type = ESPCONN_TCP;
user_conn.state = ESPCONN_NONE;
device_status = DEVICE_CONNECTING;
if (reset_flag) {
device_recon_count = 0;
}
#if (PLUG_DEVICE || LIGHT_DEVICE)
os_timer_disarm(&beacon_timer);
os_timer_setfn(&beacon_timer, (os_timer_func_t *)user_esp_platform_sent_beacon, &user_conn);
#endif
#ifdef USE_DNS
user_esp_platform_start_dns(&user_conn);
#else
const char esp_server_ip[4] = {114, 215, 177, 97};
os_memcpy(user_conn.proto.tcp->remote_ip, esp_server_ip, 4);
user_conn.proto.tcp->local_port = espconn_port();
#ifdef CLIENT_SSL_ENABLE
user_conn.proto.tcp->remote_port = 8443;
#else
user_conn.proto.tcp->remote_port = 8000;
#endif
espconn_regist_connectcb(&user_conn, user_esp_platform_connect_cb);
espconn_regist_reconcb(&user_conn, user_esp_platform_recon_cb);
user_esp_platform_connect(&user_conn);
#endif
} else {
/* if there are wrong while connecting to some AP, then reset mode */
if ((wifi_station_get_connect_status() == STATION_WRONG_PASSWORD ||
wifi_station_get_connect_status() == STATION_NO_AP_FOUND ||
wifi_station_get_connect_status() == STATION_CONNECT_FAIL)) {
user_esp_platform_reset_mode();
} else {
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_check_ip, NULL);
os_timer_arm(&client_timer, 100, 0);
}
}
}
/******************************************************************************
* FunctionName : user_esp_platform_init
* Description : device parame init based on espressif platform
* Parameters : none
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_esp_platform_init(void)
{
os_sprintf(iot_version,"%s%d.%d.%dt%d(%s)",VERSION_TYPE,IOT_VERSION_MAJOR,\
IOT_VERSION_MINOR,IOT_VERSION_REVISION,device_type,UPGRADE_FALG);
os_printf("IOT VERSION = %s\n",iot_version);
system_param_load(ESP_PARAM_START_SEC, 0, &esp_param, sizeof(esp_param));
struct rst_info *rtc_info = system_get_rst_info();
os_printf("reset reason: %x\n", rtc_info->reason);
if (rtc_info->reason == REASON_WDT_RST ||
rtc_info->reason == REASON_EXCEPTION_RST ||
rtc_info->reason == REASON_SOFT_WDT_RST) {
if (rtc_info->reason == REASON_EXCEPTION_RST) {
os_printf("Fatal exception (%d):\n", rtc_info->exccause);
}
os_printf("epc1=0x%08x, epc2=0x%08x, epc3=0x%08x, excvaddr=0x%08x, depc=0x%08x\n",
rtc_info->epc1, rtc_info->epc2, rtc_info->epc3, rtc_info->excvaddr, rtc_info->depc);
}
/***add by tzx for saving ip_info to avoid dhcp_client start****/
struct dhcp_client_info dhcp_info;
struct ip_info sta_info;
system_rtc_mem_read(64,&dhcp_info,sizeof(struct dhcp_client_info));
if(dhcp_info.flag == 0x01 ) {
if (true == wifi_station_dhcpc_status())
{
wifi_station_dhcpc_stop();
}
sta_info.ip = dhcp_info.ip_addr;
sta_info.gw = dhcp_info.gw;
sta_info.netmask = dhcp_info.netmask;
if ( true != wifi_set_ip_info(STATION_IF,&sta_info)) {
os_printf("set default ip wrong\n");
}
}
os_memset(&dhcp_info,0,sizeof(struct dhcp_client_info));
system_rtc_mem_write(64,&dhcp_info,sizeof(struct rst_info));
#if AP_CACHE
wifi_station_ap_number_set(AP_CACHE_NUMBER);
#endif
#if 0
{
char sofap_mac[6] = {0x16, 0x34, 0x56, 0x78, 0x90, 0xab};
char sta_mac[6] = {0x12, 0x34, 0x56, 0x78, 0x90, 0xab};
struct ip_info info;
wifi_set_macaddr(SOFTAP_IF, sofap_mac);
wifi_set_macaddr(STATION_IF, sta_mac);
IP4_ADDR(&info.ip, 192, 168, 3, 200);
IP4_ADDR(&info.gw, 192, 168, 3, 1);
IP4_ADDR(&info.netmask, 255, 255, 255, 0);
wifi_set_ip_info(STATION_IF, &info);
IP4_ADDR(&info.ip, 10, 10, 10, 1);
IP4_ADDR(&info.gw, 10, 10, 10, 1);
IP4_ADDR(&info.netmask, 255, 255, 255, 0);
wifi_set_ip_info(SOFTAP_IF, &info);
}
#endif
if (esp_param.activeflag != 1) {
#ifdef SOFTAP_ENCRYPT
struct softap_config config;
char password[33];
char macaddr[6];
wifi_softap_get_config(&config);
wifi_get_macaddr(SOFTAP_IF, macaddr);
os_memset(config.password, 0, sizeof(config.password));
os_sprintf(password, MACSTR "_%s", MAC2STR(macaddr), PASSWORD);
os_memcpy(config.password, password, os_strlen(password));
config.authmode = AUTH_WPA_WPA2_PSK;
wifi_softap_set_config(&config);
#endif
wifi_set_opmode(STATIONAP_MODE);
}
#if PLUG_DEVICE
user_plug_init();
#elif LIGHT_DEVICE
user_light_init();
#elif SENSOR_DEVICE
user_sensor_init(esp_param.activeflag);
#endif
if (wifi_get_opmode() != SOFTAP_MODE) {
os_timer_disarm(&client_timer);
os_timer_setfn(&client_timer, (os_timer_func_t *)user_esp_platform_check_ip, 1);
os_timer_arm(&client_timer, 100, 0);
}
}
#endif
/******************************************************************************
* 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);
}
}
/******************************************************************************
* 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);
}
}
}
/******************************************************************************
* 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
#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");
}
}
/******************************************************************************
* 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
}
/******************************************************************************
* 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
/******************************************************************************
* 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
/******************************************************************************
* Copyright 2013-2014 Espressif Systems (Wuxi)
*
* FileName: user_webserver.c
*
* Description: The web server mode configration.
* Check your hardware connection with the host while use this 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 "user_iot_version.h"
#include "espconn.h"
#include "user_json.h"
#include "user_webserver.h"
#include "upgrade.h"
#if ESP_PLATFORM
#include "user_esp_platform.h"
#endif
#ifdef SERVER_SSL_ENABLE
#include "ssl/cert.h"
#include "ssl/private_key.h"
#endif
#if LIGHT_DEVICE
#include "user_light.h"
#endif
LOCAL struct station_config *sta_conf;
LOCAL struct softap_config *ap_conf;
//LOCAL struct secrty_server_info *sec_server;
//LOCAL struct upgrade_server_info *server;
//struct lewei_login_info *login_info;
LOCAL scaninfo *pscaninfo;
struct bss_info *bss;
struct bss_info *bss_temp;
struct bss_info *bss_head;
extern u16 scannum;
LOCAL uint32 PostCmdNeeRsp = 1;
uint8 upgrade_lock = 0;
LOCAL os_timer_t app_upgrade_10s;
LOCAL os_timer_t upgrade_check_timer;
/******************************************************************************
* FunctionName : device_get
* Description : set up the device information parmer as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
device_get(struct jsontree_context *js_ctx)
{
const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);
if (os_strncmp(path, "manufacture", 11) == 0) {
jsontree_write_string(js_ctx, "Espressif Systems");
} else if (os_strncmp(path, "product", 7) == 0) {
#if SENSOR_DEVICE
#if HUMITURE_SUB_DEVICE
jsontree_write_string(js_ctx, "Humiture");
#elif FLAMMABLE_GAS_SUB_DEVICE
jsontree_write_string(js_ctx, "Flammable Gas");
#endif
#endif
#if PLUG_DEVICE
jsontree_write_string(js_ctx, "Plug");
#endif
#if LIGHT_DEVICE
jsontree_write_string(js_ctx, "Light");
#endif
}
return 0;
}
LOCAL struct jsontree_callback device_callback =
JSONTREE_CALLBACK(device_get, NULL);
/******************************************************************************
* FunctionName : userbin_get
* Description : get up the user bin paramer as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
userbin_get(struct jsontree_context *js_ctx)
{
const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);
char string[32];
if (os_strncmp(path, "status", 8) == 0) {
os_sprintf(string, "200");
} else if (os_strncmp(path, "user_bin", 8) == 0) {
if (system_upgrade_userbin_check() == 0x00) {
os_sprintf(string, "user1.bin");
} else if (system_upgrade_userbin_check() == 0x01) {
os_sprintf(string, "user2.bin");
} else{
return 0;
}
}
jsontree_write_string(js_ctx, string);
return 0;
}
LOCAL struct jsontree_callback userbin_callback =
JSONTREE_CALLBACK(userbin_get, NULL);
JSONTREE_OBJECT(userbin_tree,
JSONTREE_PAIR("status", &userbin_callback),
JSONTREE_PAIR("user_bin", &userbin_callback));
JSONTREE_OBJECT(userinfo_tree,JSONTREE_PAIR("user_info",&userbin_tree));
/******************************************************************************
* FunctionName : version_get
* Description : set up the device version paramer as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
version_get(struct jsontree_context *js_ctx)
{
const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);
char string[32];
if (os_strncmp(path, "hardware", 8) == 0) {
#if SENSOR_DEVICE
os_sprintf(string, "0.3");
#else
os_sprintf(string, "0.1");
#endif
} else if (os_strncmp(path, "sdk_version", 11) == 0) {
os_sprintf(string, "%s", system_get_sdk_version());
} else if (os_strncmp(path, "iot_version", 11) == 0) {
os_sprintf(string,"%s%d.%d.%dt%d(%s)",VERSION_TYPE,IOT_VERSION_MAJOR,\
IOT_VERSION_MINOR,IOT_VERSION_REVISION,device_type,UPGRADE_FALG);
}
jsontree_write_string(js_ctx, string);
return 0;
}
LOCAL struct jsontree_callback version_callback =
JSONTREE_CALLBACK(version_get, NULL);
JSONTREE_OBJECT(device_tree,
JSONTREE_PAIR("product", &device_callback),
JSONTREE_PAIR("manufacturer", &device_callback));
JSONTREE_OBJECT(version_tree,
JSONTREE_PAIR("hardware", &version_callback),
JSONTREE_PAIR("sdk_version", &version_callback),
JSONTREE_PAIR("iot_version", &version_callback),
);
JSONTREE_OBJECT(info_tree,
JSONTREE_PAIR("Version", &version_tree),
JSONTREE_PAIR("Device", &device_tree));
JSONTREE_OBJECT(INFOTree,
JSONTREE_PAIR("info", &info_tree));
LOCAL int ICACHE_FLASH_ATTR
connect_status_get(struct jsontree_context *js_ctx)
{
const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);
if (os_strncmp(path, "status", 8) == 0) {
jsontree_write_int(js_ctx, user_esp_platform_get_connect_status());
}
return 0;
}
LOCAL struct jsontree_callback connect_status_callback =
JSONTREE_CALLBACK(connect_status_get, NULL);
JSONTREE_OBJECT(status_sub_tree,
JSONTREE_PAIR("status", &connect_status_callback));
JSONTREE_OBJECT(connect_status_tree,
JSONTREE_PAIR("Status", &status_sub_tree));
JSONTREE_OBJECT(con_status_tree,
JSONTREE_PAIR("info", &connect_status_tree));
#if PLUG_DEVICE
/******************************************************************************
* FunctionName : status_get
* Description : set up the device status as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
status_get(struct jsontree_context *js_ctx)
{
if (user_plug_get_status() == 1) {
jsontree_write_int(js_ctx, 1);
} else {
jsontree_write_int(js_ctx, 0);
}
return 0;
}
/******************************************************************************
* FunctionName : status_set
* Description : parse the device status parmer as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* parser -- A pointer to a JSON parser state
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
status_set(struct jsontree_context *js_ctx, struct jsonparse_state *parser)
{
int type;
while ((type = jsonparse_next(parser)) != 0) {
if (type == JSON_TYPE_PAIR_NAME) {
if (jsonparse_strcmp_value(parser, "status") == 0) {
uint8 status;
jsonparse_next(parser);
jsonparse_next(parser);
status = jsonparse_get_value_as_int(parser);
user_plug_set_status(status);
}
}
}
return 0;
}
LOCAL struct jsontree_callback status_callback =
JSONTREE_CALLBACK(status_get, status_set);
JSONTREE_OBJECT(status_tree,
JSONTREE_PAIR("status", &status_callback));
JSONTREE_OBJECT(response_tree,
JSONTREE_PAIR("Response", &status_tree));
JSONTREE_OBJECT(StatusTree,
JSONTREE_PAIR("switch", &response_tree));
#endif
#if LIGHT_DEVICE
LOCAL int ICACHE_FLASH_ATTR
light_status_get(struct jsontree_context *js_ctx)
{
const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);
if (os_strncmp(path, "red", 3) == 0) {
jsontree_write_int(js_ctx, user_light_get_duty(LIGHT_RED));
} else if (os_strncmp(path, "green", 5) == 0) {
jsontree_write_int(js_ctx, user_light_get_duty(LIGHT_GREEN));
} else if (os_strncmp(path, "blue", 4) == 0) {
jsontree_write_int(js_ctx, user_light_get_duty(LIGHT_BLUE));
} else if (os_strncmp(path, "wwhite", 6) == 0) {
if(PWM_CHANNEL>LIGHT_WARM_WHITE){
jsontree_write_int(js_ctx, user_light_get_duty(LIGHT_WARM_WHITE));
}else{
jsontree_write_int(js_ctx, 0);
}
} else if (os_strncmp(path, "cwhite", 6) == 0) {
if(PWM_CHANNEL>LIGHT_COLD_WHITE){
jsontree_write_int(js_ctx, user_light_get_duty(LIGHT_COLD_WHITE));
}else{
jsontree_write_int(js_ctx, 0);
}
} else if (os_strncmp(path, "period", 6) == 0) {
jsontree_write_int(js_ctx, user_light_get_period());
}
return 0;
}
LOCAL int ICACHE_FLASH_ATTR
light_status_set(struct jsontree_context *js_ctx, struct jsonparse_state *parser)
{
int type;
static uint32 r,g,b,cw,ww,period;
period = 1000;
cw=0;
ww=0;
extern uint8 light_sleep_flg;
while ((type = jsonparse_next(parser)) != 0) {
if (type == JSON_TYPE_PAIR_NAME) {
if (jsonparse_strcmp_value(parser, "red") == 0) {
uint32 status;
jsonparse_next(parser);
jsonparse_next(parser);
status = jsonparse_get_value_as_int(parser);
r=status;
os_printf("R: %d \n",status);
//user_light_set_duty(status, LIGHT_RED);
//light_set_aim_r( r);
} else if (jsonparse_strcmp_value(parser, "green") == 0) {
uint32 status;
jsonparse_next(parser);
jsonparse_next(parser);
status = jsonparse_get_value_as_int(parser);
g=status;
os_printf("G: %d \n",status);
//user_light_set_duty(status, LIGHT_GREEN);
//light_set_aim_g( g);
} else if (jsonparse_strcmp_value(parser, "blue") == 0) {
uint32 status;
jsonparse_next(parser);
jsonparse_next(parser);
status = jsonparse_get_value_as_int(parser);
b=status;
os_printf("B: %d \n",status);
//user_light_set_duty(status, LIGHT_BLUE);
//set_aim_b( b);
} else if (jsonparse_strcmp_value(parser, "cwhite") == 0) {
uint32 status;
jsonparse_next(parser);
jsonparse_next(parser);
status = jsonparse_get_value_as_int(parser);
cw=status;
os_printf("CW: %d \n",status);
//user_light_set_duty(status, LIGHT_BLUE);
//set_aim_b( b);
} else if (jsonparse_strcmp_value(parser, "wwhite") == 0) {
uint32 status;
jsonparse_next(parser);
jsonparse_next(parser);
status = jsonparse_get_value_as_int(parser);
ww=status;
os_printf("WW: %d \n",status);
//user_light_set_duty(status, LIGHT_BLUE);
//set_aim_b( b);
} else if (jsonparse_strcmp_value(parser, "period") == 0) {
uint32 status;
jsonparse_next(parser);
jsonparse_next(parser);
status = jsonparse_get_value_as_int(parser);
os_printf("PERIOD: %d \n",status);
period=status;
//user_light_set_period(status);
}else if (jsonparse_strcmp_value(parser, "response") == 0) {
uint32 status;
jsonparse_next(parser);
jsonparse_next(parser);
status = jsonparse_get_value_as_int(parser);
os_printf("rspneed: %d \n",status);
PostCmdNeeRsp = status;
}
}
}
if((r|g|b|ww|cw) == 0){
if(light_sleep_flg==0){
}
}else{
if(light_sleep_flg==1){
os_printf("modem sleep en\r\n");
wifi_set_sleep_type(MODEM_SLEEP_T);
light_sleep_flg =0;
}
}
light_set_aim(r,g,b,cw,ww,period);
return 0;
}
LOCAL struct jsontree_callback light_callback =
JSONTREE_CALLBACK(light_status_get, light_status_set);
JSONTREE_OBJECT(rgb_tree,
JSONTREE_PAIR("red", &light_callback),
JSONTREE_PAIR("green", &light_callback),
JSONTREE_PAIR("blue", &light_callback),
JSONTREE_PAIR("cwhite", &light_callback),
JSONTREE_PAIR("wwhite", &light_callback),
);
JSONTREE_OBJECT(sta_tree,
JSONTREE_PAIR("period", &light_callback),
JSONTREE_PAIR("rgb", &rgb_tree));
JSONTREE_OBJECT(PwmTree,
JSONTREE_PAIR("light", &sta_tree));
#endif
/******************************************************************************
* FunctionName : wifi_station_get
* Description : set up the station paramer as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
wifi_station_get(struct jsontree_context *js_ctx)
{
const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);
struct ip_info ipconfig;
uint8 buf[20];
os_bzero(buf, sizeof(buf));
wifi_station_get_config(sta_conf);
wifi_get_ip_info(STATION_IF, &ipconfig);
if (os_strncmp(path, "ssid", 4) == 0) {
jsontree_write_string(js_ctx, sta_conf->ssid);
} else if (os_strncmp(path, "password", 8) == 0) {
jsontree_write_string(js_ctx, sta_conf->password);
} else if (os_strncmp(path, "ip", 2) == 0) {
os_sprintf(buf, IPSTR, IP2STR(&ipconfig.ip));
jsontree_write_string(js_ctx, buf);
} else if (os_strncmp(path, "mask", 4) == 0) {
os_sprintf(buf, IPSTR, IP2STR(&ipconfig.netmask));
jsontree_write_string(js_ctx, buf);
} else if (os_strncmp(path, "gw", 2) == 0) {
os_sprintf(buf, IPSTR, IP2STR(&ipconfig.gw));
jsontree_write_string(js_ctx, buf);
}
return 0;
}
/******************************************************************************
* FunctionName : wifi_station_set
* Description : parse the station parmer as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* parser -- A pointer to a JSON parser state
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
wifi_station_set(struct jsontree_context *js_ctx, struct jsonparse_state *parser)
{
int type;
uint8 station_tree;
while ((type = jsonparse_next(parser)) != 0) {
if (type == JSON_TYPE_PAIR_NAME) {
char buffer[64];
os_bzero(buffer, 64);
if (jsonparse_strcmp_value(parser, "Station") == 0) {
station_tree = 1;
} else if (jsonparse_strcmp_value(parser, "Softap") == 0) {
station_tree = 0;
}
if (station_tree) {
if (jsonparse_strcmp_value(parser, "ssid") == 0) {
jsonparse_next(parser);
jsonparse_next(parser);
jsonparse_copy_value(parser, buffer, sizeof(buffer));
os_memcpy(sta_conf->ssid, buffer, os_strlen(buffer));
} else if (jsonparse_strcmp_value(parser, "password") == 0) {
jsonparse_next(parser);
jsonparse_next(parser);
jsonparse_copy_value(parser, buffer, sizeof(buffer));
os_memcpy(sta_conf->password, buffer, os_strlen(buffer));
}
#if ESP_PLATFORM
else if (jsonparse_strcmp_value(parser, "token") == 0) {
jsonparse_next(parser);
jsonparse_next(parser);
jsonparse_copy_value(parser, buffer, sizeof(buffer));
user_esp_platform_set_token(buffer);
}
#endif
}
}
}
return 0;
}
LOCAL struct jsontree_callback wifi_station_callback =
JSONTREE_CALLBACK(wifi_station_get, wifi_station_set);
JSONTREE_OBJECT(get_station_config_tree,
JSONTREE_PAIR("ssid", &wifi_station_callback),
JSONTREE_PAIR("password", &wifi_station_callback));
JSONTREE_OBJECT(set_station_config_tree,
JSONTREE_PAIR("ssid", &wifi_station_callback),
JSONTREE_PAIR("password", &wifi_station_callback),
JSONTREE_PAIR("token", &wifi_station_callback));
JSONTREE_OBJECT(ip_tree,
JSONTREE_PAIR("ip", &wifi_station_callback),
JSONTREE_PAIR("mask", &wifi_station_callback),
JSONTREE_PAIR("gw", &wifi_station_callback));
JSONTREE_OBJECT(get_station_tree,
JSONTREE_PAIR("Connect_Station", &get_station_config_tree),
JSONTREE_PAIR("Ipinfo_Station", &ip_tree));
JSONTREE_OBJECT(set_station_tree,
JSONTREE_PAIR("Connect_Station", &set_station_config_tree));
//JSONTREE_OBJECT(get_wifi_station_info_tree,
// JSONTREE_PAIR("Station", &get_station_tree));
//JSONTREE_OBJECT(set_wifi_station_info_tree,
// JSONTREE_PAIR("station", &set_station_tree));
/******************************************************************************
* FunctionName : wifi_softap_get
* Description : set up the softap paramer as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
wifi_softap_get(struct jsontree_context *js_ctx)
{
const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);
struct ip_info ipconfig;
uint8 buf[20];
os_bzero(buf, sizeof(buf));
wifi_softap_get_config(ap_conf);
wifi_get_ip_info(SOFTAP_IF, &ipconfig);
if (os_strncmp(path, "ssid", 4) == 0) {
jsontree_write_string(js_ctx, ap_conf->ssid);
} else if (os_strncmp(path, "password", 8) == 0) {
jsontree_write_string(js_ctx, ap_conf->password);
} else if (os_strncmp(path, "channel", 7) == 0) {
jsontree_write_int(js_ctx, ap_conf->channel);
} else if (os_strncmp(path, "authmode", 8) == 0) {
switch (ap_conf->authmode) {
case AUTH_OPEN:
jsontree_write_string(js_ctx, "OPEN");
break;
case AUTH_WEP:
jsontree_write_string(js_ctx, "WEP");
break;
case AUTH_WPA_PSK:
jsontree_write_string(js_ctx, "WPAPSK");
break;
case AUTH_WPA2_PSK:
jsontree_write_string(js_ctx, "WPA2PSK");
break;
case AUTH_WPA_WPA2_PSK:
jsontree_write_string(js_ctx, "WPAPSK/WPA2PSK");
break;
default :
jsontree_write_int(js_ctx, ap_conf->authmode);
break;
}
} else if (os_strncmp(path, "ip", 2) == 0) {
os_sprintf(buf, IPSTR, IP2STR(&ipconfig.ip));
jsontree_write_string(js_ctx, buf);
} else if (os_strncmp(path, "mask", 4) == 0) {
os_sprintf(buf, IPSTR, IP2STR(&ipconfig.netmask));
jsontree_write_string(js_ctx, buf);
} else if (os_strncmp(path, "gw", 2) == 0) {
os_sprintf(buf, IPSTR, IP2STR(&ipconfig.gw));
jsontree_write_string(js_ctx, buf);
}
return 0;
}
/******************************************************************************
* FunctionName : wifi_softap_set
* Description : parse the softap parmer as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* parser -- A pointer to a JSON parser state
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
wifi_softap_set(struct jsontree_context *js_ctx, struct jsonparse_state *parser)
{
int type;
uint8 softap_tree;
while ((type = jsonparse_next(parser)) != 0) {
if (type == JSON_TYPE_PAIR_NAME) {
char buffer[64];
os_bzero(buffer, 64);
if (jsonparse_strcmp_value(parser, "Station") == 0) {
softap_tree = 0;
} else if (jsonparse_strcmp_value(parser, "Softap") == 0) {
softap_tree = 1;
}
if (softap_tree) {
if (jsonparse_strcmp_value(parser, "authmode") == 0) {
jsonparse_next(parser);
jsonparse_next(parser);
jsonparse_copy_value(parser, buffer, sizeof(buffer));
// other mode will be supported later...
if (os_strcmp(buffer, "OPEN") == 0) {
ap_conf->authmode = AUTH_OPEN;
} else if (os_strcmp(buffer, "WPAPSK") == 0) {
ap_conf->authmode = AUTH_WPA_PSK;
os_printf("%d %s\n", ap_conf->authmode, buffer);
} else if (os_strcmp(buffer, "WPA2PSK") == 0) {
ap_conf->authmode = AUTH_WPA2_PSK;
} else if (os_strcmp(buffer, "WPAPSK/WPA2PSK") == 0) {
ap_conf->authmode = AUTH_WPA_WPA2_PSK;
} else {
ap_conf->authmode = AUTH_OPEN;
return 0;
}
}
if (jsonparse_strcmp_value(parser, "channel") == 0) {
jsonparse_next(parser);
jsonparse_next(parser);
ap_conf->channel = jsonparse_get_value_as_int(parser);
} else if (jsonparse_strcmp_value(parser, "ssid") == 0) {
jsonparse_next(parser);
jsonparse_next(parser);
jsonparse_copy_value(parser, buffer, sizeof(buffer));
os_memcpy(ap_conf->ssid, buffer, os_strlen(buffer));
} else if (jsonparse_strcmp_value(parser, "password") == 0) {
jsonparse_next(parser);
jsonparse_next(parser);
jsonparse_copy_value(parser, buffer, sizeof(buffer));
os_memcpy(ap_conf->password, buffer, os_strlen(buffer));
}
}
}
}
return 0;
}
LOCAL struct jsontree_callback wifi_softap_callback =
JSONTREE_CALLBACK(wifi_softap_get, wifi_softap_set);
JSONTREE_OBJECT(softap_config_tree,
JSONTREE_PAIR("authmode", &wifi_softap_callback),
JSONTREE_PAIR("channel", &wifi_softap_callback),
JSONTREE_PAIR("ssid", &wifi_softap_callback),
JSONTREE_PAIR("password", &wifi_softap_callback));
JSONTREE_OBJECT(softap_ip_tree,
JSONTREE_PAIR("ip", &wifi_softap_callback),
JSONTREE_PAIR("mask", &wifi_softap_callback),
JSONTREE_PAIR("gw", &wifi_softap_callback));
JSONTREE_OBJECT(get_softap_tree,
JSONTREE_PAIR("Connect_Softap", &softap_config_tree),
JSONTREE_PAIR("Ipinfo_Softap", &softap_ip_tree));
JSONTREE_OBJECT(set_softap_tree,
JSONTREE_PAIR("Ipinfo_Softap", &softap_config_tree));
JSONTREE_OBJECT(get_wifi_tree,
JSONTREE_PAIR("Station", &get_station_tree),
JSONTREE_PAIR("Softap", &get_softap_tree));
JSONTREE_OBJECT(set_wifi_tree,
JSONTREE_PAIR("Station", &set_station_tree),
JSONTREE_PAIR("Softap", &set_softap_tree));
JSONTREE_OBJECT(wifi_response_tree,
JSONTREE_PAIR("Response", &get_wifi_tree));
JSONTREE_OBJECT(wifi_request_tree,
JSONTREE_PAIR("Request", &set_wifi_tree));
JSONTREE_OBJECT(wifi_info_tree,
JSONTREE_PAIR("wifi", &wifi_response_tree));
JSONTREE_OBJECT(wifi_req_tree,
JSONTREE_PAIR("wifi", &wifi_request_tree));
/******************************************************************************
* FunctionName : scan_get
* Description : set up the scan data as a JSON format
* Parameters : js_ctx -- A pointer to a JSON set up
* Returns : result
*******************************************************************************/
LOCAL int ICACHE_FLASH_ATTR
scan_get(struct jsontree_context *js_ctx)
{
const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);
// STAILQ_HEAD(, bss_info) *pbss = scanarg;
// LOCAL struct bss_info *bss;
if (os_strncmp(path, "TotalPage", 9) == 0) {
jsontree_write_int(js_ctx, pscaninfo->totalpage);
} else if (os_strncmp(path, "PageNum", 7) == 0) {
jsontree_write_int(js_ctx, pscaninfo->pagenum);
} else if (os_strncmp(path, "bssid", 5) == 0) {
if( bss == NULL )
bss = bss_head;
u8 buffer[32];
//if (bss != NULL){
os_memset(buffer, 0, sizeof(buffer));
os_sprintf(buffer, MACSTR, MAC2STR(bss->bssid));
jsontree_write_string(js_ctx, buffer);
//}
} else if (os_strncmp(path, "ssid", 4) == 0) {
//if (bss != NULL)
jsontree_write_string(js_ctx, bss->ssid);
} else if (os_strncmp(path, "rssi", 4) == 0) {
//if (bss != NULL)
jsontree_write_int(js_ctx, -(bss->rssi));
} else if (os_strncmp(path, "channel", 7) == 0) {
//if (bss != NULL)
jsontree_write_int(js_ctx, bss->channel);
} else if (os_strncmp(path, "authmode", 8) == 0) {
//if (bss != NULL){
switch (bss->authmode) {
case AUTH_OPEN:
jsontree_write_string(js_ctx, "OPEN");
break;
case AUTH_WEP:
jsontree_write_string(js_ctx, "WEP");
break;
case AUTH_WPA_PSK:
jsontree_write_string(js_ctx, "WPAPSK");
break;
case AUTH_WPA2_PSK:
jsontree_write_string(js_ctx, "WPA2PSK");
break;
case AUTH_WPA_WPA2_PSK:
jsontree_write_string(js_ctx, "WPAPSK/WPA2PSK");
break;
default :
jsontree_write_int(js_ctx, bss->authmode);
break;
}
bss = STAILQ_NEXT(bss, next);
// os_free(bss);
//}
}
return 0;
}
LOCAL struct jsontree_callback scan_callback =
JSONTREE_CALLBACK(scan_get, NULL);
JSONTREE_OBJECT(scaninfo_tree,
JSONTREE_PAIR("bssid", &scan_callback),
JSONTREE_PAIR("ssid", &scan_callback),
JSONTREE_PAIR("rssi", &scan_callback),
JSONTREE_PAIR("channel", &scan_callback),
JSONTREE_PAIR("authmode", &scan_callback));
JSONTREE_ARRAY(scanrslt_tree,
JSONTREE_PAIR_ARRAY(&scaninfo_tree),
JSONTREE_PAIR_ARRAY(&scaninfo_tree),
JSONTREE_PAIR_ARRAY(&scaninfo_tree),
JSONTREE_PAIR_ARRAY(&scaninfo_tree),
JSONTREE_PAIR_ARRAY(&scaninfo_tree),
JSONTREE_PAIR_ARRAY(&scaninfo_tree),
JSONTREE_PAIR_ARRAY(&scaninfo_tree),
JSONTREE_PAIR_ARRAY(&scaninfo_tree));
JSONTREE_OBJECT(scantree,
JSONTREE_PAIR("TotalPage", &scan_callback),
JSONTREE_PAIR("PageNum", &scan_callback),
JSONTREE_PAIR("ScanResult", &scanrslt_tree));
JSONTREE_OBJECT(scanres_tree,
JSONTREE_PAIR("Response", &scantree));
JSONTREE_OBJECT(scan_tree,
JSONTREE_PAIR("scan", &scanres_tree));
/******************************************************************************
* FunctionName : parse_url
* Description : parse the received data from the server
* Parameters : precv -- the received data
* purl_frame -- the result of parsing the url
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
parse_url(char *precv, URL_Frame *purl_frame)
{
char *str = NULL;
uint8 length = 0;
char *pbuffer = NULL;
char *pbufer = NULL;
if (purl_frame == NULL || precv == NULL) {
return;
}
pbuffer = (char *)os_strstr(precv, "Host:");
if (pbuffer != NULL) {
length = pbuffer - precv;
pbufer = (char *)os_zalloc(length + 1);
pbuffer = pbufer;
os_memcpy(pbuffer, precv, length);
os_memset(purl_frame->pSelect, 0, URLSize);
os_memset(purl_frame->pCommand, 0, URLSize);
os_memset(purl_frame->pFilename, 0, URLSize);
if (os_strncmp(pbuffer, "GET ", 4) == 0) {
purl_frame->Type = GET;
pbuffer += 4;
} else if (os_strncmp(pbuffer, "POST ", 5) == 0) {
purl_frame->Type = POST;
pbuffer += 5;
}
pbuffer ++;
str = (char *)os_strstr(pbuffer, "?");
if (str != NULL) {
length = str - pbuffer;
os_memcpy(purl_frame->pSelect, pbuffer, length);
str ++;
pbuffer = (char *)os_strstr(str, "=");
if (pbuffer != NULL) {
length = pbuffer - str;
os_memcpy(purl_frame->pCommand, str, length);
pbuffer ++;
str = (char *)os_strstr(pbuffer, "&");
if (str != NULL) {
length = str - pbuffer;
os_memcpy(purl_frame->pFilename, pbuffer, length);
} else {
str = (char *)os_strstr(pbuffer, " HTTP");
if (str != NULL) {
length = str - pbuffer;
os_memcpy(purl_frame->pFilename, pbuffer, length);
}
}
}
}
os_free(pbufer);
} else {
return;
}
}
LOCAL char *precvbuffer;
static uint32 dat_sumlength = 0;
LOCAL bool ICACHE_FLASH_ATTR
save_data(char *precv, uint16 length)
{
bool flag = false;
char length_buf[10] = {0};
char *ptemp = NULL;
char *pdata = NULL;
uint16 headlength = 0;
static uint32 totallength = 0;
ptemp = (char *)os_strstr(precv, "\r\n\r\n");
if (ptemp != NULL) {
length -= ptemp - precv;
length -= 4;
totallength += length;
headlength = ptemp - precv + 4;
pdata = (char *)os_strstr(precv, "Content-Length: ");
if (pdata != NULL) {
pdata += 16;
precvbuffer = (char *)os_strstr(pdata, "\r\n");
if (precvbuffer != NULL) {
os_memcpy(length_buf, pdata, precvbuffer - pdata);
dat_sumlength = atoi(length_buf);
}
} else {
if (totallength != 0x00){
totallength = 0;
dat_sumlength = 0;
return false;
}
}
if ((dat_sumlength + headlength) >= 1024) {
precvbuffer = (char *)os_zalloc(headlength + 1);
os_memcpy(precvbuffer, precv, headlength + 1);
} else {
precvbuffer = (char *)os_zalloc(dat_sumlength + headlength + 1);
os_memcpy(precvbuffer, precv, os_strlen(precv));
}
} else {
if (precvbuffer != NULL) {
totallength += length;
os_memcpy(precvbuffer + os_strlen(precvbuffer), precv, length);
} else {
totallength = 0;
dat_sumlength = 0;
return false;
}
}
if (totallength == dat_sumlength) {
totallength = 0;
dat_sumlength = 0;
return true;
} else {
return false;
}
}
LOCAL bool ICACHE_FLASH_ATTR
check_data(char *precv, uint16 length)
{
//bool flag = true;
char length_buf[10] = {0};
char *ptemp = NULL;
char *pdata = NULL;
char *tmp_precvbuffer;
uint16 tmp_length = length;
uint32 tmp_totallength = 0;
ptemp = (char *)os_strstr(precv, "\r\n\r\n");
if (ptemp != NULL) {
tmp_length -= ptemp - precv;
tmp_length -= 4;
tmp_totallength += tmp_length;
pdata = (char *)os_strstr(precv, "Content-Length: ");
if (pdata != NULL){
pdata += 16;
tmp_precvbuffer = (char *)os_strstr(pdata, "\r\n");
if (tmp_precvbuffer != NULL){
os_memcpy(length_buf, pdata, tmp_precvbuffer - pdata);
dat_sumlength = atoi(length_buf);
os_printf("A_dat:%u,tot:%u,lenght:%u\n",dat_sumlength,tmp_totallength,tmp_length);
if(dat_sumlength != tmp_totallength){
return false;
}
}
}
}
return true;
}
LOCAL os_timer_t *restart_10ms;
LOCAL rst_parm *rstparm;
/******************************************************************************
* FunctionName : restart_10ms_cb
* Description : system restart or wifi reconnected after a certain time.
* Parameters : arg -- Additional argument to pass to the function
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
restart_10ms_cb(void *arg)
{
if (rstparm != NULL && rstparm->pespconn != NULL) {
switch (rstparm->parmtype) {
case WIFI:
//if (rstparm->pespconn->state == ESPCONN_CLOSE) {
if (sta_conf->ssid[0] != 0x00) {
wifi_station_set_config(sta_conf);
wifi_station_disconnect();
wifi_station_connect();
user_esp_platform_check_ip(1);
}
if (ap_conf->ssid[0] != 0x00) {
wifi_softap_set_config(ap_conf);
system_restart();
}
os_free(ap_conf);
ap_conf = NULL;
os_free(sta_conf);
sta_conf = NULL;
os_free(rstparm);
rstparm = NULL;
os_free(restart_10ms);
restart_10ms = NULL;
//} else {
// os_timer_arm(restart_10ms, 10, 0);
//}
break;
case DEEP_SLEEP:
case REBOOT:
if (rstparm->pespconn->state == ESPCONN_CLOSE) {
wifi_set_opmode(STATION_MODE);
if (rstparm->parmtype == DEEP_SLEEP) {
#if SENSOR_DEVICE
system_deep_sleep(SENSOR_DEEP_SLEEP_TIME);
#endif
}
} else {
os_timer_arm(restart_10ms, 10, 0);
}
break;
default:
break;
}
}
}
/******************************************************************************
* FunctionName : data_send
* Description : processing the data as http format and send to the client or server
* Parameters : arg -- argument to set for client or server
* responseOK -- true or false
* psend -- The send data
* Returns :
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
data_send(void *arg, bool responseOK, char *psend)
{
uint16 length = 0;
char *pbuf = NULL;
char httphead[256];
struct espconn *ptrespconn = arg;
os_memset(httphead, 0, 256);
if (responseOK) {
os_sprintf(httphead,
"HTTP/1.0 200 OK\r\nContent-Length: %d\r\nServer: lwIP/1.4.0\r\n",
psend ? os_strlen(psend) : 0);
if (psend) {
os_sprintf(httphead + os_strlen(httphead),
"Content-type: application/json\r\nExpires: Fri, 10 Apr 2008 14:00:00 GMT\r\nPragma: no-cache\r\n\r\n");
length = os_strlen(httphead) + os_strlen(psend);
pbuf = (char *)os_zalloc(length + 1);
os_memcpy(pbuf, httphead, os_strlen(httphead));
os_memcpy(pbuf + os_strlen(httphead), psend, os_strlen(psend));
} else {
os_sprintf(httphead + os_strlen(httphead), "\n");
length = os_strlen(httphead);
}
} else {
os_sprintf(httphead, "HTTP/1.0 400 BadRequest\r\n\
Content-Length: 0\r\nServer: lwIP/1.4.0\r\n\n");
length = os_strlen(httphead);
}
if (psend) {
#ifdef SERVER_SSL_ENABLE
espconn_secure_sent(ptrespconn, pbuf, length);
#else
espconn_sent(ptrespconn, pbuf, length);
#endif
} else {
#ifdef SERVER_SSL_ENABLE
espconn_secure_sent(ptrespconn, httphead, length);
#else
espconn_sent(ptrespconn, httphead, length);
#endif
}
if (pbuf) {
os_free(pbuf);
pbuf = NULL;
}
}
/******************************************************************************
* FunctionName : json_send
* Description : processing the data as json format and send to the client or server
* Parameters : arg -- argument to set for client or server
* ParmType -- json format type
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
json_send(void *arg, ParmType ParmType)
{
char *pbuf = NULL;
pbuf = (char *)os_zalloc(jsonSize);
struct espconn *ptrespconn = arg;
switch (ParmType) {
#if LIGHT_DEVICE
case LIGHT_STATUS:
json_ws_send((struct jsontree_value *)&PwmTree, "light", pbuf);
break;
#endif
#if PLUG_DEVICE
case SWITCH_STATUS:
json_ws_send((struct jsontree_value *)&StatusTree, "switch", pbuf);
break;
#endif
case INFOMATION:
json_ws_send((struct jsontree_value *)&INFOTree, "info", pbuf);
break;
case WIFI:
json_ws_send((struct jsontree_value *)&wifi_info_tree, "wifi", pbuf);
break;
case CONNECT_STATUS:
json_ws_send((struct jsontree_value *)&con_status_tree, "info", pbuf);
break;
case USER_BIN:
json_ws_send((struct jsontree_value *)&userinfo_tree, "user_info", pbuf);
break;
case SCAN: {
u8 i = 0;
u8 scancount = 0;
struct bss_info *bss = NULL;
// bss = STAILQ_FIRST(pscaninfo->pbss);
bss = bss_head;
if (bss == NULL) {
os_free(pscaninfo);
pscaninfo = NULL;
os_sprintf(pbuf, "{\n\"successful\": false,\n\"data\": null\n}");
} else {
do {
if (pscaninfo->page_sn == pscaninfo->pagenum) {
pscaninfo->page_sn = 0;
os_sprintf(pbuf, "{\n\"successful\": false,\n\"meessage\": \"repeated page\"\n}");
break;
}
scancount = scannum - (pscaninfo->pagenum - 1) * 8;
if (scancount >= 8) {
pscaninfo->data_cnt += 8;
pscaninfo->page_sn = pscaninfo->pagenum;
if (pscaninfo->data_cnt > scannum) {
pscaninfo->data_cnt -= 8;
os_sprintf(pbuf, "{\n\"successful\": false,\n\"meessage\": \"error page\"\n}");
break;
}
json_ws_send((struct jsontree_value *)&scan_tree, "scan", pbuf);
} else {
pscaninfo->data_cnt += scancount;
pscaninfo->page_sn = pscaninfo->pagenum;
if (pscaninfo->data_cnt > scannum) {
pscaninfo->data_cnt -= scancount;
os_sprintf(pbuf, "{\n\"successful\": false,\n\"meessage\": \"error page\"\n}");
break;
}
char *ptrscanbuf = (char *)os_zalloc(jsonSize);
char *pscanbuf = ptrscanbuf;
os_sprintf(pscanbuf, ",\n\"ScanResult\": [\n");
pscanbuf += os_strlen(pscanbuf);
for (i = 0; i < scancount; i ++) {
JSONTREE_OBJECT(page_tree,
JSONTREE_PAIR("page", &scaninfo_tree));
json_ws_send((struct jsontree_value *)&page_tree, "page", pscanbuf);
os_sprintf(pscanbuf + os_strlen(pscanbuf), ",\n");
pscanbuf += os_strlen(pscanbuf);
}
os_sprintf(pscanbuf - 2, "]\n");
JSONTREE_OBJECT(scantree,
JSONTREE_PAIR("TotalPage", &scan_callback),
JSONTREE_PAIR("PageNum", &scan_callback));
JSONTREE_OBJECT(scanres_tree,
JSONTREE_PAIR("Response", &scantree));
JSONTREE_OBJECT(scan_tree,
JSONTREE_PAIR("scan", &scanres_tree));
json_ws_send((struct jsontree_value *)&scan_tree, "scan", pbuf);
os_memcpy(pbuf + os_strlen(pbuf) - 4, ptrscanbuf, os_strlen(ptrscanbuf));
os_sprintf(pbuf + os_strlen(pbuf), "}\n}");
os_free(ptrscanbuf);
}
} while (0);
}
break;
}
default :
break;
}
data_send(ptrespconn, true, pbuf);
os_free(pbuf);
pbuf = NULL;
}
/******************************************************************************
* FunctionName : response_send
* Description : processing the send result
* Parameters : arg -- argument to set for client or server
* responseOK -- true or false
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
response_send(void *arg, bool responseOK)
{
struct espconn *ptrespconn = arg;
data_send(ptrespconn, responseOK, NULL);
}
/******************************************************************************
* FunctionName : json_scan_cb
* Description : processing the scan result
* Parameters : arg -- Additional argument to pass to the callback function
* status -- scan status
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR json_scan_cb(void *arg, STATUS status)
{
pscaninfo->pbss = arg;
if (scannum % 8 == 0) {
pscaninfo->totalpage = scannum / 8;
} else {
pscaninfo->totalpage = scannum / 8 + 1;
}
JSONTREE_OBJECT(totaltree,
JSONTREE_PAIR("TotalPage", &scan_callback));
JSONTREE_OBJECT(totalres_tree,
JSONTREE_PAIR("Response", &totaltree));
JSONTREE_OBJECT(total_tree,
JSONTREE_PAIR("total", &totalres_tree));
bss_temp = bss_head;
while(bss_temp !=NULL) {
bss_head = bss_temp->next.stqe_next;
os_free(bss_temp);
bss_temp = bss_head;
}
bss_head = NULL;
bss_temp = NULL;
bss = STAILQ_FIRST(pscaninfo->pbss);
while(bss != NULL) {
if(bss_temp == NULL){
bss_temp = (struct bss_info *)os_zalloc(sizeof(struct bss_info));
bss_head = bss_temp;
} else {
bss_temp->next.stqe_next = (struct bss_info *)os_zalloc(sizeof(struct bss_info));
bss_temp = bss_temp->next.stqe_next;
}
if(bss_temp == NULL) {
os_printf("malloc scan info failed\n");
break;
} else{
os_memcpy(bss_temp->bssid,bss->bssid,sizeof(bss->bssid));
os_memcpy(bss_temp->ssid,bss->ssid,sizeof(bss->ssid));
bss_temp->authmode = bss->authmode;
bss_temp->rssi = bss->rssi;
bss_temp->channel = bss->channel;
}
bss = STAILQ_NEXT(bss,next);
}
char *pbuf = NULL;
pbuf = (char *)os_zalloc(jsonSize);
json_ws_send((struct jsontree_value *)&total_tree, "total", pbuf);
data_send(pscaninfo->pespconn, true, pbuf);
os_free(pbuf);
}
void ICACHE_FLASH_ATTR
upgrade_check_func(void *arg)
{
struct espconn *ptrespconn = arg;
os_timer_disarm(&upgrade_check_timer);
if(system_upgrade_flag_check() == UPGRADE_FLAG_START) {
response_send(ptrespconn, false);
system_upgrade_deinit();
system_upgrade_flag_set(UPGRADE_FLAG_IDLE);
upgrade_lock = 0;
os_printf("local upgrade failed\n");
} else if( system_upgrade_flag_check() == UPGRADE_FLAG_FINISH ) {
os_printf("local upgrade success\n");
response_send(ptrespconn, true);
upgrade_lock = 0;
} else {
}
}
/******************************************************************************
* FunctionName : upgrade_deinit
* Description : disconnect the connection with the host
* Parameters : bin -- server number
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
LOCAL local_upgrade_deinit(void)
{
if (system_upgrade_flag_check() != UPGRADE_FLAG_START) {
os_printf("system upgrade deinit\n");
system_upgrade_deinit();
}
}
/******************************************************************************
* FunctionName : upgrade_download
* Description : Processing the upgrade data from the host
* Parameters : bin -- server number
* pusrdata -- The upgrade data (or NULL when the connection has been closed!)
* length -- The length of upgrade data
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
local_upgrade_download(void * arg,char *pusrdata, unsigned short length)
{
char *ptr = NULL;
char *ptmp2 = NULL;
char lengthbuffer[32];
static uint32 totallength = 0;
static uint32 sumlength = 0;
static uint32 erase_length = 0;
char A_buf[2] = {0xE9 ,0x03}; char B_buf[2] = {0xEA,0x04};
struct espconn *pespconn = arg;
if (totallength == 0 && (ptr = (char *)os_strstr(pusrdata, "\r\n\r\n")) != NULL &&
(ptr = (char *)os_strstr(pusrdata, "Content-Length")) != NULL) {
ptr = (char *)os_strstr(pusrdata, "Content-Length: ");
if (ptr != NULL) {
ptr += 16;
ptmp2 = (char *)os_strstr(ptr, "\r\n");
if (ptmp2 != NULL) {
os_memset(lengthbuffer, 0, sizeof(lengthbuffer));
os_memcpy(lengthbuffer, ptr, ptmp2 - ptr);
sumlength = atoi(lengthbuffer);
if (sumlength == 0) {
os_timer_disarm(&upgrade_check_timer);
os_timer_setfn(&upgrade_check_timer, (os_timer_func_t *)upgrade_check_func, pespconn);
os_timer_arm(&upgrade_check_timer, 10, 0);
return;
}
} else {
os_printf("sumlength failed\n");
}
} else {
os_printf("Content-Length: failed\n");
}
if (sumlength != 0) {
if (sumlength >= LIMIT_ERASE_SIZE){
system_upgrade_erase_flash(0xFFFF);
erase_length = sumlength - LIMIT_ERASE_SIZE;
} else {
system_upgrade_erase_flash(sumlength);
erase_length = 0;
}
}
ptr = (char *)os_strstr(pusrdata, "\r\n\r\n");
length -= ptr - pusrdata;
length -= 4;
totallength += length;
os_printf("upgrade file download start.\n");
system_upgrade(ptr + 4, length);
} else {
totallength += length;
if (erase_length >= LIMIT_ERASE_SIZE){
system_upgrade_erase_flash(0xFFFF);
erase_length -= LIMIT_ERASE_SIZE;
} else {
system_upgrade_erase_flash(erase_length);
erase_length = 0;
}
system_upgrade(pusrdata, length);
}
if (totallength == sumlength) {
os_printf("upgrade file download finished.\n");
system_upgrade_flag_set(UPGRADE_FLAG_FINISH);
totallength = 0;
sumlength = 0;
upgrade_check_func(pespconn);
os_timer_disarm(&app_upgrade_10s);
os_timer_setfn(&app_upgrade_10s, (os_timer_func_t *)local_upgrade_deinit, NULL);
os_timer_arm(&app_upgrade_10s, 10, 0);
}
}
/******************************************************************************
* FunctionName : webserver_recv
* Description : Processing the received data from the server
* 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
webserver_recv(void *arg, char *pusrdata, unsigned short length)
{
URL_Frame *pURL_Frame = NULL;
char *pParseBuffer = NULL;
bool parse_flag = false;
struct espconn *ptrespconn = arg;
if(upgrade_lock == 0){
os_printf("len:%u\n",length);
if(check_data(pusrdata, length) == false)
{
os_printf("goto\n");
goto _temp_exit;
}
parse_flag = save_data(pusrdata, length);
if (parse_flag == false) {
response_send(ptrespconn, false);
}
// os_printf(precvbuffer);
pURL_Frame = (URL_Frame *)os_zalloc(sizeof(URL_Frame));
parse_url(precvbuffer, pURL_Frame);
switch (pURL_Frame->Type) {
case GET:
os_printf("We have a GET request.\n");
if (os_strcmp(pURL_Frame->pSelect, "client") == 0 &&
os_strcmp(pURL_Frame->pCommand, "command") == 0) {
if (os_strcmp(pURL_Frame->pFilename, "info") == 0) {
json_send(ptrespconn, INFOMATION);
}
if (os_strcmp(pURL_Frame->pFilename, "status") == 0) {
json_send(ptrespconn, CONNECT_STATUS);
} else if (os_strcmp(pURL_Frame->pFilename, "scan") == 0) {
char *strstr = NULL;
strstr = (char *)os_strstr(pusrdata, "&");
if (strstr == NULL) {
if (pscaninfo == NULL) {
pscaninfo = (scaninfo *)os_zalloc(sizeof(scaninfo));
}
pscaninfo->pespconn = ptrespconn;
pscaninfo->pagenum = 0;
pscaninfo->page_sn = 0;
pscaninfo->data_cnt = 0;
wifi_station_scan(NULL, json_scan_cb);
} else {
strstr ++;
if (os_strncmp(strstr, "page", 4) == 0) {
if (pscaninfo != NULL) {
pscaninfo->pagenum = *(strstr + 5);
pscaninfo->pagenum -= 0x30;
if (pscaninfo->pagenum > pscaninfo->totalpage || pscaninfo->pagenum == 0) {
response_send(ptrespconn, false);
} else {
json_send(ptrespconn, SCAN);
}
} else {
response_send(ptrespconn, false);
}
} else if(os_strncmp(strstr, "finish", 6) == 0){
bss_temp = bss_head;
while(bss_temp != NULL) {
bss_head = bss_temp->next.stqe_next;
os_free(bss_temp);
bss_temp = bss_head;
}
bss_head = NULL;
bss_temp = NULL;
response_send(ptrespconn, true);
} else {
response_send(ptrespconn, false);
}
}
} else {
response_send(ptrespconn, false);
}
} else if (os_strcmp(pURL_Frame->pSelect, "config") == 0 &&
os_strcmp(pURL_Frame->pCommand, "command") == 0) {
if (os_strcmp(pURL_Frame->pFilename, "wifi") == 0) {
ap_conf = (struct softap_config *)os_zalloc(sizeof(struct softap_config));
sta_conf = (struct station_config *)os_zalloc(sizeof(struct station_config));
json_send(ptrespconn, WIFI);
os_free(sta_conf);
os_free(ap_conf);
sta_conf = NULL;
ap_conf = NULL;
}
#if PLUG_DEVICE
else if (os_strcmp(pURL_Frame->pFilename, "switch") == 0) {
json_send(ptrespconn, SWITCH_STATUS);
}
#endif
#if LIGHT_DEVICE
else if (os_strcmp(pURL_Frame->pFilename, "light") == 0) {
json_send(ptrespconn, LIGHT_STATUS);
}
#endif
else if (os_strcmp(pURL_Frame->pFilename, "reboot") == 0) {
json_send(ptrespconn, REBOOT);
} else {
response_send(ptrespconn, false);
}
} else if (os_strcmp(pURL_Frame->pSelect, "upgrade") == 0 &&
os_strcmp(pURL_Frame->pCommand, "command") == 0) {
if (os_strcmp(pURL_Frame->pFilename, "getuser") == 0) {
json_send(ptrespconn , USER_BIN);
}
} else {
response_send(ptrespconn, false);
}
break;
case POST:
os_printf("We have a POST request.\n");
pParseBuffer = (char *)os_strstr(precvbuffer, "\r\n\r\n");
if (pParseBuffer == NULL) {
break;
}
pParseBuffer += 4;
if (os_strcmp(pURL_Frame->pSelect, "config") == 0 &&
os_strcmp(pURL_Frame->pCommand, "command") == 0) {
#if SENSOR_DEVICE
if (os_strcmp(pURL_Frame->pFilename, "sleep") == 0) {
#else
if (os_strcmp(pURL_Frame->pFilename, "reboot") == 0) {
#endif
if (pParseBuffer != NULL) {
if (restart_10ms != NULL) {
os_timer_disarm(restart_10ms);
}
if (rstparm == NULL) {
rstparm = (rst_parm *)os_zalloc(sizeof(rst_parm));
}
rstparm->pespconn = ptrespconn;
#if SENSOR_DEVICE
rstparm->parmtype = DEEP_SLEEP;
#else
rstparm->parmtype = REBOOT;
#endif
if (restart_10ms == NULL) {
restart_10ms = (os_timer_t *)os_malloc(sizeof(os_timer_t));
}
os_timer_setfn(restart_10ms, (os_timer_func_t *)restart_10ms_cb, NULL);
os_timer_arm(restart_10ms, 10, 0); // delay 10ms, then do
response_send(ptrespconn, true);
} else {
response_send(ptrespconn, false);
}
} else if (os_strcmp(pURL_Frame->pFilename, "wifi") == 0) {
if (pParseBuffer != NULL) {
struct jsontree_context js;
user_esp_platform_set_connect_status(DEVICE_CONNECTING);
if (restart_10ms != NULL) {
os_timer_disarm(restart_10ms);
}
if (ap_conf == NULL) {
ap_conf = (struct softap_config *)os_zalloc(sizeof(struct softap_config));
}
if (sta_conf == NULL) {
sta_conf = (struct station_config *)os_zalloc(sizeof(struct station_config));
}
jsontree_setup(&js, (struct jsontree_value *)&wifi_req_tree, json_putchar);
json_parse(&js, pParseBuffer);
if (rstparm == NULL) {
rstparm = (rst_parm *)os_zalloc(sizeof(rst_parm));
}
rstparm->pespconn = ptrespconn;
rstparm->parmtype = WIFI;
if (sta_conf->ssid[0] != 0x00 || ap_conf->ssid[0] != 0x00) {
ap_conf->ssid_hidden = 0;
ap_conf->max_connection = 4;
if (restart_10ms == NULL) {
restart_10ms = (os_timer_t *)os_malloc(sizeof(os_timer_t));
}
os_timer_disarm(restart_10ms);
os_timer_setfn(restart_10ms, (os_timer_func_t *)restart_10ms_cb, NULL);
os_timer_arm(restart_10ms, 10, 0); // delay 10ms, then do
} else {
os_free(ap_conf);
os_free(sta_conf);
os_free(rstparm);
sta_conf = NULL;
ap_conf = NULL;
rstparm =NULL;
}
response_send(ptrespconn, true);
} else {
response_send(ptrespconn, false);
}
}
#if PLUG_DEVICE
else if (os_strcmp(pURL_Frame->pFilename, "switch") == 0) {
if (pParseBuffer != NULL) {
struct jsontree_context js;
jsontree_setup(&js, (struct jsontree_value *)&StatusTree, json_putchar);
json_parse(&js, pParseBuffer);
response_send(ptrespconn, true);
} else {
response_send(ptrespconn, false);
}
}
#endif
#if LIGHT_DEVICE
else if (os_strcmp(pURL_Frame->pFilename, "light") == 0) {
if (pParseBuffer != NULL) {
struct jsontree_context js;
jsontree_setup(&js, (struct jsontree_value *)&PwmTree, json_putchar);
json_parse(&js, pParseBuffer);
os_printf("rsp1:%u\n",PostCmdNeeRsp);
if(PostCmdNeeRsp == 0)
PostCmdNeeRsp = 1;
else
response_send(ptrespconn, true);
} else {
response_send(ptrespconn, false);
}
}
else if (os_strcmp(pURL_Frame->pFilename, "reset") == 0) {
response_send(ptrespconn, true);
extern struct esp_platform_saved_param esp_param;
esp_param.activeflag = 0;
system_param_save_with_protect(ESP_PARAM_START_SEC, &esp_param, sizeof(esp_param));
system_restore();
system_restart();
}
#endif
else {
response_send(ptrespconn, false);
}
}
else if(os_strcmp(pURL_Frame->pSelect, "upgrade") == 0 &&
os_strcmp(pURL_Frame->pCommand, "command") == 0){
if (os_strcmp(pURL_Frame->pFilename, "start") == 0){
response_send(ptrespconn, true);
os_printf("local upgrade start\n");
upgrade_lock = 1;
system_upgrade_init();
system_upgrade_flag_set(UPGRADE_FLAG_START);
os_timer_disarm(&upgrade_check_timer);
os_timer_setfn(&upgrade_check_timer, (os_timer_func_t *)upgrade_check_func, NULL);
os_timer_arm(&upgrade_check_timer, 120000, 0);
} else if (os_strcmp(pURL_Frame->pFilename, "reset") == 0) {
response_send(ptrespconn, true);
os_printf("local upgrade restart\n");
system_upgrade_reboot();
} else {
response_send(ptrespconn, false);
}
}else {
response_send(ptrespconn, false);
}
break;
}
if (precvbuffer != NULL){
os_free(precvbuffer);
precvbuffer = NULL;
}
os_free(pURL_Frame);
pURL_Frame = NULL;
_temp_exit:
;
}
else if(upgrade_lock == 1){
local_upgrade_download(ptrespconn,pusrdata, length);
if (precvbuffer != NULL){
os_free(precvbuffer);
precvbuffer = NULL;
}
os_free(pURL_Frame);
pURL_Frame = NULL;
}
}
/******************************************************************************
* FunctionName : webserver_recon
* Description : the connection has been err, reconnection
* Parameters : arg -- Additional argument to pass to the callback function
* Returns : none
*******************************************************************************/
LOCAL ICACHE_FLASH_ATTR
void webserver_recon(void *arg, sint8 err)
{
struct espconn *pesp_conn = arg;
os_printf("webserver's %d.%d.%d.%d:%d err %d reconnect\n", pesp_conn->proto.tcp->remote_ip[0],
pesp_conn->proto.tcp->remote_ip[1],pesp_conn->proto.tcp->remote_ip[2],
pesp_conn->proto.tcp->remote_ip[3],pesp_conn->proto.tcp->remote_port, err);
}
/******************************************************************************
* FunctionName : webserver_recon
* Description : the connection has been err, reconnection
* Parameters : arg -- Additional argument to pass to the callback function
* Returns : none
*******************************************************************************/
LOCAL ICACHE_FLASH_ATTR
void webserver_discon(void *arg)
{
struct espconn *pesp_conn = arg;
os_printf("webserver's %d.%d.%d.%d:%d disconnect\n", pesp_conn->proto.tcp->remote_ip[0],
pesp_conn->proto.tcp->remote_ip[1],pesp_conn->proto.tcp->remote_ip[2],
pesp_conn->proto.tcp->remote_ip[3],pesp_conn->proto.tcp->remote_port);
}
/******************************************************************************
* FunctionName : user_accept_listen
* Description : server listened a connection successfully
* Parameters : arg -- Additional argument to pass to the callback function
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
webserver_listen(void *arg)
{
struct espconn *pesp_conn = arg;
espconn_regist_recvcb(pesp_conn, webserver_recv);
espconn_regist_reconcb(pesp_conn, webserver_recon);
espconn_regist_disconcb(pesp_conn, webserver_discon);
}
/******************************************************************************
* FunctionName : user_webserver_init
* Description : parameter initialize as a server
* Parameters : port -- server port
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_webserver_init(uint32 port)
{
LOCAL struct espconn esp_conn;
LOCAL esp_tcp esptcp;
esp_conn.type = ESPCONN_TCP;
esp_conn.state = ESPCONN_NONE;
esp_conn.proto.tcp = &esptcp;
esp_conn.proto.tcp->local_port = port;
espconn_regist_connectcb(&esp_conn, webserver_listen);
#ifdef SERVER_SSL_ENABLE
espconn_secure_set_default_certificate(default_certificate, default_certificate_len);
espconn_secure_set_default_private_key(default_private_key, default_private_key_len);
espconn_secure_accept(&esp_conn);
#else
espconn_accept(&esp_conn);
#endif
}
Notice: AT added some functions so it's larger than before, if you want to compile it, please compile it as 1024KB or larger flash in compilation STEP 5.
1compile options
(1) COMPILE
Possible value: gcc
Default value:
If not set, use xt-xcc by default.
(2) BOOT
Possible value: none/old/new
none: no need boot
old: use boot_v1.1
new: use boot_v1.2+
Default value: none
(3) APP
Possible value: 0/1/2
0: original mode, generate eagle.app.v6.flash.bin and eagle.app.v6.irom0text.bin
1: generate user1
2: generate user2
Default value: 0
(3) SPI_SPEED
Possible value: 20/26.7/40/80
Default value: 40
(4) SPI_MODE
Possible value: QIO/QOUT/DIO/DOUT
Default value: QIO
(4) SPI_SIZE
Possible value: 0/2/3/4/5/6
Default value: 0
For example:
make COMPILE=gcc BOOT=new APP=1 SPI_SPEED=40 SPI_MODE=QIO SPI_SIZE_MAP=0
2You can also use gen_misc to make and generate specific bin you needed.
Linux: ./gen_misc.sh
Windows: gen_misc.bat
Follow the tips and steps.
\ No newline at end of file
#############################################################
# 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
ifdef AT_OPEN_SRC
SUBDIRS += \
at
endif
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
ifdef AT_OPEN_SRC
COMPONENTS_eagle.app.v6 += \
at/libat.a
endif
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 \
-lmain \
-ljson \
-lupgrade \
-lsmartconfig \
$(DEP_LIBS_eagle.app.v6)
ifndef AT_OPEN_SRC
LINKFLAGS_eagle.app.v6 += \
-lat
endif
LINKFLAGS_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
ifdef AT_OPEN_SRC
CONFIGURATION_DEFINES += \
-DAT_OPEN_SRC
endif
ifeq ($(APP),0)
else
CONFIGURATION_DEFINES += \
-DAT_UPGRADE_SUPPORT
endif
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:
@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%
#!/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
#ifndef __USER_CONFIG_H__
#define __USER_CONFIG_H__
#define AT_CUSTOM_UPGRADE
#ifdef AT_CUSTOM_UPGRADE
#ifndef AT_UPGRADE_SUPPORT
#error "upgrade is not supported when eagle.flash.bin+eagle.irom0text.bin!!!"
#endif
#endif
#endif
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment