CN104577537A

CN104577537A - 一种基于物联网的智能wifi插座及其控制方法

Info

Publication number: CN104577537A
Application number: CN201410525562.8A
Authority: CN
Inventors: 栾春涛; 唐久奎; 朱俊杰; 王会玖
Original assignee: Gongniu Group Co Ltd
Current assignee: Gongniu Group Co Ltd
Priority date: 2014-10-09
Filing date: 2014-10-09
Publication date: 2015-04-29
Anticipated expiration: 2034-10-09
Also published as: CN104577537B

Abstract

本发明公开了一种基于物联网的智能WIFI插座及其控制方法，包括电源模块、WIFI模块和继电器开关，继电器开关与电源模块相连接，WIFI模块包括控制器，控制器内包括配置功能模块、管理控制模块和本地控制模块，配置功能模块和本地控制模块同时与继电器相连接，本地控制模块同时还与管理控制模块相连接，管理控制模块还通过无线与控制终端相连接。基于物联网的智能WIFI插座能使用户方便的对智能WIFI插座进行控制，且对智能WIFI插座的设备固件能进行不影响正常工作的更新，保证了智能WIFI插座的使用效果。本发明实用性强、易于实现。

Description

一种基于物联网的智能WIFI插座及其控制方法

技术领域

本发明涉及一种插座，尤其是指一种基于物联网的智能WIFI插座及其控制方法。

背景技术

物联网最初在1999年提出：即通过射频识别（RFID）、红外感应器、全球定位系统、激光扫描器、气体感应器等信息传感设备，按约定的协议，把任何物品与互联网连接起来，进行信息交换和通讯，以实现智能化识别、定位、跟踪、监控和管理的一种网络。简而言之，物联网就是“物物相连的互联网”。

现有的插座，功能较为局限，用电设备插上插座后，用户按下插座的按钮使插座与市电导通，进而使用电设备可以正常工作。而用户远离插座时，就无法主动控制插座与市电的通断，比如在在办公室，如果家中的灯忘关了，用户无法控制插座的通断，来关掉家里的灯；夏天还没有到家，用户无法控制插座的通断，来开启家里的空调。

中国专利公开号CN103647192A，公开日2014年3月19日，名称为“Wi-Fi智能插座系统”的发明专利中公开了一种Wi-Fi智能插座系统，包括插座体，所述的插座体内集成有主控MCU，与主控MCU相连的设置有定时器和继电器，继电器控制插头的开关，同时主控MCU还控制Wi-Fi模块，Wi-Fi模块通过互联网与云服务器相连，与云服务器相配的还设置有手机客户端或PC客户端。不足之处在于，该智能插座系统的功能较为单一，只能对插座的关断进行简单的控制，不能满足用户的需求。

发明内容

本发明的目的是克服现有技术中插座功能较为局限，不能满足用户远程对插座上连接的电器进行控制的缺陷，提供一种基于物联网的智能WIFI插座及其控制方法，通过该智能WIFI插座用户可以实现对电器进行远程控制，满足了用户的需求。

本发明的目的是通过下述技术方案予以实现：

一种基于物联网的智能WIFI插座，包括电源模块、WIFI模块和继电器开关，继电器开关与电源模块相连接，WIFI模块包括控制器，控制器内包括配置功能模块、管理控制模块和本地控制模块，配置功能模块和本地控制模块同时与继电器相连接，本地控制模块同时还与管理控制模块相连接，管理控制模块还通过无线与控制终端相连接。智能WIFI插座与控制终端的通信方式采用UDP的通信方式实现，UPD协议数据采用AES 128B的算法来进行加密后传输，保证通信数据的安全，提高了智能WIFI插座的安全性。控制终端通过与管理控制模块进行通信，管理控制模块发送信号至本地控制模块，本地控制模块控制继电器开关达到控制终端控制智能WIFI插座的目的。同时管理控制模块还通过对配置功能模块的控制达到对智能WIFI插座的WIFI配置工作。

作为一种优选方案，智能WIFI插座还包括自动升级模块和远程控制模块，远程控制模块与继电器相连接，自动升级模块和远程控制模块同时还与管理控制模块相连接，管理控制模块还通过无线与远程智能云端相连接。远程智能云端与管理控制模块进行通信，管理控制模块发送信号至自动升级模块或远程控制模块，远程控制模块控制继电器开关达到远程智能云端控制智能WIFI插座的目的。同时管理控制模块还通过对自动升级模块的控制达到对智能WIFI插座的固件进行升级的工作。

作为一种优选方案，控制终端为手机。

智能WIFI插座包括如下功能：

功能一：

手机APP控制继电器开关，手机APP软件会通过UDP广播来进行判断智能插座是否在局域网范围内，若判断在局域网范围内，则手机APP通过本地的UDP包对智能插座进行控制，若判断智能插座不在局域网内，则通过远程服务器再与智能插座端进行通信，达到远程开关插座继电器的功能；

功能二：

多组、多模式定时操作，嵌入式WIFI模组自带时钟，当智能插座接入远程智能云端后，会向远程智能云端取得一个当前的时区相对时间，然后以此时间为基础，自己时钟不断更新，作为智能插座当前的相对时间，然后依据此时间来执行一系列的定时等操作。

功能三：

事件推送功能，即支持继电器状态改变后，智能插座主动以事件机制推送信息到本地APP和远程智能云端等功能，本智能WIFI插座支持手动按键切换继电器开关功能，当继电器被手动切换后，插座会立即发送一个事件信息到本局域网内的APP和远程的云服务器，以实现APP上实时的显示出智能插座的开关状态，给用户提供一个很好的感知。

功能四：

自动远程更新智能插座设备固件，本智能WIFI插座的设计，支持了智能WIFI插座端固件的远程自动更新，设备做自动更新时与智能插座的正常工作是并行执行的，方便智能插座功能有更新时，可以很好的更新到旧版本的固件上，同时保证了智能插座的正常工作不受影响，且用户不会感到更新时带给用户使用的不便。

一种基于物联网的智能WIFI插座的控制方法，基于一种基于物联网的智能WIFI插座，包括如下步骤：

步骤1，管理控制模块判断智能WIFI插座的继电器是否处于工作状态，若处于工作状态，跳转至步骤2，如不处于工作状态，则跳转至步骤3；

步骤2，管理控制模块判断智能WIFI插座的连接方式，若智能WIFI插座与手机相连接，则管理控制模块激活本地控制模块，本地控制模块控制继电器；若智能WIFI插座与远程智能云端相连接，则管理控制模块激活远程控制模块，远程控制模块控制继电器；

步骤3，管理控制模块激活配置功能模块，配置功能模块与手机相连接进行通信。

作为一种优选方案，智能WIFI插座的控制方法，还包括以下步骤：

步骤4，管理控制模块定时激活自动升级模块，自动升级模块与远程智能云端进行通信。

本发明的有益效果是，基于物联网的智能WIFI插座能使用户方便的对智能WIFI插座进行控制，且对智能WIFI插座的设备固件能进行不影响正常工作的更新，保证了智能WIFI插座的使用效果。本发明实用性强、易于实现。

附图说明

图1是本发明的一种电路原理连接图；

图2是本发明的一种流程图。

其中：1、电源模块，2、控制器，3、继电器开关，4、手机，5、远程智能云端，21、配置功能模块，22、管理控制模块，23、本地控制模块，24、自动升级模块，25、远程控制模块。

具体实施方式

下面结合附图和实施例对本发明进一步描述。

实施例：一种基于物联网的智能WIFI插座，其电路原理连接图如图1所示，包括电源模块1、WIFI模块和继电器开关3，继电器开关与电源模块相连接，WIFI模块包括控制器2，控制器内包括配置功能模块21、管理控制模块22、本地控制模块23、自动升级模块24和远程控制模块25，本地控制模块同时与继电器相连接，配置功能模块和本地控制模块同时还与管理控制模块相连接，管理控制模块还通过无线与手机4相连接。远程控制模块与继电器相连接，自动升级模块和远程控制模块同时还与管理控制模块相连接，管理控制模块还通过无线与远程智能云端5相连接。

本发明控制方法的流程图如图2所示，包括如下步骤：

S1，管理控制模块判断智能WIFI插座的继电器是否处于工作状态，若处于工作状态，跳转至S2，如不处于工作状态，则跳转至S3；

S2，管理控制模块判断智能WIFI插座的连接方式，若智能WIFI插座与手机相连接，则管理控制模块激活本地控制模块，本地控制模块控制继电器S21；若智能WIFI插座与远程智能云端相连接，则管理控制模块激活远程控制模块，远程控制模块控制继电器S22；

S3，管理控制模块激活配置功能模块，配置功能模块与手机相连接进行通信；

S4，管理控制模块定时激活自动升级模块，自动升级模块与远程智能云端进行通信。

智能WIFI插座包括如下功能：

功能一：

功能二：

功能三：

功能四：

为了完成上述4个功能，配置功能模块、管理控制模块、本地控制模块、

自动升级模块和远程控制模块工作如下所述：

1. 管理控制模块：

（1）判断继电器开关情况，插座处于被添加后，若继电器被APP打开，则蓝灯亮，若继电器关闭，则红灯亮。

（2）执行WIFI插座的定时操作，当远程控制模块启动，WIFI插座的当前时间被更新之后，WIFI插座管理控制模块会判断当前需要执行的定时操作，并在定时时间到后做相应的操作。定时包括了单次时间点定时，单次时间段定时，对周的时间点循环定时和对一周内某一天时间段的定时。定义时间段的定时，可保证在这一时间段内，插座的状态保持一个定时的状态不变，如需要家里的热水器在每天早上7:30~8:00保持开启，则可设置一个7：30~8：00的时间段定时即可，设计时间段定时，可以给用户带来很多的便利。

（3）判断远程升级模块的使能，自动远程升级模块默认不开启，当服务器下发远程升级命令后，管理控制模块会启动自动升级模块线程，使能模块自动远程升级为新版本固件。

2. 配置管理模块：当APP需要配置该WIFI智能插座时，手机APP会自动连接上作为AP的WIFI模组，连接上后，通过UDP发送协议数据到WIFI模组，完成WIFI模块的WIFI配置工作，主要包括将要连接路由器的SSID和路由器的加密方式，算法和密码，同时APP会获取到WIFI插座的自身配置信息，如MAC地址，Device ID等信息，APP会将这些信息作为到云服务器绑定该WIFI插座的依据，完成WIFIF插座的WIFI配置和绑定用户的工作。

3. 本地控制模块：APP工作时，会不断的向APP所在的局域网UDP广播特定的协议数据包，周期为1min/次，当智能WIFI插座收到这个APP广播的本地数据包后，则会回复特定的协议数据，APP会根据回复的信息，判断在该局域网范围内是否有WIFI智能插座，当发现有WIFI智能插座后，会发送一条添加信息，同时设定一个AES 加密的密码，将WIFI插座添加到APP的本地控制范围内，同时，智能插座端也会将该APP的信息，如IP地址，保存到智能插座端维护的本地APP列表之内，之后，APP即对该智能插座的控制即采用本地UDP的方式进行通信控制，通信过程中的UDP数据包均用设定的AES 密码来进行加密。

本地控制模块的代码如下：

void dev_do_recv_data_local(U8 *data, int len, struct sockaddr_in *addr)

{

struct __STR_L1_CMD *l1_cmd= (struct __STR_L1_CMD *)data;

DEV_CONFIG *dev_config= &(m2m_at_config_n->un_dev_config.dev_config);

int local_index;

U8 l2_cmd_flag1;

char * mac_q;

mac_q= (char *)device_mac_addr_int;//NVRAM_ADDR_MAC;

if (l1_cmd->cmd== L1_CMD_LOCAL_BEAT)

dev_recv_local_beat(data, len, addr);

if (l1_cmd->flag.BIT.TLS!= 1)

{

if (IS_BIT_SET(dev_config->flag, FLAG_BIT_LOCAL_NEED_TLS)!= 0)

return ;

}

else

{

if ((l1_cmd->cmd== L1_CMD_LOCAL_REG)&&(IS_BIT_SET(dev_config->flag, FLAG_BIT_LOCAL_KEY_AVAI)== 0))

{

device_aes_decrypt(data, len, KEY_TYPE_OPEN);

}

else if ((((l1_cmd->cmd&0x80)==0x80)&&IS_BIT_SET(dev_config->flag, FLAG_BIT_LOCAL_KEY_AVAI)== 0))

//add for test

{

device_aes_decrypt(data, len, KEY_TYPE_OPEN);

}

else if (IS_BIT_SET(dev_config->flag, FLAG_BIT_LOCAL_KEY_AVAI)!= 0)

{

device_aes_decrypt(data, len, KEY_TYPE_LOCAL);

}

else

return ;

HF_DBG(("dev_do_recv_data_local: %s\r\n", "decrypted"));

dev_debug_print_data(data, len);

}

data_copy_cmd(data);

if (l1_cmd->RES!= 0x00)

return ;

if (l1_cmd->ver!= HF_IOTM_VER)

return ;

if (device_mac_same(data+2, (U8 *)(mac_q+4))== 0)

return ;

if (devicetype_ok(l1_cmd)== 0)

return ;

if(l1_cmd->flag.BIT.ACK == 1)

remove_waiting_cmd(l1_cmd->cmd, DEV_SENDTO_ALL_LOCAL);

switch(l1_cmd->cmd)

{

case L1_CMD_LOCAL_REG:

dev_recv_local_reg(data, len, addr);

break;

case L1_CMD_SET_NICKNAME:

dev_recv_set_nickname(data, len, addr);

break;

case L1_CMD_GET_NICKNAME:

dev_recv_get_nickname(data, len, addr);

break;

case L1_CMD_LOCAL_GET_TIME:

dev_recv_local_get_time(data, len, addr);

break;

case L1_CMD_LOCAL_UPDATE_SERVADD:

dev_recv_local_update_servadd(data, len, addr);

break;

case L1_CMD_GET_DEVICE_INFO:

dev_recv_get_device_info(data, len, addr);

break;

case L1_CMD_SET_DEVICE_RELD:

dev_recv_set_device_reld(data, len, addr);

break;

case L1_CMD_LOCAL_FAC_UPDATA: //local updata

{

dev_recv_upgrade(data, len); // server to tell device to upgrade

updata_cmd_is_recv_from_local = 1;

}

break;

case L1_CMD_LOCAL_DATA_SEND:

break;

case L1_CMD_LOCAL_DATA_CTRL:

{

local_index= find_in_local_list(addr);

HF_DBG(("dev_do_recv_data_local: local_index=%d\r\n", local_index));

if (local_index!= -1 )

{

l2_cmd_flag1= *(data+sizeof(struct __STR_L1_CMD));

if (l2_cmd_flag1== L2_FLAG1_SET)

do_data_ctrl_req_local(data, len, (U8)local_index);

else if (l2_cmd_flag1== L2_FLAG1_GET)

do_data_info_req_local(data, len, (U8)local_index);

}

break;

}

case L1_CMD_LOCAL_FAC_TEST_GET_INFO:

dev_recv_get_device_info(data, len, addr); //for factory test

break;

case L1_CMD_LOCAL_FAC_TEST_CTL:

{

local_index= find_in_local_list(addr);

HF_DBG(("dev_do_recv_data_local: local_index=%d\r\n", local_index));

if (local_index!= -1 )

{

do_data_ctrl_req_local(data, len, (U8)local_index); //for factory test

}

else

{

HF_DBG(("TEST ERROR!"));

}

break;

}

case L1_CMD_LOCAL_FAC_SET_INFO:

{

local_index= find_in_local_list(addr);

HF_DBG(("dev_do_recv_data_local: local_index=%d\r\n", local_index));

if (local_index!= -1 )

{

do_data_ctrl_fac_set_pinfo(data, len, (U8)local_index); //for factory test

}

else

{

HF_DBG(("TEST ERROR!"));

}

break;

}

default:

break;

}

static void device_recv_from_local(void)

{

int num;

unsigned char *c= m2m_net_recv_local;

struct sockaddr_in addr;

extern int getSystime();

memset(c, 0, DEV_LOCAL_MAXRECV_LEN);

num= udp_recv_data((char*)c, DEV_LOCAL_MAXRECV_LEN, dev_local_sock, &addr);

if (num >= 16)

{

dev_do_recv_data_local((U8 *)c, num, &addr);

}

return;

}

static U8 dev_local_select_sock()

{

fd_set fdR;

struct timeval timeout;

int ret;

U8 sel= 0;

FD_ZERO(&fdR);

if (dev_local_sock!= -1)

FD_SET(dev_local_sock,&fdR);

timeout.tv_sec= 0; // timeout shall be in while

timeout.tv_usec= 200000; // 100ms

ret= select(dev_local_sock+1,&fdR,NULL,NULL,&timeout);

//printf("After Select: ret= %d\n", ret);

if (ret<= 0)

return 0;

else if ((FD_ISSET(dev_local_sock, &fdR))&&(dev_local_sock!= -1))

sel|= 0x01;

return sel;

}

static void dev_init_udp_local_sock()

{

struct sockaddr_in addr;

HF_DBG(("init a local sock!"));

while (1)

{

if ( (dev_local_sock= socket(AF_INET, SOCK_DGRAM, 0)) < 0) //a UDP socket

{

msleep(500);

continue;

}

else

break;

}

memset(&addr, 0, sizeof(addr));

addr.sin_family = AF_INET;

addr.sin_port = htons(DEV_LOCAL_PORT);

addr.sin_addr.s_addr=htonl(INADDR_ANY);

bind(dev_local_sock, (struct sockaddr*)&addr, sizeof(addr));

dev_local_state= DEV_LOCAL_STATE_DISCONN;

hfnet_set_udp_broadcast_port_valid(DEV_LOCAL_PORT-1,DEV_LOCAL_PORT); //SDK Must used!

HF_DBG(("init local sock OK!"));

}

void device_udp_local_thread(void)

{

U8 sel;

dev_init_udp_local_sock();

while (1)

{

sel= dev_local_select_sock();

if (IS_BIT_SET(sel, 0)) // dev_server_sock selected

device_recv_from_local();

if(dev_local_num > 0)

{

if((l2_event_local == L2_EVENT_SETPIN)||(l2_event_local == L2_EVENT_SETALM))

{

if (((l2_event_local& 0x0f)& (L2_EVENT_SETPIN))!= 0)

{

device_send_event(L2_EVENT_SETPIN, DEV_SENDTO_ALL_LOCAL);

}

if (((l2_event_local& 0x0f)&(L2_EVENT_SETALM))!= 0)

{

device_send_event(L2_EVENT_SETALM, DEV_SENDTO_ALL_LOCAL);

}

l2_event_local= 0xf0;

}

msleep(100);

////////////////////////////////////////

}

void hfiots_start(void)

{

extern void device_udp_local_thread(void);

extern void device_udp_server_thread(void);

device_iots_para_init();

if(hfthread_create(device_hfiots_thread, "IOT_TD_1", 250, NULL, HFTHREAD_PRIORITIES_MID,NULL,NULL)!= HF_SUCCESS)

{

HF_DBG(("Create a thread failed!"));

}

if(hfthread_create(device_udp_local_thread, "IOT_TD_2",300, NULL, HFTHREAD_PRIORITIES_MID,NULL,NULL)!= HF_SUCCESS)

{

HF_DBG(("Create a thread failed!"));

}

if(cmd_read_dev_wifi_mode() ==MODULE_RUN_MODE_STA)

{

dev_wifi_run_mode_flag = MODULE_RUN_MODE_STA;

if(hfthread_create(device_udp_server_thread, "IOT_TD_3", 350, NULL, HFTHREAD_PRIORITIES_MID,NULL,NULL)!= HF_SUCCESS)

{

HF_DBG(("Ccreate a thread failed!"));

}

else

dev_wifi_run_mode_flag = MODULE_RUN_MODE_AP;

return;

}

4. 远程控制模块：远程控制模块首先会发送信息到远程的服务器，请求接入远程服务器，智能插座与云服务器通过C口方向的协议交互时序。

远程控制模块会更新智能插座的当前时间，每次接入时，会获取一个当前时间，后续时间依靠WIFI模组的自身时钟进行更新，作为智能插座定时操作的时间基准。远程控制模块可接受服务器发送给WIFI插座的控制命令，控制命令包括设定的定时信息和对继电器开关的操作等。每一条控制命令都采用一问一答的形式，保证了数据的稳定性，不丢包，远程采用UDP，数据实时性将会很高，控制开关将会很及时，能带给用户一个很好的体验。

远程控制模块的代码如下：

void data_ctrl_to_device(U8 *dat_in, int dat_in_len, U8 *dat_out, int *dat_out_len)

{

U16 len_tmp;

U8 l2_cmd;

*dat_out_len= 0;

if ((*(dat_in+0)== L2_FLAG1_SET)&&(*(dat_in+1)== 0/*FLAG2*/))

;

else

return ;

if (dat_in_len< 4)

return ;

Memcpy((char *)(&len_tmp), dat_in+2, 2);

len_tmp= ntohs(len_tmp);

if (dat_in_len< len_tmp+4)

return ;

l2_cmd= *(dat_in+4);

switch (l2_cmd)

{

case L2_CMD_SET_PIN:

l2_cmd_set_pin(dat_in+4, len_tmp, dat_out, dat_out_len);

break;

case L2_CMD_SET_ALARM:

l2_cmd_set_alarm(dat_in+4, len_tmp, dat_out, dat_out_len);

break;

case L2_CMD_RM_ALARM:

l2_cmd_rm_alarm(dat_in+4, len_tmp, dat_out, dat_out_len);

break;

default:

*dat_out_len= 0;

break;

}

if (*dat_out_len!= 0)

{

if (l2_cmd== L2_CMD_SET_PIN)

{

l2_event_server = L2_EVENT_SETPIN;

l2_event_local = L2_EVENT_SETPIN;

}

else if((l2_cmd== L2_CMD_SET_ALARM)||(l2_cmd== L2_CMD_RM_ALARM))

{

l2_event_server = L2_EVENT_SETALM;

l2_event_local = L2_EVENT_SETALM;

}

dev_debug_print_data(dat_out, *dat_out_len);

return;

}

void do_data_ctrl_req_server(U8 *data, int len, U8 sendto)

{

struct __STR_L1_CMD *l1_cmd= (struct __STR_L1_CMD *)data;

struct __STR_L1_CMD reply;

portTickType now= GetSysTimeMS();

char *L2_data;

int L2_len;

unsigned short l2_user_len;

char *L2_ret_data;//= m2m_net_recv_iots;

int L2_ret_len;

if (l1_cmd->flag.BIT.REP!= 1)

return ;

Memcpy((char *)&reply, (char *)data, sizeof(struct __STR_L1_CMD));

reply.flag.BIT.REP= 1;

reply.flag.BIT.ACK= 1;

reply.flag.BIT.L2= 1;

L2_data= (char *)(data+ sizeof(struct __STR_L1_CMD));

Memcpy((char*)&l2_user_len, (L2_data+2),2);

l2_user_len = ntohs(l2_user_len);

L2_len = 4+l2_user_len;

L2_ret_data= (char *)HFMalloc(300, 0);

memset(L2_ret_data,0,300);

if(hfiots_server_recv_FE_callback((U8 *)L2_data, L2_len, (U8 *)L2_ret_data, &L2_ret_len) == HFIOTS_USR_TRUE)

{

HF_DBG(("local recv has done in usr callback"));

}

else

{

data_ctrl_to_device((U8 *)L2_data, L2_len, (U8 *)L2_ret_data, &L2_ret_len);

}

if (L2_ret_len== 0)

{

HFFree(L2_ret_data);

return ;

}

if (sendto== DEV_SENDTO_SERVER)

dev_send_reply(&reply, (U8 *)L2_ret_data, L2_ret_len, dev_server_sock, &dev_server_addr, dev_server_TLS, KEY_TYPE_SERVER);

HFFree(L2_ret_data);

return;

}

void dev_do_recv_data_server(U8 *data, int len)

{

struct __STR_L1_CMD *l1_cmd= (struct __STR_L1_CMD *)data;

U8 * mac_q=NULL;

mac_q= (U8*)device_mac_addr_int;//NVRAM_ADDR_MAC;

U8 l2_cmd_flag1;

unsigned int index = 0;

if (l1_cmd->cmd== L1_CMD_DISCOVER_REQ)

{

dev_recv_discover_req(data, len);

HF_DBG(("recv server let dev discover request..."));

return ;

}

#if Cus_gongniu

if (l1_cmd->cmd== L1_CMD_NEED_SERVER_ERASE_DEVICE)

{

index= find_waiting_cmd(L1_CMD_NEED_SERVER_ERASE_DEVICE, DEV_SENDTO_SERVER);

HF_DBG(("~~~~~OK TO ERASE DEVICE TO SERVER:%d~~~~~",index));

if (index>= 0)

{

gn_clear_erase_flag();

device_iots_reload();

}

return ;

}

#endif

if (dev_server_TLS== 1)

{

if (l1_cmd->flag.BIT.TLS!= 1)

return ;

if (dev_server_key_av== 1)

{

if ((l1_cmd->cmd== L1_CMD_ACCESS_REQ)||(l1_cmd->cmd== L1_CMD_DISCOVER_REQ))

{

device_aes_decrypt(data, len, KEY_TYPE_OPEN);

}

else

{

device_aes_decrypt(data, len, KEY_TYPE_SERVER); // aes_decrypt

}

else

{

device_aes_decrypt(data, len, KEY_TYPE_OPEN);

}

data_copy_cmd(data);

if (l1_cmd->RES!= 0x00)

return ;

if (l1_cmd->ver!= HF_IOTM_VER)

return ;

if (device_mac_same(data+2, (U8 *)(mac_q+4))== 0)

return ;

if (devicetype_ok(l1_cmd)== 0)

return ;

dev_debug_print_data(data, len);

remove_waiting_cmd(l1_cmd->cmd, DEV_SENDTO_SERVER);

switch(l1_cmd->cmd)

{

case L1_CMD_ACCESS_REQ:

dev_recv_access_req(data, len);

break;

case L1_CMD_BEAT:

break;

case L1_CMD_TIME_REQ:

dev_recv_time_req(data, len);

break;

case L1_CMD_SEND_MODULE_INFO:

dev_recv_module_info_send_rsp(data, len); // server to update key

break;

case L1_CMD_UPDATE_SERVADD:

dev_recv_update_servadd(data, len); // server to update server address

break;

case L1_CMD_UPGRADE:

dev_recv_upgrade(data, len); // server to tell device to upgrade

break;

case L1_CMD_DATA_SEND:

break;

case L1_CMD_DATA_CTRL:

l2_cmd_flag1= *(data+sizeof(struct __STR_L1_CMD));

HF_DBG(("l2_cmd_flag1:%X ",l2_cmd_flag1));

if (l2_cmd_flag1== L2_FLAG1_SET)

do_data_ctrl_req_server(data, len, DEV_SENDTO_SERVER);

else if (l2_cmd_flag1== L2_FLAG1_GET)

do_data_info_req_server(data, len, DEV_SENDTO_SERVER);

break;

default:

break;

}

static void device_recv_from_server(void)

{

int num;

unsigned char *recv_data_buf_ptr= m2m_net_recv_server;

struct sockaddr_in addr;

extern int getSystime();

memset(recv_data_buf_ptr, 0, DEV_SERVER_MAXRECV_LEN);

num= udp_recv_data((char *)m2m_net_recv_server, DEV_SERVER_MAXRECV_LEN, dev_server_sock, &addr);

if (num > 0)

{

HF_DBG(( "<<____Receive from Server,cmd:0x%X______>>%s", *(recv_data_buf_ptr+0),"\r\n"));

dev_debug_print_data((U8 *)recv_data_buf_ptr, num);

dev_do_recv_data_server((U8 *)recv_data_buf_ptr, num);

}

return;

}

static U8 dev_server_select_sock()

{

fd_set fdR;

struct timeval timeout;

int ret;

U8 sel= 0;

FD_ZERO(&fdR);

if (dev_server_sock!= -1)

FD_SET(dev_server_sock,&fdR);

timeout.tv_sec= 0; // timeout shall be in while

timeout.tv_usec= 100000; // 100ms

ret= select(dev_server_sock+1,&fdR,NULL,NULL,&timeout);

if (ret<= 0)

{

return 0;

}

else if ((FD_ISSET(dev_server_sock, &fdR))&&(dev_server_sock!= -1))

sel|= 0x01;

return sel;

}

static void dev_init_udp_server_sock()

{

struct sockaddr_in addr;

ip_addr_t dest_addr;

HF_DBG(("TO init a server sock!"));

DEV_CONFIG *dev_config= &(m2m_at_config_n->un_dev_config.dev_config);

if (IS_BIT_SET(dev_config->flag, FLAG_BIT_SERV_ADDR_AVAI)) // connect to server

{

if(hf_is_ipaddress((char *)(dev_config->server_ip)) !=1 )

{

char ret;

ret = netconn_gethostbyname((char *)(dev_config->server_ip), &dest_addr);

if(ret!=/*ERR_OK*/0)

{

msleep(500);

return ;

}

else

{

if( inet_aton((char *)(dev_config->server_ip), (ip_addr_t *) &dest_addr) == 0)

{

//u_printf("error!\r\n");

}

memset(&dev_server_addr, 0, sizeof(dev_server_addr));

inet_addr_from_ipaddr(&dev_server_addr.sin_addr, &dest_addr);

dev_server_addr.sin_family = AF_INET;

dev_server_addr.sin_port = htons(dev_config->server_port);

while (1)

{

if ( (dev_server_sock= socket(AF_INET, SOCK_DGRAM, 0)) < 0) //a UDP socket

{

msleep(1000);

continue;

}

else

break;

}

memset(&addr, 0, sizeof(addr));

addr.sin_family = AF_INET;

addr.sin_addr.s_addr=htonl(INADDR_ANY);

bind(dev_server_sock, (struct sockaddr*)&addr, sizeof(addr));

dev_server_state= DEV_SERVER_STATE_CONNECTING;

HF_Debug(DEBUG_DEVICE, "Server sock %s!\r\n", "ok");

}

return;

}

void device_udp_server_thread(void)

{

U8 sel;

DEV_CONFIG *dev_config= &(m2m_at_config_n->un_dev_config.dev_config);

portTickType now = 0;

U16 beattm = 0;

U32 my_time_ms;

HF_DBG(("SERVER thread"));

while (cmd_read_is_wifi_linked()== 0)

msleep(1000);

while (!(IS_BIT_SET(dev_config->flag, FLAG_BIT_SERV_ADDR_AVAI)))

{

msleep(1000);

}

HF_Debug(DEBUG_DEVICE, "device_udp_server_thread: %d\r\n", 1);

dev_init_udp_server_sock();

if ((dev_config->beat_time== 0)||(dev_config->beat_time> 60*5)) // beat time shall less than 5 min

beattm= 60*1; // 1 mins

else

beattm= dev_config->beat_time;

HF_DBG(("beat time: %d\r\n", beattm));

my_time_ms = 0;

while (1)

{

now= GetSysTimeMS();

waiting_time= now;

my_time_ms++;

if (dev_server_state== DEV_SERVER_STATE_CONNECTING)

{

my_time_ms = 0;

device_send_cmd(L1_CMD_ACCESS_REQ, CMD_TIMEOUT_1, 1, 0xFFFF, DEV_SEND_DATA_MAX_FAILTM, DEV_SENDTO_SERVER, NULL, 0, 0xFFFF);

}

if (dev_server_state== DEV_SERVER_STATE_CONNECTED)

{

if ((dev_time_avai== 0)||(dev_time_avai== 0xff))

{

device_send_cmd(L1_CMD_TIME_REQ, CMD_TIMEOUT_1, 1, 0xFFFF, DEV_SEND_DATA_MAX_FAILTM, DEV_SENDTO_SERVER, NULL, 0, 0xFFFF);

}

else

{

if ((U32)((now-dev_time_last_update)/1000)>= (U32)(DEV_TIME_UPDATE_TM))

dev_time_avai= 0xff;

}

if (((U32)((now-module_last_send_info_time)/1000)>= (U32)(MODULE_SEND_INFO_TIME))||(is_need_first_send_devinfo_to_server > 0))

{

device_send_cmd(L1_CMD_SEND_MODULE_INFO, CMD_TIMEOUT_1, 1, 0xFFFF, DEV_SEND_DATA_MAX_FAILTM, DEV_SENDTO_SERVER, NULL, 0, 0xFFFF);

module_last_send_info_time= now;

is_need_first_send_devinfo_to_server--;

}

if ((U32)((now-dev_last_beat_time)/1000)>= (U32)(beattm))

{

HF_DBG(("Do beat"));

dev_last_beat_time= now;

}

#if Cus_gongniu

if ((dev_config->need_to_reset_server == 1))

{

HF_DBG(("~~~~~ TO NEED ERASE DEVICE~~~~~"));

device_send_cmd(L1_CMD_NEED_SERVER_ERASE_DEVICE, CMD_TIMEOUT_1, 1, 0xFFFF, DEV_SEND_DATA_MAX_FAILTM, DEV_SENDTO_SERVER, NULL, 0, 0xFFFF);

to_server_erase_flag ++;

if(to_server_erase_flag > 3)

gn_clear_erase_flag();

}

#endif

#if Cus_gongniu

if((l2_event_server == L2_EVENT_SETPIN) || (l2_event_server == L2_EVENT_SETALM))

{

if(l2_event_server == L2_EVENT_SETPIN)

{

if (device_send_event(L2_EVENT_SETPIN, DEV_SENDTO_SERVER)== 1)

l2_event_server = 0xf0;

}

else if(l2_event_server == L2_EVENT_SETALM)

{

if (device_send_event(L2_EVENT_SETALM, DEV_SENDTO_SERVER))

l2_event_server = 0xf0;

}

else if(l2_event_server == L2_EVENT_USR_DATA)

{

// if (device_send_event(L2_EVENT_USR_DATA, DEV_SENDTO_SERVER))

l2_event_server = 0xf0;

}

if(is_init_event_flag > 0)

{

if(is_init_event_flag>3)

l2_event_server = L2_EVENT_SETPIN;

else

l2_event_server = L2_EVENT_SETALM;

is_init_event_flag--; //for first time

}

#endif

}

if(my_time_ms*150>(beattm*1000*5))

{

dev_write_err_no_to_flash(DEV_ERR_NO_SYS_TIME_ERR);

dev_write_err_no_to_flash(dev_server_state&0xFF);

HF_DBG(("**RUN ERROR,TO RESTART:%X***",dev_server_state));

msleep(3000);

hfsys_softreset();

}

sel= dev_server_select_sock();

if (IS_BIT_SET(sel, 0)) // dev_server_sock selected

device_recv_from_server();

update_waiting_cmd();

msleep(50);

}

5. 自动升级模块：自动升级模块会每一段时间向云服务器上报一条UDP协议数据，该数据包含了设备的软件版本信息和硬件版本信息，MAC地址等，当服务器收到该模块的信息后会判断该WIFI插座是否需要升级，若需要升级，则云服务器会返回一个升级的配置文件信息给WIFI插座，WIFI插座在收到该升级配置信息之后，会去按照指定的配置信息，使能升级，同时升级过程中，WIFI插座的其他功能模块不受影响，将会正常工作，待自动升级模块升级成功后，会判断继电器的状态，当继电器关闭处于关闭状态时，会立即重新启动WIFI插座端固件，重新工作在新版本的固件上，若插座继电器开启，为避免开启会重启会影响已连接的家电设备的正常工作，WIFI插座会等继电器关闭之后再重新启动，切换为新版本的固件，继续工作，该设计，很好的保证了自动升级模块完全不影响智能插座的正常工作。

Claims

1.一种基于物联网的智能WIFI插座，其特征是，包括电源模块、WIFI模块和继电器开关，继电器开关与电源模块相连接，WIFI模块包括控制器，控制器内包括配置功能模块、管理控制模块和本地控制模块，本地控制模块同时与继电器相连接，配置功能模块和本地控制模块同时还与管理控制模块相连接，管理控制模块还通过无线与控制终端相连接。

2.根据权利要求1所述的一种基于物联网的智能WIFI插座，其特征是，还包括自动升级模块和远程控制模块，远程控制模块与继电器相连接，自动升级模块和远程控制模块同时还与管理控制模块相连接，管理控制模块还通过无线与远程智能云端相连接。

3.根据权利要求1或2所述的一种基于物联网的智能WIFI插座，其特征是，所述的控制终端为手机。

4.一种基于物联网的智能WIFI插座的控制方法，基于权利要求2所述的一种基于物联网的智能WIFI插座，其特征是，包括如下步骤：

5.根据权利要求4所述的一种基于物联网的智能WIFI插座的控制方法，其特征是，还包括以下步骤：