手机app+esp8266控制小区大门门锁,实现远程开门

最新推荐文章于 2024-03-24 18:40:03 发布
最新推荐文章于 2024-03-24 18:40:03 发布
阅读量7k 收藏 40
点赞数 7
分类专栏： C++语言 手机开发 文章标签： 物联网 嵌入式 app
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lijiteng/article/details/105952788
版权

        近日笔者自己动手修理自家的门铃时,发现只要接通开门的电源线,就可以打开楼宇的大门了，突发奇想：在门铃引出线加装继电器就可以用esp8266连上互联，实现远程开门了。（我家门铃比较老旧，不知其他牌子门铃是否也是可以这样操作，知道的朋友留言告诉一下）。

具体要实现的功能：通过手机app操作实现开门功能。实现原理：esp8266连接服务器，并与之交互数据，手机app向服务器发送开锁指令，服务器转发指令到esp8266，esp8266通过gpio发送高电平给继电器，接通开门电源线，实现开门。本文只从程序开发方面去说明开发的过程。更多的硬件方面的说明请看相关文档。

需要的设备清单：

继电器:信号线连接esp8266的gpio2,当高电平是继电器断开,门锁关状态,开锁时将gpio2置为低电平2秒钟,即可实现开锁.

esp8266

家庭wifi

 

立即上源码

esp8266部分，使用udp与服务器通信：(在ESP8266_NONOS_SDK-2.1.0-18上编译通过)

#include "user_interface.h"
#include "espconn.h"
#include "gpio.h"
#include "eagle_soc.h"
#include "osapi.h"    //os_printf所需要的头文件

ETSTimer my_timer,act_timer,low_timer;
struct espconn conn;
esp_udp user_udp;
ip_addr_t esp_server_ip;
void ICACHE_FLASH_ATTR init_cb(void);
void ICACHE_FLASH_ATTR espconn_cli_timer_cb(void *timer_arg);
void ICACHE_FLASH_ATTR act_timer_cb(void *timer_arg);
void ICACHE_FLASH_ATTR client_connect();
void ICACHE_FLASH_ATTR act_timer_cb(void *timer_arg);
void ICACHE_FLASH_ATTR ret_back_cb(void *timer_arg);
void ICACHE_FLASH_ATTR espconn_recv_data_cb(void *arg,char *pdata,unsigned short len);
void ICACHE_FLASH_ATTR espconn_sent_cb(void *arg);

static int gLoginSucess = 0;

void ICACHE_FLASH_ATTR espconn_recv_data_cb(void *arg,char *pdata,unsigned short len)
{//接收到服务发来的信息，进行相关的操作
    os_printf("espconn_recv_data_cb datalen:%d,conetnt[%s]\n",len,pdata);
    if(strncmp(pdata,"LOGIN_RESP",11) == 0)
    {
                gLoginSucess = 1;
                os_printf("login succeed\n");
                if(strcmp(pdata+11,"LOW") == 0)
                    GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 0);
                else if(strcmp(pdata+11,"HEIGHT") == 0)
                    GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 1);
                os_timer_disarm(&act_timer);
                os_timer_setfn(&act_timer,act_timer_cb, NULL);
                os_timer_arm(&act_timer, 60000, 1);
    }
    else if(strcmp(pdata,"ACK_RESP") == 0)
    {
        os_printf("act resp\n");
    }
    else if(strcmp(pdata,"OPEN") == 0)
    {
        os_printf("opt:OPEN\n");
        //gpio16_output_set(0);
        GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 0);
        os_timer_disarm(&low_timer);
        os_timer_setfn(&low_timer,ret_back_cb, NULL);
        os_timer_arm(&low_timer, 500, 0);
    }
    else if(strcmp(pdata,"LOW")==0)
    {
        GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 0);
        char szData[16] = {0};
        os_sprintf(szData,"LOW_RESP_%d",system_get_chip_id());
        espconn_sent(&conn,szData,strlen(szData));
    }
    else if(strcmp(pdata,"HEIGHT")==0)
    {
        GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 1);
        char szData[20] = {0};
        os_sprintf(szData,"HEIGHT_RESP_%d",system_get_chip_id());
        espconn_sent(&conn,szData,strlen(szData));
    }
    else if(strcmp(pdata,"UPDATE")==0)
    {
        
    }
    else
    {
        os_printf("unknow command\n");
    }
}
void ICACHE_FLASH_ATTR espconn_sent_cb(void *arg)
{
    os_printf("espconn_sent_cb\n");   
}

void ICACHE_FLASH_ATTR ret_back_cb(void *timer_arg)
{
    //gpio16_output_set(1);
    GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 1);
    char szData[16] = {0};
    os_sprintf(szData,"OPEN_RESP_%d",system_get_chip_id());
    espconn_sent(&conn,szData,strlen(szData));
}

void ICACHE_FLASH_ATTR act_timer_cb(void *timer_arg)
{
    os_printf("act_timer_cb\n");   
    char szData[16] = {0};
    os_sprintf(szData,"ACK_%d",system_get_chip_id());
    espconn_sent(&conn,szData,strlen(szData));
}
void ICACHE_FLASH_ATTR login_timer_cb(void *timer_arg)
{
    if(!gLoginSucess)
    {
        os_printf("login_timer_cb\n");
        char szData[16] = {0};
        os_sprintf(szData,"LOGIN_%d",system_get_chip_id());
        espconn_sent(&conn,szData,strlen(szData));
        os_timer_disarm(&my_timer);
        os_timer_setfn(&my_timer,login_timer_cb, NULL);
        os_timer_arm(&my_timer, 5000, 0);
    }
}
LOCAL void ICACHE_FLASH_ATTR
my_dns_found(const char *name, ip_addr_t *ipaddr, void *arg)
{
    struct espconn *pespconn = (struct espconn *)arg;

    if (ipaddr == NULL) 
    {
        os_printf("my_dns_found NULL\n");
        /*
        if (++device_recon_count == 5) {
            device_status = DEVICE_CONNECT_SERVER_FAIL;

            user_esp_platform_reset_mode();
        }*/

        return;
    }

    os_printf("my_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) 
    {
        esp_server_ip.addr = ipaddr->addr;
        os_memcpy(user_udp.remote_ip, &ipaddr->addr, 4);
    }
    os_timer_disarm(&my_timer);
    os_timer_setfn(&my_timer,espconn_cli_timer_cb, NULL);
    os_timer_arm(&my_timer, 10000, 0);
    
}
void ICACHE_FLASH_ATTR client_connect()
{    
    conn.type      = ESPCONN_UDP;
    conn.state     = ESPCONN_NONE;
    user_udp.remote_port = 9004;
    conn.proto.udp = &user_udp;
    espconn_regist_sentcb(&conn, espconn_sent_cb);
    espconn_regist_recvcb(&conn, espconn_recv_data_cb); 
    os_printf("begin espconn_connect\n");
    //espconn_connect(&conn);
    espconn_create(&conn);    
    char szData[16] = {0};
    os_sprintf(szData,"LOGIN_%d",system_get_chip_id());
    espconn_sent(&conn,szData,strlen(szData));
    os_timer_disarm(&my_timer);
    os_timer_setfn(&my_timer,login_timer_cb, NULL);//设置监听登陆成功的函数
    os_timer_arm(&my_timer, 10000, 0);
}
void ICACHE_FLASH_ATTR espconn_cli_timer_cb(void *timer_arg)
{//连接wifi，如果未连上wifi会不停重试
    init_cb();
}
void ICACHE_FLASH_ATTR init_cb(void)
{//初始化函数主要功能获取服务器的地址
    //struct ip_info info;
    //wifi_get_ip_info(STATION_IF,&info);
    uint8 status=wifi_station_get_connect_status();
    os_printf("wifi_station_get_connect_status:%d\n",status);
    if(status==STATION_GOT_IP)
    {
        if(esp_server_ip.addr == 0)
        {
            char *servername = "www.aomomo.net";
            espconn_gethostbyname(&conn, servername, &esp_server_ip, my_dns_found);
            os_printf("espconn_gethostbyname\n");
            os_timer_disarm(&my_timer);
            os_timer_setfn(&my_timer,espconn_cli_timer_cb, NULL);
            os_timer_arm(&my_timer, 10000, 0);
        }    
        else
            client_connect();//连上wifi后开始登陆服务器
       }
       else
       {
            os_printf("setup my_timer for espconn_cli_timer_cb\n");
            os_timer_disarm(&my_timer);
            os_timer_setfn(&my_timer,espconn_cli_timer_cb, NULL);
            os_timer_arm(&my_timer, 5000, 0);
       }
}
void ICACHE_FLASH_ATTR user_init()
{
    os_printf("2222222222222222222222222222222\n");
    uint8 opmode;
    //uart_init(115200,115200);
    wifi_set_opmode(STATION_MODE);//把esp8266设置为工作站的工作模式
    opmode = wifi_get_opmode();
    os_printf("current mode is: %d\n", opmode); 
    esp_server_ip.addr = 0;
/*
    struct ip_info info;
    IP4ADDR(&info.ip,192,168,1,111);
    IP4ADDR(&info.gw,192,168,1,1);
    IP4ADDR(&info.netmask,255,255,255,0);
    wifi_set_ip_info(STATION_IF,&info);
    */
       struct station_config stationconf;
     stationconf.bssid_set = 0;
     memset(stationconf.ssid, 0, sizeof(stationconf.ssid));
     memset(stationconf.password, 0, sizeof(stationconf.password));
     os_strncpy(stationconf.ssid, "esp8266", sizeof(stationconf.ssid));//设置wifi接入点
     os_strncpy(stationconf.password, "esp12345", sizeof(stationconf.password));//设置wifi接入点密码
    wifi_station_set_config(&stationconf);//设置
    gpio_init();
    //gpio16_output_conf();
    //gpio16_output_set(0);
    //gpio_output_set(0, BIT2, BIT2, 0);
    //PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U,FUNC_GPIO2);//
    //PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO16_U,FUNC_GPIO16);//
    //PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, FUNC_GPIO2);
    GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 1);//设置gpio2为高电平，连接继电器的信号输入，此时继电器状态为断开。
    system_init_done_cb(init_cb);//初始化完成后的回调函数  
}
void ICACHE_FLASH_ATTR
user_rf_pre_init(){} 

 

服务器部分

//同时支持tcp与udp服务,9003为tcp服务,9004为udp服务,部署在linux服务器上

#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <netdb.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <string>
#include <list>
#include <map>
#include <sstream>
 

using namespace std;

int g_iMaxFd = 0;
int g_iServerSocketFd;
int g_iUdpFd;
fd_set g_set;

typedef struct _ConnInfo
{
    int iFd;
    struct sockaddr_in addr;
    unsigned int addrLen;
    time_t iLastTime;
} ConnInfo;

list<ConnInfo> g_servlist;
map<string,ConnInfo> g_client_info;

int CanSend(int fd,int p_iUsec);
int CanReceive(int fd,int p_iUsec);

 

void WriteLog(string str)
{
    printf("%s\n",str.c_str());
}

int main(int argc,char *argv[])
{

    g_iServerSocketFd = socket(AF_INET,SOCK_STREAM,0); 
    struct sockaddr_in cli_addr;
    unsigned int iNameLen;
    iNameLen = sizeof(cli_addr);
    int iFlags = fcntl(g_iServerSocketFd, F_GETFL, 0);
    fcntl(g_iServerSocketFd, F_SETFL, iFlags | O_NONBLOCK);
//#ifdef LINUX
    int iOpt;
    socklen_t iLen;
    iOpt = 1;
    iLen = sizeof(iOpt);
    //free the port
    setsockopt(g_iServerSocketFd, SOL_SOCKET, SO_REUSEADDR, (void *)&iOpt, iLen);
//#endif

    struct sockaddr_in serv_addr;
    memset((void *)&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(9003);
    //bind to the specify port
    if(bind(g_iServerSocketFd,(struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
        WriteLog( "Server:Can't bind local address! 9003\n");
        return false;
    }
    //begin listen
    listen(g_iServerSocketFd,5);

    struct sockaddr_in  localAddr;
    g_iUdpFd =  socket(AF_INET, SOCK_DGRAM, 0);
    bzero(&localAddr, sizeof(localAddr));
    localAddr.sin_family = AF_INET;
    localAddr.sin_port = htons(9004);
    localAddr.sin_addr.s_addr = INADDR_ANY;
    iFlags = fcntl(g_iUdpFd, F_GETFL, 0);
    fcntl(g_iUdpFd, F_SETFL, iFlags | O_NONBLOCK);
    int result =  bind(g_iUdpFd, (struct sockaddr *)&localAddr, sizeof(localAddr));
    if(result < 0)
    {

       WriteLog( "Server:Can't bind local address! 9004\n");
        return false;
    }
    g_client_info.clear();
    WriteLog( "start..." );

    FD_ZERO( &g_set );
    ConnInfo conn;
    conn.iFd = g_iServerSocketFd;
    conn.iLastTime = time(NULL);
    g_servlist.push_back(conn);
    conn.iFd = g_iUdpFd;
    conn.iLastTime = time(NULL);
    g_servlist.push_back(conn);
    FD_SET(g_iServerSocketFd, &g_set);
    FD_SET(g_iUdpFd, &g_set);
    g_iMaxFd = (g_iServerSocketFd > g_iUdpFd? g_iServerSocketFd : g_iUdpFd);
    
    while(1)
    {
        struct timeval ptv;
        ptv.tv_sec = 30;
        ptv.tv_usec = 0;
        fd_set fdset = g_set;
        int iRet = select(g_iMaxFd+1,  &fdset,  NULL,  NULL,  &ptv); 
        if(iRet > 0)
        {
            for(list<ConnInfo>::iterator it=g_servlist.begin();it!=g_servlist.end();it++)
            {
                int fd = it->iFd;
                if(FD_ISSET(fd,&fdset))
                {
                    if(fd == g_iServerSocketFd)
                    {
                        struct sockaddr_in clientAddr;
                        unsigned int nameLen = sizeof(clientAddr);
                        int clientSock = accept( g_iServerSocketFd, (sockaddr*)&clientAddr, &nameLen );
                        printf( "get accept:%d\n" , clientSock);
                        if(clientSock > 0)
                        {
                            conn.iFd = clientSock;
                            conn.iLastTime = time(NULL);
                            conn.addr = clientAddr;
                            conn.addrLen = nameLen;
                            g_servlist.push_back(conn);
                            FD_SET(clientSock, &g_set);
                            if(clientSock > g_iMaxFd) g_iMaxFd = clientSock;
                        }
                    }
                    else
                    {
                        struct sockaddr_in  remoteAddr;
                        socklen_t remoteAddrLength = sizeof(remoteAddr);
                        char szData[24] = {0};
                        int iLen = recvfrom(fd,szData,24,0,(struct sockaddr *)&remoteAddr, &remoteAddrLength);
                        if(iLen <=0)
                        {
                            close(fd);
                            it = g_servlist.erase(it);
                            FD_CLR(fd,&g_set);

                           printf( "socket break:%d" , fd);
                            break;
                        }
                        printf( "fd:%d,recv:%s\n" , fd , szData );
                                                
                        if(strncmp(szData,"LOGIN",5)==0)
                        {
                            it->iLastTime = time(NULL);
                            it->addr = remoteAddr;
                            it->addrLen = remoteAddrLength;
                            string strClientId = szData+6;
                            memset(szData,0,sizeof(szData));
                            strncpy(szData,"LOGIN_RESP_HEIGHT",sizeof(szData));
                            sendto(fd,szData,strlen(szData),0,(struct sockaddr *)&remoteAddr ,remoteAddrLength);
                            string strSign = "000000000000000000";
                            string strVersion = "1.0";
                            map<string,ConnInfo>::iterator p = g_client_info.find(strClientId);
                            if(p == g_client_info.end())                                
                                g_client_info[strClientId] = *it;
                            else
                            {
                                p->second.iLastTime = it->iLastTime;
                                p->second.addr = remoteAddr;
                                p->second.addrLen = remoteAddrLength;
                            }
                        }
                        else if(strncmp(szData,"ACK",3)==0)
                        {
                            it->iLastTime = time(NULL);
                            it->addr = remoteAddr;
                            it->addrLen = remoteAddrLength;
                            string strClientId = szData+4;
                            memset(szData,0,sizeof(szData));
                            strncpy(szData,"ACK_RESP",sizeof(szData));
                            sendto(fd,szData,strlen(szData),0,(struct sockaddr *)&remoteAddr ,remoteAddrLength);
                            map<string,ConnInfo>::iterator p = g_client_info.find(strClientId);
                            if(p != g_client_info.end())
                            {
                                p->second.iLastTime = it->iLastTime;
                                p->second.addr = remoteAddr;
                                p->second.addrLen = remoteAddrLength;
                            }
                        }
                        else if(strncmp(szData,"CTRL",4)==0)
                        {
                            memset(szData,0,sizeof(szData));
                            strncpy(szData,"OPEN",4);
                            for(list<ConnInfo>::iterator pit=g_servlist.begin();pit!=g_servlist.end();pit++)
                            {
                                if(pit->iFd != g_iServerSocketFd)
                                {
                                    printf( "send to fd:%d\n" ,pit->iFd);
                                    sendto(pit->iFd,szData,strlen(szData),0,(struct sockaddr *)&pit->addr ,pit->addrLen);
                                }
                            }
                            sendto(fd,szData,strlen(szData),0,(struct sockaddr *)&remoteAddr ,remoteAddrLength);
                        }
                        else if(strncmp(szData,"ORDER|",6)==0)//收到手机端的开门指令,转发给esp8266
                        {
                            stringstream ss(szData);
                            string strOrder,strClientId,strOP;
                            getline(ss,strOrder,'|');
                            getline(ss,strClientId,'|');
                            getline(ss,strOP,'|'); 
                            map<string,ConnInfo>::iterator p = g_client_info.find(strClientId);
                            if(p == g_client_info.end())
                               printf("can not find clientid:%s\n" , strClientId);
                            else
                            {
                               printf( "send to fd:%d,op:%s\n" , p->second.iFd ,strOP.c_str());
                                sendto(p->second.iFd,strOP.c_str(),strOP.length(),0,(struct sockaddr *)&p->second.addr ,p->second.addrLen);
                            }
                            sendto(fd,"OK",2,0,0,0);
                        }
                        else if(strncmp(szData,"OPEN_RESP",9)==0)
                        {
                            string strClientId = szData+10;
                            map<string,ConnInfo>::iterator p = g_client_info.find(strClientId);
                            if(p != g_client_info.end())
                            {
                                p->second.iLastTime = time(NULL);
                            }
                        }
                        else if(strncmp(szData,"HEIGHT_RESP",11)==0)
                        {
                            string strClientId = szData+12;
                        }
                        else if(strncmp(szData,"LOW_RESP",8)==0)
                        {
                            string strClientId = szData+9;
                        }
                        else
                        {
                            close(fd);
                            it = g_servlist.erase(it);
                            FD_CLR(fd,&g_set);
                           printf( "unbknow command socket close" );
                            break;
                        }
                    }
                }
            }
        }
        else if(iRet == 0)
        {
            for(list<ConnInfo>::iterator it=g_servlist.begin();it!=g_servlist.end();)
            {
                if( it->iFd != g_iUdpFd && it->iFd != g_iServerSocketFd  && difftime(time(NULL),it->iLastTime) > 120)
                {
                   printf( "clean not active fd:%d\n" , it->iFd);
                    FD_CLR(it->iFd,&g_set);
                    close(it->iFd);
                    it = g_servlist.erase(it);    
                }
                else
                    it++;
            }
        }
        else
            ;
    }
}


int CanReceive(int fd,int p_iUsec)
{
    fd_set rf;
    struct timeval tox;
    
    FD_ZERO(&rf);
    FD_SET(fd, &rf);
    int i = p_iUsec / 1000 / 1000;
    tox.tv_sec = i;
    tox.tv_usec = p_iUsec % (1000 * 1000);
    //return select(fd + 1, &rf, NULL, NULL, &tox);
    return select(FD_SETSIZE, &rf, NULL, NULL, &tox);
}
int CanSend(int fd,int p_iUsec)
{
    fd_set rf;
    struct timeval tox;
    FD_ZERO(&rf);
    FD_SET(fd, &rf);
    int i = p_iUsec / 1000 / 1000;
    tox.tv_sec = i;
    tox.tv_usec = p_iUsec % (1000 * 1000);
    return select(FD_SETSIZE, NULL, &rf, NULL, &tox);
    //return select(fd + 1, NULL, &rf, NULL, &tox);
}
 

lijiteng
关注
  • 7
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
利用esp8266模块实现远程开关（1）
06-24
利用esp8266模块实现远程开关，人在外，手机可以实现WIFI远程控制家里的灯打开与关闭。
ESP8266+SG90+GP2Y0E03实现远程开门和感应开门
06-23
ESP8266接入贝壳物联，可以通过手机远程发送指令实现电机转动，红外测距传感器GP2Y0E03连接到Node MCU，可以实现在一定距离内识别物体（人）并控制电机转动，这样就实现了远程开门和感应开门。
ESP8266与STM32的APP远程开关
最新发布
jz_pyy的博客
03-24 1483
基于ESP8266与STM32的APP远程开关
基于esp8266的手机远程控制开关装置
2302_79918745的博客
10-28 952
本文演示的方法比较适合只想了解物联网玩玩的同学，如想深入了解建议从C语言以及Arduino的使用，以及ESP8266,ESP32等物联网单片机的机构及引脚用法学起。如今市面上有很多成熟的电子模块供我们使用，大大降低了我们的学习成本。我们也可借助米思齐或Arduino的图形化编程来完成我们的项目，进一步降低输入代码繁琐的时间。仅以此博客记录一下我的学习，也为想了解物联网的同学提供自己的经验。电源线接单片机的3V。信号线接单片机的D4。搜索我们需要用到的单片机esp8266，安装最新版本。
stm32+esp8266实现局域网下小灯控制源码
04-20
stm32+esp8266实现局域网下小灯控制源码。 1,串口写指令 通过stm32串口2发送AT指令给esp8266，此时可以通过串口一查看配置的AT指令。可以在程序中找到对应的语句 具体指令 AT AT+RST AT+CWMODE_CUR=1 //模式选择 AT+CWJAP_CUR="WIFI名","密码" //注意这里对应连接路由器的 AT+CIFSR //获取IP,用于随后TCP/IP通讯 AT+CIPMUX=1 //多连接模式 AT+CIPSERVER=1,8288 //设置通讯端口 上述写入语句可以在串口1查看，并获得相应的OK回复。 2，stm32程序 主要包含了一些初始化配置，然后在main函数，通过判断接收到的指令来控制小灯的亮灭。部分程序如下： while ( 1 ) { switch(flag) { case 'a': GPIO_SetBits(GPIOA,GPIO_Pin_0 );break;//开灯 case 'c': GPIO_ResetBits(GPIOA,GPIO_Pin_0 );break;/ } }
物联网项目实战开发之基于STM32+ESP8266 WIFI上传多路开关状态及远程控制到OneNet物联网平台代码程序
05-23
STM32F103通过串口2跟ESP8266相连。 1、连接onenet物联网平台，主动上报本地数据到平台端。 2、接收平台端下发的控制指令并动作。 3、代码使用KEIL开发，当前在STM32F103C8T6运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量即可。 4、软件下载时，请注意keil选择项是jlink还是stlink. 5、硬件设计、软件开发、数据联网：[email protected];
51单片机ESP8266WIFI远程门禁密码锁可修改密码APP开锁查看密码
LS840233684的博客
04-29 2612
实践制作DIY- GC003-WIFI远程门禁密码 一、功能说明： 基于51单片机设计-WIFI远程门禁密码锁 二、功能介绍：1.基于STC89C52RC，有一个LCD1602显示器显示信息，6位数密码，4X4键盘输入密码，修改密码，删除输入。有一个继电器开锁后通电表明开锁。 2.使用ESP8266-WIFI模块和安卓手机APP进行数据交互。 3.APP可以显示密码、远程开锁。 三、详情介绍： 视频讲解：哔哩哔哩搜索UP主“爱搞单片机”在其空间搜索关键词“STM32汽车儿童安全系统”观看..
搭建树莓派手机远程开门系统
weixin_34405332的博客
06-13 508
【目标】按下手机app中的按钮，寝室的门锁打开。【基本原理】Raspberry Pi 作为控制装置：其运行Linux系统，因此功能强大；提供GPIO接口，因此便于控制物理开门机构。yeelink 平台作为云提供者：自己搭建web服务器成本高难度大，yeelink提供免费的物联网云服务，并开放API，可以用于编写手机app。在yeelink 平台注册一个开关型传感器，平时其value为0。RasP...
【宿舍开门】成本20元，ESP8266强制门户网页开关+RFID
Zy_1213的博客
04-17 6419
具体实现功能： 1、ESP8266使用AP模式，终端设备通过 Web 网页实现舵机控制； 2、RFID-MFRC522射频实现舵机控制，可录入实体卡（校园一卡通），支持手机NFC。 wifi强制门户功能演示： RFID-MFRC522功能演示： 硬件部分：NodeMcu V3开发板、舵机、RFID-RC522射频 NodeMcu和 RC522接线图 NodeMcu引脚图 NodeMcu原理图 舵机接GPI0(D3) 供电采用充电器 ...
基于STM32+ESP8266设计智能锁(支持微信小程序一键配网连接腾讯云平台).7z
05-27
详情请搜索CSDN文章： 基于STM32+ESP8266设计智能锁(支持微信小程序一键配网连接腾讯云平台) 文章里对该代码做了详细介绍。
ESP8266控制APP+源码合集.zip
04-13
ESP8266控制APP+源码合集，适合初学者研究，包含源码及帮助文档。
基于STM32设计的动态密码锁(带手机APP).zip
07-04
资料包里包含STM32源码，Qt上位机源码、Android手机APP安装包，windows系统可执行文件、开发板原理图。 在哔哩哔哩有实物效果演示：https://www.bilibili.com/video/BV13Y4y1t7Gn?share_source=copy_web 随着人们生活水平的提高及科学技术的发展，个人信息保护显得至关重要，这款智能电子密码锁，以STM32单片机为主控制器,由触摸矩阵键盘、ESP8266、步进电机等模块组成，具有远程控制、随机密码生成等功能。 当前支持的开锁方式： （1）手机APP远程开锁。支持手机APP远程开锁。手机APP连接上ESP8266创建的WIFI热点和TCP服务器，可以在手机APP上对设备端的RTC时间进行校准，设备唯一ID获取，生成随机开锁密码。 （2）随机密码开锁。手机APP与本地设备采用时间、作为算法种子，采用算法生成开锁密码，每一串的密码有效时间为一分钟。查看手机APP上显示的密码之后，在本地设备上输入完成密码对比开锁。
物联网项目实战开发之基于STM32+ESP8266 WIFI连接阿里云智能生活飞燕平台，实现APP远程控制测试代码程序
05-23
STM32F103通过串口2跟ESP8266相连。 1、连接阿里云aliyun物联网生活平台（飞燕平台），主动上报本地数据到平台端。 2、接收平台端下发的控制指令并动作。 3、手机app使用阿里云智造APP。 4、代码使用KEIL开发，当前在STM32F103C8T6运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量即可。 5、软件下载时，请注意keil选择项是jlink还是stlink. 6、硬件设计、软件开发、数据联网：[email protected];
基于STM32F103C8T6+ESP8266温室大棚远程监控系统
04-22
包含原理图、程序、APP、原子云固件、FLASH烧录工具等等 检测环境温湿度并显示、检测土壤湿度并显示、检测环境光照强度并显示、检测环境中CO2并显示、通过ESP8266将数据上传云平台和手机app、超限蜂鸣器报警和电机系统工作
STM32C8T6通过扫描二维码进行智能开锁使用esp8266
04-30
STM32C8T6通过扫描二维码进行智能开锁使用esp8266，压缩包里包含了使用说明，引脚接线
STM32+ESP8266实现在线OTA升级(腾讯云物联网)_20220331.zip
03-31
STM32+ESP8266实现在线OTA升级，博客教程地址：https://blog.csdn.net/qq_44062900/article/details/123856364
基于ESP8266+点灯科技+小爱同学控制开门解决方案！
檬柠wan
09-22 9017
每次下班回到家就已经很累了，到门口还要到处翻找钥匙，然后开门，是不是觉得很烦，那我们有没有不用通过钥匙开门且成本低的方案了？下面我会教大家基于ESP8266+点灯科技+小爱同学来控制开门的方法。
ESP8266制作简单的WiFi开关
11-17
其中包含esp8266使用lua实现操作GPIO,串口,定时器,TCP服务器和客户端,UDP,本地mqtt, 数据存储等源码和说明文档; 制作自己简单的wifi开关
物联网stm32开发板app小程序web远程控制ota升级w5500+esp8266
12-11
物联网是指通过无线通信技术将各种设备、物品互联互通，实现信息共享和远程控制的网络系统。STM32开发板是一种常用的微控制器开发板，其可以与各种外部设备相连，如传感器、执行器等。在物联网应用中，使用STM32开发板进行设备的控制和数据的采集十分常见。 为了方便用户对物联网设备进行控制，可以使用App、小程序或者Web页面等方式实现远程控制。在本场景中，我们使用了STM32开发板、W5500以太网模块和ESP8266 WiFi模块。 W5500是一款硬件以太网控制器，它可以用于将STM32开发板连接到网络。通过W5500，STM32可以通过Ethernet协议与Internet进行通信。用户可以通过编写STM32的程序，实现与云服务器的数据交互与远程控制。 同时，我们还可以使用ESP8266模块连接到STM32开发板，使得STM32具备WiFi通信能力。ESP8266可以连接到无线网络，并提供与云服务器的通信接口。使用ESP8266模块，我们可以使用HTTP或MQTT等协议与互联网进行通信，实现物联网设备的远程控制和OTA（Over-The-Air）升级。 OTA升级指的是通过网络向设备更新固件，而不需要将设备连接到计算机进行有线升级。在物联网应用中，OTA升级可以实现灵活的固件更新，为设备带来更多的功能和修复漏洞。使用OTA升级，我们可以通过网络将固件更新的指令发送到STM32开发板，然后通过W5500或ESP8266模块将固件文件下载到设备，最后进行固件更新。这样，设备的固件可以实时更新，同时不需要用户手动连接设备和计算机。 总之，通过使用STM32开发板、W5500以太网模块、ESP8266 WiFi模块以及相应的App、小程序或者Web页面，我们可以实现对物联网设备的远程控制和OTA升级。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lijiteng

好心啦,福心啦.打赏网络乞丐啦

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值