esp-joylink解析（smartconfig过程）

最新推荐文章于 2024-04-19 09:58:30 发布
最新推荐文章于 2024-04-19 09:58:30 发布
阅读量1.2k 收藏
点赞数
分类专栏： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013550000/article/details/90083059
版权

创建TASK，用于sniffer配网

//创建TASK，用于sniffer配网
void jd_innet_start_task(void)
{
    xTaskCreate(jd_innet_start, "jd_innet_start", 1024*3, NULL, tskIDLE_PRIORITY + 2, NULL);
}

开启sniffer模式，进行一些配网模式的初始化等，执行到回调函数中接收802.11包

static void jd_innet_start (void *pvParameters)
{
    unsigned char* pBuffer = NULL;
    joylink_smnt_param_t param;
    esp_wifi_set_promiscuous(0);

    pBuffer = (unsigned char*)malloc(1024);
    if (pBuffer == NULL) {
        log_debug("%s,%d\r\n",__func__,__LINE__);
        vTaskDelete(NULL);
    }
    
	memset(&param,0x0,sizeof(param));
	memcpy(param.secretkey,AES_KEY,sizeof(param.secretkey));
	param.switch_channel_callback = esp_switch_channel_callback;
	param.get_result_callback = esp_get_result_callback;
    joylink_smnt_init(param);

#ifdef CONFIG_TARGET_PLATFORM_ESP8266
    esp_wifi_set_promiscuous_data_len(32);
#endif
    if (ESP_OK != esp_wifi_set_promiscuous_rx_cb(jd_innet_pack_callback)){
        log_debug ("[%s] set_promiscuous fail\n\r",__func__);
    }

    if (ESP_OK != esp_wifi_set_promiscuous(1)){
        log_debug ("[%s] open promiscuous fail\n\r",__func__);
    }

    if (jd_innet_timer_task_handle != NULL) {
        jd_innet_timer_task_flag = true;
        while(jd_innet_timer_task_flag) {
            vTaskDelay(10);
        }
    }
    xTaskCreate(jd_innet_timer_task, "jd_innet_timer_task", 2048, NULL, tskIDLE_PRIORITY + 5, &jd_innet_timer_task_handle);

    vTaskDelete(NULL);
}

重要函数
esp_wifi_set_promiscuous(bool en);/开启/关闭混杂模式/

esp_err_tesp_wifi_set_promiscuous(bool en)
Enable the promiscuous mode.

Return
ESP_OK: succeed
ESP_ERR_WIFI_NOT_INIT: WiFi is not initialized by esp_wifi_init
Parameters
en: false - disable, true - enable

esp_wifi_set_promiscuous_data_len(32);

没有找到这个函数，猜测是设置混杂模式获取数据的长度为32.

esp_wifi_set_promiscuous_rx_cb(jd_innet_pack_callback)

esp_err_tesp_wifi_set_promiscuous_rx_cb(wifi_promiscuous_cb_tcb)
Register the RX callback function in the promiscuous mode.

Each time a packet is received, the registered callback function will be called.

Return
ESP_OK: succeed
ESP_ERR_WIFI_NOT_INIT: WiFi is not initialized by esp_wifi_init
Parameters
cb: callback

其中：

//特殊配网包格式
typedef struct{
	smnt_status_t state;	
	uint16 syncFirst;				
	uint8 syncCount;				
	uint8 syncStepPoint;			
	uint8 syncFirst_downlink;		
	uint8 syncCount_downlink;		
	uint8 syncStepPoint_downlink;	
	uint8 directTimerSkip;			
	uint8 broadcastVersion;			
	uint8 muticastVersion;			
	uint8  broadIndex;				
	uint8  broadBuffer[5];			
	uint16 lastLength;			
	uint16 lastUploadSeq;		
	uint16 lastDownSeq;		
	uint8  syncAppMac[6];		
	uint8  syncBssid[6];		
	uint16 syncIsUplink;		
	uint8 chCurrentIndex;		
	uint8 chCurrentProbability;	
	uint8 isProbeReceived;	
	uint8 payload_multicast[128];	
	uint8 payload_broadcast[128];
	smnt_encrypt_data_t result;	
}joylinkSmnt_t;

//配网的状态
typedef enum{
   
	SMART_CH_INIT 		=	0x1,
	SMART_CH_LOCKING 	=	0x2,
	SMART_CH_LOCKED 	=	0x4,
	SMART_FINISH 		= 	0x8
}smnt_status_t;

//加密数据
typedef struct{
	unsigned char type;	                        // 0:NotReady, 1:ControlPacketOK, 2:BroadcastOK, 3:MulticastOK
	unsigned char encData[1+32+32+32];            // length + EncodeData
}smnt_encrypt_data_t;

接着执行到回调函数 包都到这里来

/*recv packet callback*/
static void jd_innet_pack_callback(void *buf, wifi_promiscuous_pkt_type_t type)
{

    wifi_promiscuous_pkt_t *pack_all = NULL;
    int len=0;
    PHEADER_802_11 frame = NULL;

    if (type != WIFI_PKT_MISC) {
        pack_all = (wifi_promiscuous_pkt_t *)buf;
        frame = (PHEADER_802_11)pack_all->payload;        
#ifdef CONFIG_TARGET_PLATFORM_ESP8266
    len = pack_all->rx_ctrl.sig_mode ? pack_all->rx_ctrl.HT_length : pack_all->rx_ctrl.legacy_length;
#else
    len = pack_all->rx_ctrl.sig_len;
#endif
		joylink_smnt_datahandler(frame, len);

    }
}

以下是802.11的帧类型

//wifi帧格式
typedef enum {
   
    WIFI_PKT_MGMT,  /**< Management frame, indicates 'buf' argument is wifi_promiscuous_pkt_t */
    WIFI_PKT_CTRL,  /**< Control frame, indicates 'buf' argument is wifi_promiscuous_pkt_t */
    WIFI_PKT_DATA,  /**< Data frame, indiciates 'buf' argument is wifi_promiscuous_pkt_t */
    WIFI_PKT_MISC,  /**< Other type, such as MIMO etc. 'buf' argument is wifi_promiscuous_pkt_t but the payload is zero length. */
} wifi_promiscuous_pkt_type_t;

接下来进行解包,支持组播方式和广播方式

void joylink_smnt_datahandler(PHEADER_802_11 pHeader, int length)
{
	uint8 isUplink = 1;				
	uint8 packetType = 0;					// 1-multicast packets 2-broadcast packets 0-thers
	uint8 isDifferentAddr = 0;
	uint8 *pDest, *pSrc, *pBssid;
	uint16 lastLength = 0;
	uint16 lastSeq_uplink = 0,lastSeq_downlink = 0;
	static uint8 past_channel = 0xFF;
	
	if (pSmnt == NULL)
		return;
	if ((length > 100) && (pSmnt->state != SMART_CH_LOCKED))	
		return;
	
	if (pHeader->FC.ToDs){
		isUplink = 1;				
		pBssid = pHeader->Addr1;
		pSrc = pHeader->Addr2;
		pDest = pHeader->Addr3;	

		if (!((memcmp(pDest, "\xFF\xFF\xFF\xFF\xFF\xFF", 6) == 0) || (memcmp(pDest, "\x01\x00\x5E", 3) == 0))){
			return;
		}		
		lastSeq_uplink = pSmnt->lastUploadSeq;
		pSmnt->lastUploadSeq = pHeader->Sequence;
	}else{
		pDest = pHeader->Addr1;	
		pBssid = pHeader->Addr2;
		pSrc  = pHeader->Addr3;
		
		isUplink = 0;
		//not broadcast nor multicast package ,return
		if (!((memcmp(pDest, "\xFF\xFF\xFF\xFF\xFF\xFF", 6) == 0) || (memcmp(pDest, "\x01\x00\x5E", 3) == 0))){
			return;
		}
		lastSeq_downlink = pSmnt->lastDownSeq;
		pSmnt->lastDownSeq = pHeader->Sequence;
	}
	lastLength = pSmnt->lastLength;
	pSmnt->lastLength = length;

	if (memcmp(pDest, "\xFF\xFF\xFF\xFF\xFF\xFF", 6) == 0)
	{
		if (pSmnt->state == SMART_CH_LOCKING)
		{
			if(isUplink == 1)
				printf("uplink:(%02x-%04d)->length:%2x, =length-synfirst:(0x%02x),synfirst:%2x\n", *((uint8*)pHeader) & 0xFF, pHeader->Sequence, length, (uint8)(length - pSmnt->syncFirst +1),pSmnt->syncFirst);
			else
				printf("downlink:(%02x-%04d)->length:%2x, =length-synfirst:(0x%02x),synfirst:%2x\n", *((uint8*)pHeader) & 0xFF, pHeader->Sequence, length, (uint8)(length - pSmnt->syncFirst_downlink +1),pSmnt->syncFirst_downlink);
			
		}
		packetType = 2;
	}
	else if (memcmp(pDest, "\x01\x00\x5E", 3) == 0)
	{
		if (pSmnt->state == SMART_CH_LOCKING)
			printf("(%02x-%04d):%02x:%02x:%02x->%d\n", *((uint8*)pHeader) & 0xFF, pHeader->Sequence, pDest[3], pDest[4], pDest[5], (uint8)length);
		packetType = 1;
	}

	if (memcmp(pSrc, pSmnt->syncAppMac, 6) != 0)
	{
		isDifferentAddr = 1;
	}

	if(pSmnt->state == SMART_CH_LOCKING)
	{
		if (packetType == 0) return;
		if ((isUplink==1) && (pHeader->Sequence == lastSeq_uplink)) return;
		if ((isUplink==0) && (pHeader->Sequence == lastSeq_downlink)) return;
		if(!isDifferentAddr)
		{
			if (packetType != 0)
			{
				if (packetType == 1)
				{
					if (((pDest[3] >> 6) == ((pDest[4] ^ pDest[5]) & 0x1)) && (pDest[3] != 0) && ((pDest[3]&0x3F) <=  PAYLOAD_MAX))
					{
						/*if receive multicast right message for two times,lock the channel*/
						if(past_channel == pSmnt->chCurrentIndex + 1)
						{
							past_channel = 0xFF;
							if (pSmnt->chCurrentProbability < 20) 
								pSmnt->chCurrentProbability = 10;

							memcpy(pSmnt->syncBssid, pBssid, 6);
							pSmnt->state = SMART_CH_LOCKED;
						}
						else
						{
							past_channel = pSmnt->chCurrentIndex + 1;
						}

					}
					joylink_smnt_muticastadd(pDest); // Internal state machine could delay the ch switching
					return;
				}

				if(isUplink == 1)
				{
					if (lastLength == length)	return;

					int expectLength = 1 + pSmnt->syncFirst + pSmnt->syncCount%4 - (pSmnt->syncStepPoint?4:0);
					int isStep = (pSmnt->syncStepPoint == 0 && length == (expectLength - 4));	

					if ( ( length == expectLength ) || isStep)
					{
						pSmnt->syncCount++;
						pSmnt->chCurrentProbability++;

						if (isStep)		pSmnt->syncStepPoint = pSmnt->syncCount;

						if (pSmnt->syncCount >= 3)	// Achive SYNC count!
						//if (pSmnt->syncCount >= 4)	// Achive SYNC count!
						{
							pSmnt->syncFirst = pSmnt->syncFirst + pSmnt->syncStepPoint - (pSmnt->syncStepPoint ? 4 : 0);	// Save sync world
							memcpy(pSmnt->syncBssid, pBssid, 6);

							pSmnt->state 		= SMART_CH_LOCKED;

							printf("SYNC:(%02X%02X%02X%02X%02X%02X-%02X%02X%02X%02X%02X%02X)------->:CH=%d, WD=%d\n",
								pSrc[0], pSrc[1], pSrc[2], pSrc[3], pSrc[4], pSrc[5],
								pBssid[0], pBssid[1], pBssid[2], pBssid[3], pBssid[4], pBssid[5],
								pSmnt->chCurrentIndex+1, pSmnt->syncFirst);
							
							pSmnt->syncIsUplink = isUplink;
							
							if(pSmnt->chCurrentProbability < 20)
								pSmnt->chCurrentProbability = 20;
							printf("--->locked by uplink\n");
						}
						return;
					}
					if (pSmnt->syncCount)
					{
						pSmnt->syncStepPoint = 0;
						pSmnt->syncCount = 0;
						memcpy(pSmnt->syncAppMac, pSrc, 6);
						pSmnt->syncFirst = length;
						printf("SYNC LOST\n");
					}
				}
				else
				{
					if (lastLength == length)	return;

					int expectLength = 1 + pSmnt->syncFirst_downlink+ pSmnt->syncCount_downlink%4 - (pSmnt->syncStepPoint_downlink?4:0);
					int isStep = (pSmnt->syncStepPoint_downlink == 0 && length == (expectLength - 4));	

					if ( ( length == expectLength ) || isStep)
					{
						pSmnt->syncCount_downlink++;
						pSmnt->chCurrentProbability++;
						
						if (isStep)			pSmnt->syncStepPoint_downlink = pSmnt->syncCount_downlink;

						if (pSmnt->syncCount_downlink>= 3)	// Achive SYNC count!
						//if (pSmnt->syncCount_downlink>= 4)	// Achive SYNC count!
						{
							pSmnt->syncFirst_downlink = pSmnt->syncFirst_downlink + pSmnt->syncStepPoint_downlink - (pSmnt->syncStepPoint_downlink? 4 : 0);	// Save sync world
							memcpy(pSmnt->syncBssid, pBssid, 6);
							pSmnt->state = SMART_CH_LOCKED;
							printf("SYNC:(%02X%02X%02X%02X%02X%02X-%02X%02X%02X%02X%02X%02X)------->:CH=%d, WD=%d\n",
								pSrc[0], pSrc[1], pSrc[2], pSrc[3], pSrc[4], pSrc[5],
								pBssid[0], pBssid[1], pBssid[2], pBssid[3], pBssid[4], pBssid[5],
								pSmnt->chCurrentIndex+1, pSmnt->syncFirst_downlink);

							pSmnt->syncIsUplink = isUplink;
							if(pSmnt->chCurrentProbability < 20)
								pSmnt->chCurrentProbability = 20;
							printf("--->locked by downlink\n");
						}
						return;
					}
					pSmnt->syncStepPoint_downlink = 0;
					pSmnt->syncCount_downlink = 0;
					memcpy(pSmnt->syncAppMac, pSrc, 6);
					pSmnt->syncFirst_downlink = length;
					printf("SYNC LOST\n");
				}
			} 
			return;	
		}
		memcpy(pSmnt->syncAppMac, pSrc, 6);
		pSmnt->syncFirst = length;
		pSmnt->syncFirst_downlink = length;
		printf("Try to SYNC!\n");
		return;
	}
	else if (pSmnt->state == SMART_CH_LOCKED)
	{
		if (isDifferentAddr) return;

		if (packetType == 1){
			joylink_smnt_muticastadd(pDest);
			return;
		}
		
		if ( (packetType != 1)&&(memcmp(pDest, pSmnt->syncBssid, 6) != 0) ){
			packetType = 2;
		}
		
		if(isUplink == 1)
		{
			if (length < (pSmnt->syncFirst - 1)) return;
			if ( pHeader->Sequence == lastSeq_uplink) return;
		}
		else
		{
			if (length < (pSmnt->syncFirst_downlink - 1)) return;
			if ( pHeader->Sequence == lastSeq_downlink) return;
		}
		if (packetType == 2)
		{
			int ascii;
			if(isUplink == 1)
				ascii = length - pSmnt->syncFirst + 1;
			else
				ascii = length - pSmnt->syncFirst_downlink + 1;

			if((((ascii >> 8) & 0x01) == 1) && (((ascii >> 3)&0x1F) == 0))
			{
				;
			}
			else
			{
				joylink_smnt_broadcastadd(ascii);
			}
			if (((length + 4 - lastLength) % 4 == 1)&& (length - pSmnt->syncFirst)<4)  // There are SYNC packets even ch locked.
			{
				if (pSmnt->chCurrentProbability < 20) pSmnt->chCurrentProbability++;
			}
		}
	}
	else if (pSmnt->state == SMART_FINISH)
	{
		printf("SMART_FINISH-1\n");
	}
	else
	{
		pSmnt->state = SMART_CH_LOCKING;
		memcpy(pSmnt->syncAppMac, pSrc, 6);
		pSmnt->syncFirst = length;
		pSmnt->syncStepPoint = 0;
		pSmnt->syncCount = 0;
		printf("Reset All State\n");
	}
	return;
}

广播包标志：\xFF\xFF\xFF\xFF\xFF\xFF
组播包标志：\x01\x00\x5E
由调试结果可知，通过切换信道来锁定配网包的信道，循环接收包进行补全数据。
得到配网所需的SSID和PASSWORD
本示例说明：下面是调试LOG


downlink:(40-2111)->length:38, =length-synfirst:(0x01),synfirst:38
downlink:(40-0033)->length:38, =length-synfirst:(0x01),synfirst:38
downlink:(40-1855)->length:39, =length-synfirst:(0x02),synfirst:38
------------------->SYNC (CH:13) 0
uplink:(88-3624)->length:53, =length-synfirst:(0x1c),synfirst:38
Try to SYNC!
uplink:(88-3626)->length:54, =length-synfirst:(0x02),synfirst:53
------------------->SYNC (CH:1) 0
downlink:(80-0747)->length:60, =length-synfirst:(0x0e),synfirst:53
Try to SYNC
最低0.47元/天 解锁文章
甲虫ss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
ESP8266开发之旅 进阶篇⑩ sniffer混杂模式，监听802.11帧，黑科技基础
单片机菜鸟哥的博客
02-08 4万+
授人以鱼不如授人以渔，目的不是为了教会你具体项目开发，而是学会学习的能力。希望大家分享给你周边需要的朋友或者同学，说不定大神成长之路有博哥的奠基石。。。 共同学习成长QQ群 622368884，不喜勿加，里面有一大群志同道合的探路人 快速导航 单片机菜鸟的博客快速索引(快速找到你要的) 如果觉得有用，麻烦点赞收藏，您的支持是博主创作的动力。 ...
SP8266 smartconfig源码 smartconfig.zip
09-01
SP8266 smartconfig源码 smartconfig.zip iot wifi模块开发源码
ESP32配置京东JOYLink
duangker的博客
10-15 635
写在前面： 本工程基于 乐鑫官方工程，请先阅读乐鑫官方README文档。 本工程目前仅支持ESP32，想用ESP8266的同学，可以替换component.mk中LIBS += joylink为LIBS += 8266joylink,但是本人目前尚未验证。 操作介绍： 0. 硬件准备： 开发板：ESP32 开发板 路由器：使用 2.4GHz 网络，可以连接外网 手机：安装小京鱼沙箱版APP 1. 环境准备： 请先配置esp_idf, 官方项目：github， 国内clone比较慢的同学可以用乐鑫的国
esp32~Sniffer模式的人流量检测
Hynson的学习笔记
10-09 4273
项目参考： ESP32 应用实践：基于混杂接收模式的人流量检测 本想着移植到esp8266，可是它不支持sniffer和sta共存，实际写代码确认了wifi连上路由打开sniffer后，发现它掉线了，查询官方api文档也验证了这一点。有点可惜，本想写篇教程的，失败！方案不可行，测试了上面给的demo挺稳的，大家看一下顺便可以熟悉下IDF编程风格。 ...
ESP32 应用实践：基于混杂接收模式的人流量检测
热门推荐
乐鑫 Espressif
11-22 1万+
本文介绍了如何通过ESP32来统计人流量，同时将数据通过MQTT协议上传到OneNET平台，以及在该平台如何看到人流量检测结果的实时数据和统计。本文由浅入深，从基本名词的说明，到环境的搭建，以及示例代码的原理和代码展示，以及最后的结果都做了一个较为详尽的描述。在文章结尾，也分析了部分代码以及文章小结，为后来的开发者抛砖引玉。
Esp32嗅探器
02-25
Esp32嗅探器 итаетмакадресаустроойстввокругиспользующихwi-fi。 微型sd的Идётпострочнаязаписьрезультатов。 Потребление120МаЧ。 应用PowerBank10.000МаЧрассчётноевремяработы83часа
wireshark抓包工具的使用
weixin_46417419的博客
07-15 1181
WIFI-Sniffer模式 wifi sniffer模式可以通过esp_wifi_set_promiscous()使能。如 果使能sniffer模式，可以向应用程序存储以下数据包 802.11管理帧 802.11数据帧，包括APDU,AMPDU,AMSCU等 802.11MIMO帧，sniffer 模式仅转MIMO帧的长度 802.11控制帧 不可向应用程序转存以下数据包 802.11错误帧，如有CRC错误的帧 对于Sniffer 模式 可以 转储的帧，应用程序可以另外使用 esp_
ESP32 – WiFi sniffer
qinrenzhi的博客
03-07 3256
2017-01-23 by Łukasz Podkalicki This experimental project shows how to build a simple and inexpensive WiFi packet analyzer (also known as a WiFi sniffer). The heart of this project is WiFi module of ...
esp8266 探测MAC地址，串口输出.环境 Aruduino1.85
09-26 5321
esp8266混杂模式下的接收数据回调函数 promisc_cb 解析数据 串口输出。 #include &lt;ESP8266WiFi.h&gt; #include "./sniffer.h" #define disable 0 #define CHANNEL 1 #define BAUD_RATE 115200 #define CHANNEL_HOPPING true //if t...
ESP32系列--第四篇 WiFi概述
coderma的博客
05-11 4914
一、目的 二、介绍 三、实战
ESP8266SDK编程手册1.30版本
01-27
ESP8266的WIFI芯片编程手册；SDK编程手册1.30版本；PDF文件，标签已经全部做好，方便查阅；
ESP8266_wifi探针sniffer
12-27
ESP8266 wifi 探针，wifi sniffer,内含sniffer数据手册以及esp8266等相关手册。固件烧录及环境搭建按照安信可官网。 IDE安装：https://en.ai-thinker.com/ai_ide_install IDE使用：https://en.ai-thinker.com/ai_ide_use 固件烧录：https://en.ai-thinker.com/esp_download
esp8266-dual-cloud:esp8266 Dual cloud support demo，现支持alink + joylink
05-13
有关 esp8266 对接 ALINK 的相关介绍请参考： 有关 esp8266 对接 JOYLINK 的相关介绍清参考：1. 资源限制esp8266 在同时对接 alink + joylink 时，在正常工作和控制状态下，剩余内资源在 10k 左右，完全满足正常的...
joylink-boot:Spring Boot的显示版本
05-17
【标题】"joylink-boot:Spring Boot的显示版本"揭示了这是一个基于Spring Boot框架的项目，专注于提供一种方式来展示Spring Boot应用的版本信息。在Spring Boot中，版本信息的管理是开发过程中不可或缺的一部分，它...
JD_joylink
12-07
此压缩包文件包含的是`joylink_dev_sdk_v1.3.4`，这可能是京东微联SDK的一个特定版本，用于设备制造商和软件开发者进行产品集成。 京东微联SDK的核心功能包括： 1. **设备认证**：SDK提供了一套完整的设备身份验证...
ESP32 蓝牙经典嗅探器：一款强大的物联网分析工具
最新发布
gitblog_00050的博客
04-19 539
ESP32 蓝牙经典嗅探器：一款强大的物联网分析工具 项目地址:https://gitcode.com/Matheus-Garbelini/esp32_bluetooth_classic_sniffer 项目简介 ESP32 Bluetooth Classic Sniffer 是一个基于 Espressif Systems 的 ESP32 微控制器的开源项目，它能够捕获并解析蓝牙经典（Blueto...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值