【ESP8266】使用ESP8266 NONOS SDK的JSON API

最新推荐文章于 2024-06-23 22:48:56 发布
最新推荐文章于 2024-06-23 22:48:56 发布
阅读量1.5w 收藏 35
点赞数 12
分类专栏： ESP8266 文章标签： ESP8266 JSON
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yannanxiu/article/details/50911357
版权

2016年9月30日更新：本人移植了cJSON到ESP8266的NONOS SDK，详情可以查看这篇文章：

http://blog.csdn.net/yannanxiu/article/details/52713746

===============================================

一、概述

这篇文章是讲解如何用ESP8266官方提供的Json接口处理数据。


首先要在esp_iot_sdk/example/IoT_Demo示例目录下找到user_json.c和user_json.h，把这两个文件包含进自己的工程。


查看json.h文件，里面有一下宏定义

#define JSON_TYPE_ARRAY '['
#define JSON_TYPE_OBJECT '{'
#define JSON_TYPE_PAIR ':'
#define JSON_TYPE_PAIR_NAME 'N' /* for N:V pairs */
#define JSON_TYPE_STRING '"'
#define JSON_TYPE_INT 'I'
#define JSON_TYPE_NUMBER '0'
#define JSON_TYPE_ERROR 0

后面的例程都是用此宏定义来判断Json的键值的数据类型。


二、生成一个Json

下面给出生成Json树的示例，生成的JSON树get_h内容如下："hi":{"hello":"world"}

/***************************************************/
LOCAL int ICACHE_FLASH_ATTR
hello_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, "hello", 5) == 0) {
        os_sprintf(string, "world");
    }

    jsontree_write_string(js_ctx, string);

    return 0;
}

LOCAL struct jsontree_callback hello_callback =
    JSONTREE_CALLBACK(hello_get, NULL);

JSONTREE_OBJECT(get_hello,
                JSONTREE_PAIR("hello", &hello_callback));
JSONTREE_OBJECT(get_h,
                JSONTREE_PAIR("hi", &get_hello));

其中宏定义JSONTREE_OBJECT是生成一个JSON数的对象，第一个参数是该对象的名称（get_h），JSONTREE_PAIR是生成一个键值对的宏。

JSONTREE_CALLBACL是生成一个回调指针的宏，该宏有两个参数，第一个参数是设置读取JSON树的值的函数，这里为hello_get函数，第二个参数是设置写入JSON树的值的函数，这里没有用到，为NULL。

hello_get是生成JSON树的值的函数。其中用os_strncnp进行Json键的判断，如果键为hello，则对该键写入"world"值。

这里生成的JSON是："hi":{"hello","world"}，hi是用来调用后面Json数据的：


#define BUF_LENTH 64
LOCAL char buf[BUF_LENTH];
	json_ws_send((struct jsontree_value *)&get_h, "hi", buf);
	os_printf("%s\n",buf);

使用json_ws_send函数可以把hi后面的数据写入buf，json_ws_send函数在IoT_demo例程中的user_json.c文件里。

最后打印结果是：

{

"hello":"world"

}


三、生成一个温湿度Json数据

下面是一个生成温湿度的例程：

/********************DHT11***********************/
LOCAL int ICACHE_FLASH_ATTR
dht11_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, "temp", 4) == 0)
    {
        //os_sprintf(string, "%d",temperture);
    	os_sprintf(string,"25");
    }
    else if(os_strncmp(path, "hum", 3) == 0)
	{
    	//os_sprintf(string, "%d",hum);
    	os_sprintf(string,"40");
    }

    jsontree_write_string(js_ctx, string);

    return 0;
}

LOCAL struct jsontree_callback dht11_callback =
    JSONTREE_CALLBACK(dht11_get, NULL);

JSONTREE_OBJECT(get_dht11,
                JSONTREE_PAIR("temp", &dht11_callback),
		JSONTREE_PAIR("hum", &dht11_callback));
JSONTREE_OBJECT(DHT11JSON,
                JSONTREE_PAIR("dht11", &get_dht11));

//返回DHT11数据的json格式
char* ICACHE_FLASH_ATTR
get_dht11_json(void)
{
	static char dht11_buf[64];
	os_memset(dht11_buf,0,64);		//清空
	json_ws_send((struct jsontree_value *)&DHT11JSON, "dht11", dht11_buf);
	return dht11_buf;
}


之后在user_init入口函数写一个打印函数 

os_printf(get_dht11_json());

就可以看到串口打印出

{
"temp":"25",
"hum":"40"
}


四、一个完整的生成Json数据示例

下面是一个完整的生成Json数据的示例，可以生成字符串、整型值、数组、Json对象的Value。

Json数据的生成最重要的是理解函数回调机制，看代码要从下往上看，如果看官接触过异步回调机制的代码，阅读起来可能会有一种相似的感觉。


#include "user_json.h"
#include "ets_sys.h"
#include "os_type.h"
#include "osapi.h"
#include "mem.h"
#include "user_interface.h"

LOCAL int ICACHE_FLASH_ATTR
jsonTree_get(struct jsontree_context *js_ctx)
{
    const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);
    
    //生成"String":"data"
    if (os_strncmp(path, "String", os_strlen("String")) == 0) {
    	jsontree_write_string(js_ctx, "data");
    //生成"Integer":1
    } else if (os_strncmp(path, "Integer", os_strlen("Integer")) == 0) {
        jsontree_write_int(js_ctx, 1);
    //生成"Array":[0,1,2]
    } else if (os_strncmp(path, "Array", os_strlen("Array")) == 0) {
    	int array[3] = {0,1,2};
    	jsontree_write_atom(js_ctx, "[");
    	jsontree_write_int_array(js_ctx, array, 3);
    	jsontree_write_atom(js_ctx, "]");
    }

    return 0;
}

LOCAL int ICACHE_FLASH_ATTR
jsonArray_get(struct jsontree_context *js_ctx)
{
    const char *path = jsontree_path_name(js_ctx, js_ctx->depth - 1);

    if (os_strncmp(path, "K1", os_strlen("K2")) == 0) {
    	jsontree_write_string(js_ctx, "D1");
    } else if (os_strncmp(path, "K2", os_strlen("K2")) == 0) {
    	jsontree_write_string(js_ctx, "D2");
    } else if (os_strncmp(path, "K3", os_strlen("K3")) == 0) {
    	jsontree_write_string(js_ctx, "D3");
    }

    return 0;
}

//初始化一个Json数据回调函数
//JSONTREE_CALLBACK第一个参数为生成Json数据的函数指针，第二个为获取Json数据的函数指针
LOCAL struct jsontree_callback jsonArrayCallback =
    JSONTREE_CALLBACK(jsonArray_get, NULL);

JSONTREE_OBJECT(jsonArrayData,
                JSONTREE_PAIR("K1", &jsonArrayCallback),
                JSONTREE_PAIR("K2", &jsonArrayCallback),
		JSONTREE_PAIR("K3", &jsonArrayCallback));
JSONTREE_ARRAY(jsonArray,
               JSONTREE_PAIR_ARRAY(&jsonArrayData),
               JSONTREE_PAIR_ARRAY(&jsonArrayData),
               JSONTREE_PAIR_ARRAY(&jsonArrayData));

LOCAL struct jsontree_callback jsonCallback =
    JSONTREE_CALLBACK(jsonTree_get, NULL);

JSONTREE_OBJECT(jsonObject,
                JSONTREE_PAIR("String", &jsonCallback),
                JSONTREE_PAIR("Integer", &jsonCallback),
                JSONTREE_PAIR("JsonArray", &jsonArray));
JSONTREE_OBJECT(jsonTestTrees,
                JSONTREE_PAIR("String", &jsonCallback),    //生成一个String键，并设置一个回调函数
		JSONTREE_PAIR("Integer", &jsonCallback),   //生成一个Integer键，并设置一个回调函数
		JSONTREE_PAIR("Array", &jsonCallback),     //生成一个Array键，并设置一个回调函数
		JSONTREE_PAIR("JsonObject", &jsonObject)); //生成一个jsonObject键，并设置一个Json对象
JSONTREE_OBJECT(jsonTestTree,
                JSONTREE_PAIR("jsonTest", &jsonTestTrees));


#define LENGTH 512
char* getJsonTree(void)
{
    static char jsonbuf[LENGTH];
    os_memset(jsonbuf, 0, LENGTH);      //初始化字符串
	json_ws_send((struct jsontree_value *)&jsonTestTree, "jsonTest", jsonbuf);

	//os_printf("%s\n", jsonbuf);

	return jsonbuf;
}




该代码会生成如下Json数据： 

{
    "String": "data",
    "Integer": 1,
    "Array": [
        0,
        1,
        2
    ],
    "JsonObject": {
        "String": "data",
        "Integer": 1,
        "JsonArray": [
            {
                "K1": "D1",
                "K2": "D2",
                "K3": "D3"
            },
            {
                "K1": "D1",
                "K2": "D2",
                "K3": "D3"
            },
            {
                "K1": "D1",
                "K2": "D2",
                "K3": "D3"
            }
        ]
    }
}



五、从Json提取数据

如果网络发送一串JSON数据给ESP8266，如何使用该接口获取JSON的键值呢？下面给出示例代码，这里使用的数据是上面生成的数据。

其中第二次的Json对象数据获取很麻烦，所以传给8266的Json尽量用一层，如果是数组里面再有Json对象，那么就更麻烦了，具体请看代码。

LOCAL int ICACHE_FLASH_ATTR
jsonTree_set(struct jsontree_context *js_ctx, struct jsonparse_state *parser)
{
    int type;

    while ((type = jsonparse_next(parser)) != 0) {
    	//如果是KEY类型
        if (type == JSON_TYPE_PAIR_NAME) {
            char buffer[64];
            os_bzero(buffer, 64);

            if (jsonparse_strcmp_value(parser, "String") == 0) {
                jsonparse_next(parser);	//返回的是冒号字符
                type = jsonparse_next(parser);	//返回的是双引号字符
                os_printf("String Value type = %c\n", type);	// = "

                //如果Value是字符串类型，则读取数据到buffer
                if (JSON_TYPE_STRING == type){	//#define JSON_TYPE_STRING '"'
                	jsonparse_copy_value(parser, buffer, sizeof(buffer));
                	os_printf("String Value = %s\n", buffer);
                }

            } else if (jsonparse_strcmp_value(parser, "Integer") == 0) {
                jsonparse_next(parser);
                type = jsonparse_next(parser);


                os_printf("Integer Value type = %c\n", type);	// = 0
                //如果Value是数值类型
                if(JSON_TYPE_NUMBER == type){	//#define JSON_TYPE_NUMBER '0'
                	//jsonparse_copy_value(parser, buffer, sizeof(buffer));
                	int num = 0;
                	num = jsonparse_get_value_as_int(parser);
                	os_printf("Integer Value = %d\n", num);		// = 1
                }
            } else if (jsonparse_strcmp_value(parser, "Array") == 0) {
                jsonparse_next(parser);	//跳过冒号
                type = jsonparse_next(parser);
                os_printf("Array Value type = %c\n", type);		// = [

                //如果Value是数组类型
                if(JSON_TYPE_ARRAY == type){	//#define JSON_TYPE_ARRAY '['
                	//jsonparse_copy_value(parser, buffer, sizeof(buffer));
                	int length = jsonparse_get_len(parser);
                	os_printf("Array Length = %d\n", length);	//= 5, 数据是[0,1,2]，可能把逗号也算在内

                	int i;
                	int num = 100;
                	//循环读取数组的数据
                	for(i=0; i<length; i++){
                		type = jsonparse_next(parser);
                		// 如果是逗号，则直接打印, 如果是数值则打印0
                		os_printf("Array[%d] type = %c ", i, type);

                		//如果是数值类型，则转换成int并打印出来
                		if(JSON_TYPE_NUMBER==type){
                        	num = jsonparse_get_value_as_int(parser);
                        	os_printf("Array[%d] = %d\n", i, num);
                		}
                		//后面可以添加else if判断是否是其他类型
                		//比如 else if(JSON_TYPE_OBJECT==type),判断是否是Json对象
                		else{
                			os_printf("\n");
                		}
                	}
                }
            }
#if 1
            else if (jsonparse_strcmp_value(parser, "JsonObject") == 0) {
                jsonparse_next(parser);	//跳过冒号
                type = jsonparse_next(parser);
                os_printf("JsonObject Value type = %c\n", type);		// = {

                if(JSON_TYPE_OBJECT == type){	//#define JSON_TYPE_OBJECT '{'
                	int length = jsonparse_get_len(parser);
                	os_printf("JsonObject Length = %d\n", length);

                	//char temp[128] = {0};
                	//jsonparse_copy_value(parser, temp, 128);
                	//os_printf("JsonObject Value = %s\n", temp);

                	//循环读取数据
                	int i = 0;
                	//for(i=0; i<length; i++){
                	while(type != '}'){
                		i++;
                		type = jsonparse_next(parser);

                		os_printf("JsonObject[%d] type = %c", i, type);
                		os_printf("\n");
                		//os_memset(temp, 0, 128);
                    	//jsonparse_copy_value(parser, temp, 128);
                    	//os_printf("JsonObject Value = %s\n", temp);
                		//读取第二层的Json对象的数据
                		jsonObject_set(parser);
                	}
                }

            }
#endif
        }
    }

    return 0;
}

LOCAL int ICACHE_FLASH_ATTR
jsonObject_set(struct jsonparse_state *parser)
{
	int type = jsonparse_get_type(parser);
	int vtype = parser->vtype;
	//os_printf("json Object type=%c, vtype=%c\n", type, vtype);
	char buffer[64];
	os_bzero(buffer, 64);

	//如果是KEY类型
	if (vtype == JSON_TYPE_PAIR_NAME) {
	   if (jsonparse_strcmp_value(parser, "String") == 0) {
			jsonparse_next(parser);	//返回的是冒号字符
			type = jsonparse_next(parser);	//返回的是双引号字符
			//os_printf("jsonObject String Value type = %c\n", type);	// = "

			//如果Value是字符串类型，则读取数据到buffer
			if (JSON_TYPE_STRING == type){	//#define JSON_TYPE_STRING '"'
				jsonparse_copy_value(parser, buffer, sizeof(buffer));
				os_printf("jsonObject String Value = %s\n", buffer);
			}

		} else if (jsonparse_strcmp_value(parser, "Integer") == 0) {
			jsonparse_next(parser);
			type = jsonparse_next(parser);
			//os_printf("jsonObject Integer Value type = %c\n", type);	// = 0
			//如果Value是数值类型
			if(JSON_TYPE_NUMBER == type){	//#define JSON_TYPE_NUMBER '0'
				//jsonparse_copy_value(parser, buffer, sizeof(buffer));
				int num = 0;
				num = jsonparse_get_value_as_int(parser);
				os_printf("jsonObject Integer Value = %d\n", num);		// = 1
			}
		} else if (jsonparse_strcmp_value(parser, "JsonArray") == 0) {
			jsonparse_next(parser);
			type = jsonparse_next(parser);
			//os_printf("jsonObject Integer Value type = %c\n", type);	// = 0
			//如果Value是数值类型
			if(JSON_TYPE_ARRAY == type){
				//jsonparse_copy_value(parser, buffer, sizeof(buffer));
				//os_printf("buffer = %s\n", buffer);
            	int length = jsonparse_get_len(parser);
            	os_printf("JsonArray Length = %d\n", length);	//读取出来的长度不准确

            	//循环读取Json对象数据
				int i = 0;
				//for(i=0; i<length; i++){
				while(type != ']'){i++;		//用']'判断是否达到数组末尾

					type = jsonparse_next(parser);

					os_printf("JsonArray[%d] type = %c", i, type);
					os_printf("\n");

					//如果是KEY类型
					if (type == JSON_TYPE_PAIR_NAME) {
					   if (jsonparse_strcmp_value(parser, "K1") == 0) {
							jsonparse_next(parser);	//返回的是冒号字符
							type = jsonparse_next(parser);	//返回的是双引号字符
							//os_printf("K1 Value type = %c\n", type);	// = "

							//如果Value是字符串类型，则读取数据到buffer
							if (JSON_TYPE_STRING == type){	//#define JSON_TYPE_STRING '"'
								os_bzero(buffer, 64);
								jsonparse_copy_value(parser, buffer, sizeof(buffer));
								os_printf("K1 = %s\n", buffer);
							}
						} else if(jsonparse_strcmp_value(parser, "K2") == 0){
							jsonparse_next(parser);	//返回的是冒号字符
							type = jsonparse_next(parser);	//返回的是双引号字符
							//如果Value是字符串类型，则读取数据到buffer
							if (JSON_TYPE_STRING == type){	//#define JSON_TYPE_STRING '"'
								os_bzero(buffer, 64);
								jsonparse_copy_value(parser, buffer, sizeof(buffer));
								os_printf("K2 = %s\n", buffer);
							}
						} else if(jsonparse_strcmp_value(parser, "K3") == 0){
							jsonparse_next(parser);	//返回的是冒号字符
							type = jsonparse_next(parser);	//返回的是双引号字符
							//如果Value是字符串类型，则读取数据到buffer
							if (JSON_TYPE_STRING == type){	//#define JSON_TYPE_STRING '"'
								os_bzero(buffer, 64);
								jsonparse_copy_value(parser, buffer, sizeof(buffer));
								os_printf("K3 = %s\n", buffer);
							}
						}
					}
				}
			}
		}
	}
}



LOCAL int ICACHE_FLASH_ATTR
jsonArray_set(struct jsontree_context *js_ctx, struct jsonparse_state *parser)
{
	int type;

	while ((type = jsonparse_next(parser)) == 0) {
		//如果是KEY类型
		if (type == JSON_TYPE_PAIR_NAME) {
			char buffer[64];
			os_bzero(buffer, 64);

			if (jsonparse_strcmp_value(parser, "K1") == 0) {
                if (JSON_TYPE_STRING == type){	//#define JSON_TYPE_STRING '"'
                	jsonparse_copy_value(parser, buffer, sizeof(buffer));
                	os_printf("K1 Value = %s\n", buffer);
                }
			} else if (jsonparse_strcmp_value(parser, "K2")==0) {
                if (JSON_TYPE_STRING == type){	//#define JSON_TYPE_STRING '"'
                	jsonparse_copy_value(parser, buffer, sizeof(buffer));
                	os_printf("K2 Value = %s\n", buffer);
                }
			} else if (jsonparse_strcmp_value(parser, "K3")==0) {
                if (JSON_TYPE_STRING == type){	//#define JSON_TYPE_STRING '"'
                	jsonparse_copy_value(parser, buffer, sizeof(buffer));
                	os_printf("K3 Value = %s\n", buffer);
                }
			}
		}
	}

    return 0;
}




void ICACHE_FLASH_ATTR
setJsonTree(char *json)
{
    struct jsontree_context js;

    jsontree_setup(&js, (struct jsontree_value *)&jsonTestTree, json_putchar);
    json_parse(&js, json);
}

void ICACHE_FLASH_ATTR
setJsonObject(char *json)
{
    struct jsontree_context js;

    jsontree_setup(&js, (struct jsontree_value *)&jsonObject, json_putchar);
    json_parse(&js, json);
}


最后要修改一下这条语句，给jsonCallback第二个参数添加jsonTree_set。

LOCAL struct jsontree_callback jsonCallback =
    JSONTREE_CALLBACK(jsonTree_get, jsonTree_set);

打印：

String Value type = "
String Value = data
Integer Value type = 0
Integer Value = 1
Array Value type = [
Array Length = 5
Array[0] type = 0 Array[0] = 0
Array[1] type = , 
Array[2] type = 0 Array[2] = 1
Array[3] type = , 
Array[4] type = 0 Array[4] = 2
JsonObject Value type = {
JsonObject Length = 10
JsonObject[1] type = N
jsonObject String Value = data
JsonObject[2] type = ,
JsonObject[3] type = N
jsonObject Integer Value = 1
JsonObject[4] type = ,
JsonObject[5] type = N
JsonArray Length = 9
JsonArray[1] type = {
JsonArray[2] type = N
K1 = D1
JsonArray[3] type = ,
JsonArray[4] type = N
K2 = D2
JsonArray[5] type = ,
JsonArray[6] type = N
K3 = D3
JsonArray[7] type = }
JsonArray[8] type = ,
JsonArray[9] type = {
JsonArray[10] type = N
K1 = D1
JsonArray[11] type = ,
JsonArray[12] type = N
K2 = D2
JsonArray[13] type = ,
JsonArray[14] type = N
K3 = D3
JsonArray[15] type = }
JsonArray[16] type = ,
JsonArray[17] type = {
JsonArray[18] type = N
K1 = D1
JsonArray[19] type = ,
JsonArray[20] type = N
K2 = D2
JsonArray[21] type = ,
JsonArray[22] type = N
K3 = D3
JsonArray[23] type = }
JsonArray[24] type = ]
JsonObject[6] type = }


六、代码下载

如果想要示例代码，可以从这里下载：http://download.csdn.net/detail/u012163234/9638834




阏男秀
关注
  • 12
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
ESP8266 API接口调用
perseverance51博客
07-23 1569
ESP8266 API接口调用 目的：通过调用API接口来获取指定网站返回数据 API接口网站：https://developer.hitokoto.cn/sentence/#%E7%AE%80%E4%BB%8B API接口调用程序 /********************************************************************** 程序名称/Project : API接口调用 ***********************************
ESP8266使用官方Json接口的例程
09-24
ESP8266使用官方Json接口的例程 对应的技术文章：http://blog.csdn.net/yannanxiu/article/details/50911357
ESP8266系列入门教程
最新发布
2301_79990172的博客
06-23 1029
ESP8266 系列无线模块是安信可科技自主研发设计的一系列高性价比 Wi-Fi SoC 模组。该系列模块支持标准的 IEEE802.11 b/g/n 协议，内置完整的TCP/IP 协议栈。用户可以使用该系列模块为现有的设备添加联网功能，也可以构建独立的网络控制器。安信可科技为客户提供完整的硬件、软件参考方案，以便缩短您的产品研发周期，为您节省成本投入。1.1产品特性体积超小的 802.11b/g/n Wi-Fi SoC 模块采用低功率 32 位 CPU，可兼作应用处理器。
ESP8266 Non-OS SDK API参考
01-03
ESP8266 Non-OS SDK API参考,提供了API接口，可以查询，利于硬件开发
ESP8266_NONOS_SDK_esp8266sdk_
10-02
本文件为ESP8266 nonos 的 官方 sdk，可直接使用进行编辑 开发。
ESP8266 Non-OS SDK API参考.pdf
10-06
本⽂文档提供 ESP8266_NONOS_SDK 的 API 说明，版本3.0.1（2019.03）
esp8266_non_os_sdk_api中文文档目录分级版.pdf
09-17
和官方的文档内容一样，但是官方文档的书签没有分级导致查找困难，我手动对目录进行了分级方便大家使用
ESP8266常用API函数总结（vscode+platformIO）
weixin_48819160的博客
08-23 1054
个人总结ESP系列芯片常用API函数，开发环境：vscode+platformIO 如果有环境配置问题，欢迎留言
ESP8266使用AT指令进行API访问
Gear Long 的博客
05-18 3479
今天看到了一个有关使用 ESP8266的AT指令 的HTTP连接的demo，因此想拿来一试， 访问API试一下，简单访问 心知天气 天气服务平台的地区天气接口测试一下 (万物基于API，你细品) 本文仅发布在CSDN 青云双青 和我的个人博客，其他地方出现均为搬运 需要准备的 NodeMCU开发板一个 （ESP-12E） Flash Download Tools 烧录软件一个 AT指令的固件 已经注册成功的心知天气的API接口一个(下面这个可以直接使用) https://api.seniverse.
Arduino IDE for ESP8266 （0） 官方API
a83025273的博客
01-15 846
http://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/readme.html 0简单的连接到WIFI #include <ESP8266WiFi.h> void setup() { Serial.begin(115200); Serial.println(); Wi...
esp8266-NodeMCU-API中文说明
02-19
esp8266在lua编程时调用API说明，英语不好的同学，应该有帮助，资料来源也可以百度
ESP8266 Non-OS SDK API 参考
03-12
ESP8266EX 拥有完整的且⾃成体系的 Wi-Fi ⽹络功能，既能够独⽴应⽤，也可以作为从机搭载于其他主机 MCU 运⾏。当 ESP8266EX 独⽴应⽤时，能够直接从外接 Flash 中启动。内置的⾼速缓冲存储器有利于提⾼系统性能，并且优化存储系统。此外 ESP8266EX只需通过 SPI/SDIO 接⼝或 I2C/UART ⼝即可作为 Wi-Fi 适配器，应⽤到基于任何微控制器的设计中。
NodeMCU ESP8266 外设的 Arduino API 接口介绍
一名热爱技术的工程师的博客。分享技术干货，记录美好生活。永远相信美好的事情即将发生。
10-07 1713
Arduino在硬件上做了相应的封装，新的硬件需要兼容Arduino的接口。比如NodeMCU ESP8266的底层硬件做一次封装，对用户需要开放出来规定好的接口。
ESP8266-5-使用API获取知心天气数据
qq_52940987的博客
10-26 860
这里直接在知心天气建立一个免费项目就可以了，免费用户只返回天气现象文字、代码和气温 3 项数据。API秘钥就是代码里的key，某些版本的esp8266的固件编译报错找不到urequests模块，则需要自己去Thonny下载。首先让esp8266连接网络。然后建立main.py。写在boot就可以了。
从零开始的ESP8266探索（13）-Arduino for esp8266特有API说明
Naisu的各种笔记
12-29 6442
目的 本文介绍了Arduino for esp8266中特有API说明 特有API说明 睡眠模式及系统软复位 使用ESP.deepSleep(microseconds, mode)可以使ESP8266进入睡眠模式，其中microseconds为睡眠时间，mode为睡眠唤醒后工作模式，参数如下： WAKE_RF_DEFAULT : do or not do the radio calibrati...
ESP8266解析JSON数据
FristLineCode的博客
11-11 5478
使用官方提供的user_json.c和user_json.h。 假设服务器传过来的json数据为   {"v":1} 。 先说明一下几个必要的函数： 1: jsontree_setup(&js,(struct jsontree_value *)&msg_tree,json_putchar); //生成JSON树格式 这个函数的意思应该是让js和自己建的一个msg_tree建立起联系，
esp8266解析json数据
qq_40850266的博客
03-15 1308
#include <ArduinoJson.h> void setup() { Serial.begin(115200); Serial.println("这里用于测试json数据的解析"); // DynamicJsonDocument对象 定义时候我们需要定义一个大小信息+复制大小 const size_t capacity = JSON_OBJECT_SIZE(2) + 30; DynamicJsonDocument doc(capacity); // 要解析
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值