Repository: alibaba/AliOS-Things (language: python)

Issue:
[Bug Report]: HaaS EDU K1创意案例缺少README.md
### 联系方式

_No response_

### 您发现了什么问题

A bug happened!
运行环境:
固件版本:
HaaS EDU K1创意案例缺少README.md

### 分支

master (Default)

### 请选择您发现此问题的解决方案名称

_No response_

### 日志

_No response_


Discussion / hints:

Fix patch:
diff --git a/haas_lib_bundles/python/README.md b/haas_lib_bundles/python/README.md
index 457fdefa4f..f7cb1cc4ec 100644
--- a/haas_lib_bundles/python/README.md
+++ b/haas_lib_bundles/python/README.md
@@ -1,86 +1,5 @@
 # HaaS Python
 
-## HaaS Python快速开始
-
-&emsp;&emsp;
-对于初学者，我们建议您从开发板快速开始入门。
-* [ESP32快速开始](docs/startup/ESP32_startup.md)
-* [HaaS100快速开始](docs/startup/HaaS100_startup.md)
-* [HaaS EDU K1快速开始](docs/startup/HaaS_EDU_K1_startup.md)
-* [HaaS506快速开始](docs/startup/HaaS506_startup.md)
-
-&emsp;&emsp;
-快速入门完成之后，建议您进入HaaS Python官网中[趣味案例专区](https://haas.iot.aliyun.com/solution)，趣味对应的markdown文档链接如下：
-* ESP32开发板
-  * [起夜灯](./docs/examples/human_detector/esp32/README.md)
-  * [燃气检测系统](./docs/examples/gas_detector/esp32/README.md)
-  * [甲醛检测系统](./docs/examples/hcho_detector/esp32/README.md)
-  * [花卉养植](./docs/examples/floriculture/esp32/README.md)
-  * [火焰检测](./docs/examples/fire_detector/esp32/README.md)
-  * [智慧路灯](./docs/examples/smart_public_lighting/esp32/README.md)
-  * [车辆定位](./docs/examples/vehicle_location/esp32/README.md)
-
-&emsp;&emsp;
-如果您想更详细的了解如何从浅到深完成一个完整的物联网应用的开发，建议您进入我们的[学习中心](https://haas.iot.aliyun.com/learning)进行学习。
-
-
-&emsp;&emsp;
-如果您想看HaaS Python都提供哪些库及其API说明，请点击如下链接查看。
-* MicroPython标准API
-
-|库名称|库说明|超链接|
-|:-:|:-|:-:|
-|math|数学函数|[点我查看说明](docs/standard_api/math.md)|
-|ubinascii|二进制/ASCII转换|[点我查看说明](docs/standard_api/ubinascii.md)|
-|ucollections|容器|[点我查看说明](docs/standard_api/ucollections.md)|
-|uhashlib|散列算法|[点我查看说明](docs/standard_api/uhashlib.md)|
-|uio|输入/输出流|[点我查看说明](docs/standard_api/uio.md)|
-|ujson|JSON编解码|[点我查看说明](docs/standard_api/json.md)|
-|uos|基础系统操作模块|[点我查看说明](docs/standard_api/uos.md)|
-|usocket|socket模块|[点我查看说明](docs/standard_api/usocket.md)|
-|ustruct|打包和解压原始数据类型|[点我查看说明](docs/standard_api/ustruct.md)|
-|sys|系统相关函数|[点我查看说明](docs/standard_api/sys.md)|
-|utime|时间相关函数|[点我查看说明](docs/standard_api/utime.md)|
-|uzlib|zlib解压缩|[点我查看说明](docs/standard_api/uzlib.md)|
-|_thread|底层多线程|[点我查看说明](docs/standard_api/_thread.md)|
-|bluetooth|蓝牙BLE功能|[点我查看说明](docs/standard_api/bluetooth.md)|
-
-* HaaS Python扩展API
-
-|库名称|库说明|超链接|
-|:-|:-|:-:|
-|aliyunIoT Device|物联网平台设备类功能|[点我查看说明](docs/haas_extended_api/aliyunIoT/device.md)|
-|aliyunIoT Gateway|物联网平台网关类功能|[点我查看说明](docs/haas_extended_api/aliyunIoT/gateway.md)|
-|kv|键值对存储系统|[点我查看说明](docs/haas_extended_api/kv.md)|
-|OSS|阿里云存储服务|[点我查看说明](docs/haas_extended_api/oss.md)|
-|audio| 音频录制和播放|[点我查看说明](docs/haas_extended_api/audio.md)|
-|bleNetConfig|蓝牙配网功能|[点我查看说明](docs/haas_extended_api/bleNetConfig.md)|
-|http|HTTP模块|[点我查看说明](docs/haas_extended_api/http.md)|
-|modbus|Modbus协议|[点我查看说明](docs/haas_extended_api/modbus.md)|
-|ulog|log分级打印模块|[点我查看说明](docs/haas_extended_api/ulog.md)|
-|OTA|Python轻应用在线更新|[点我查看说明](docs/haas_extended_api/ota.md)|
-|ucamera| 摄像头功能模块|[点我查看说明](docs/haas_extended_api/ucamera.md)|
-|AI|人工智能功能模块|[点我查看说明](docs/haas_extended_api/AI.md)|
-
-* HaaS Python硬件积木驱动库
-
-|硬件积木名称|功能|Python驱动库|
-|:-|:-|:-:|
-|aht21b|温湿度传感器库|[库文件](./libraries/aht21b)|
-|sht3x|温湿度传感器库|[库文件](./libraries/sht3x)|
-|si7006|温湿度传感器库|[库文件](./libraries/si7006)|
-|cht8305|温湿度传感器库|[库文件](./libraries/cht8305)|
-|ir|人体感应传感器|[库文件](./libraries/ir)|
-|dcmotor|直流电机|[库文件](./libraries/dcmotor)|
-|fire|火焰传感器|[库文件](./libraries/fire)|
-|ap3216c|光照传感器|[库文件](./libraries/ap3216c)|
-|mq2|燃气/烟雾传感器|[库文件](./libraries/mq2)|
-|photoresistor|光敏传感器|[库文件](./libraries/photoresistor)|
-|hcho|甲醛传感器|[库文件](./libraries/hcho)|
-|gnss|GPS传感器|[库文件](./libraries/gnss)|
-
-更多关于硬件积木的介绍、API使用文档及对应的案例文档请参考[链接](https://gitee.com/haasedu/haasedu/blob/release_2.0/%E6%8B%93%E5%B1%95%E7%9F%A5%E8%AF%86/HaaS%E7%A1%AC%E4%BB%B6%E7%A7%AF%E6%9C%A8%E5%BA%93/%E4%BC%A0%E6%84%9F%E5%99%A8%E7%A1%AC%E4%BB%B6%E7%A7%AF%E6%9C%A8/README.md#/haasedu/haasedu/blob/master/%E6%8B%93%E5%B1%95%E7%9F%A5%E8%AF%86/HaaS%E7%A1%AC%E4%BB%B6%E7%A7%AF%E6%9C%A8%E5%BA%93/%E4%BC%A0%E6%84%9F%E5%99%A8%E7%A1%AC%E4%BB%B6%E7%A7%AF%E6%9C%A8/%E6%B8%A9%E6%B9%BF%E5%BA%A6%E4%BC%A0%E6%84%9F%E5%99%A8_SHT3X-DIS.md)。
-
 ## HaaS Python背景
 
 &emsp;&emsp;
@@ -95,13 +14,16 @@ MicroPython开源项目中主要包含四部分内容：轻量级的Python解释
 &emsp;&emsp;
 HaaS Python是阿里云IoT团队最新研发的一套低代码编程框架，兼容MicroPython编程规范，依托HaaS平台软硬件积木提供AI、支付、蓝牙配网、云连接、UI等物联网场景常用的能力，从而解决了物联网应用开发难的问题。有了Python轻应用框架，物联网编程不再局限于专业软件开发人员，一般的技术员也可以快速实现复杂的物联网需求。
 
-### HaaS Python特点
+## HaaS Python特点
 1. 更好的解决数据上云问题
 
 &emsp;&emsp;
 物联网中最常用的场景是数据上云及远程设备控制，针对这点，Python轻应用提供了简单易用支持Python应用快速移植的硬件访问接口Driver库及包括Socket，HTTP，HTTPS，Websocket，MQTT及aliyunIoT（连接阿里云物联网平台的SDK）在内的多种网络功能。以下是基于Python轻应用框架实现远程控制开发板LED灯的例子。可以看出只需要数十行代码(以ESP32平台为例)就可以完成物联网设备数据上云及远程控制的功能。
 
 
+ <details>
+ <summary>数据上云示例代码</summary>
+
  ```python
 
  '''
@@ -242,13 +164,14 @@ if __name__ == '__main__' :
    connect_lk(productKey, deviceName, deviceSecret)
 
  ```
+ </details>
 
 2. 丰富的垂直解决方案
 
 &emsp;&emsp;
 HaaS云端解决方案中心包含大量软硬一体应用案例，覆盖连云、控端、AI、UI等IoT设备常见应用。开发者可以基于这些案例快速定制物联网产品。
 
-1. 背靠阿里生态，不止有端，还有云
+3. 背靠阿里生态，不止有端，还有云
 
 &emsp;&emsp;
 Python轻应用不仅仅是一个端上开发框架，它还背靠阿里生态，提供强大的云端能力。除了提供物联网常用的设备管理、远程控制、数据报表、异常预警等能力以外，还提供了支付宝支付能力、天猫精灵语音识别和语义理解能力、达摩院数视觉算法能力及高德地图能力等。
@@ -263,6 +186,8 @@ Python轻应用不仅仅是一个端上开发框架，它还背靠阿里生态
 &emsp;&emsp;
 HaaS开发者钉钉群提供7*24小时技术支持。HaaS供需平台，帮HaaS开发者实现商业链路闭环。每月一次Python轻应用开发者月会，开发者提出的需求和建议通过阿里内部任务系统跟进，并通过HaaS微发布向开发者反馈最新进展。Python轻应用的开发团队还提供了一套详细的编程文档，其中包括如何在不同的HaaS开发板上完成快速上手的文章、最新编程接口的详细介绍及参考用法（其中包括Python轻应用在物联网场景的垂直使用案例），基于这套文档及技术支持体系，开发者只需要一两天就可以学会Python轻应用。
 
+## HaaS Python快速开始
+如何快速开始你的HaaS Python之旅，请参考[链接](https://haas.iot.aliyun.com/haasapi/index.html#/Python/docs/zh-CN/startup/startup)。
 
 ## 了解更多
 &emsp;&emsp;
@@ -271,5 +196,5 @@ HaaS开发者钉钉群提供7*24小时技术支持。HaaS供需平台，帮HaaS
 &emsp;&emsp;
 如果您对HaaS有任何疑问或建议，也欢迎进群提给我们。
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/imgs/HaaS社区.png  width=100%/>
+<img src=https://img.alicdn.com/imgextra/i3/O1CN01aYBmpk1kG2REDqZNM_!!6000000004655-2-tps-2240-880.png width=100%/>
 </div>
diff --git a/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/README.md b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/README.md
new file mode 100644
index 0000000000..b619c65a21
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/README.md
@@ -0,0 +1,556 @@
+# 火焰检测系统
+&emsp;&emsp;
+下图是本案例除硬件连线外的3步导学，每个步骤中实现的功能请参考图中的说明。在硬件连线完成之后我们建议您先使用“一分钟上云体验”功能预先体验本案例的实际运行效果。
+<div align="center">
+<img src=./../../../images/4_fire_detector_步骤概述.jpg width=60%/>
+</div>
+
+## 1、简介
+
+&emsp;&emsp;
+自从第一次工业革命开始到现代，化石燃料一直是很重要的能源之一，而煤在化石燃料中占比较高。煤转化成能量需要燃烧，不管是第一次工业革命的内燃机还是现在仍然占比很高的火力发电，都需要大量的烧煤。现代的火力发电系统会持续对炉膛中煤的燃烧情况进行监控，防止出现燃煤熄灭的情况。
+本场景就是针对这个场景对火焰进行实时的监控，如果出现火焰熄灭的情况，则进行灯光报警。
+
+### 1.1、背景知识
+
+&emsp;&emsp;
+火力发电系统中所用的火焰监控的核心在于如何精准的检测炉膛中的火焰强度，目前市场上已经有很多的传感器可以对火焰强度进行测量。
+目前市面上用的最多的火焰传感器，即红外接收二极管，对火焰特别敏感。它对火焰产生的红外线非常敏感，当火焰亮度越大时，发出的红外线越多，火焰传感器管脚间的阻抗变小；当火焰变小时，发出的红外线变少，火焰传感器管脚间的阻抗变大。
+本节选用的火焰传感器外观如下：
+<div align="center">
+<img src=./../../../images/4_火焰传感器外观图.png width=40%/>
+</div>
+<br>
+
+### 1.2、准备
+
+&emsp;&emsp;
+完成本案例需要如下硬件：
+1. [HaaS EDU K1开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C5AB3B8A4A88800000001&dataId=800C5AB3B8A4A888)   一台
+2. [火焰传感器](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C65AE63D505D100000002&dataId=800C65AE63D505D1)               一个
+3. 连接线若干
+
+&emsp;&emsp;
+硬件连线图如下图所示：
+<div align="center">
+<img src=./../../../images/4_HaaS_EDU_K1_火焰传感器连线图.png width=90%/>
+</div>
+<br>
+
+## 2、物联网平台开发
+&emsp;&emsp;
+对于第一次使用物联网平台的读者，需要开通实例以使用物联网平台的功能。这里可以使用免费的公共实例进行开发。
+
+&emsp;&emsp;
+在[物联网平台](https://iot.console.aliyun.com/lk/summary/new)中，左上角选择“华东2-上海”，点击“公共实例”，即可开通。
+
+<div align="center">
+<img src=./../../../images/5_3_开通公共实例.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+开通物联网平台功能之后，需要完成下面的3个步骤完成云端设备的创建：
+1. 创建云端产品
+2. 创建产品属性（物模型）
+3. 创建云端设备（获取三元组）
+
+<br>
+
+### 2.1、创建云端产品
+&emsp;&emsp;
+点击上图中的“公共实例”，即可进入[控制台](https://iot.console.aliyun.com/lk/summary/new)进行产品创建。然后，创建云端产品的网址：https://iot.console.aliyun.com/product
+
+&emsp;&emsp;
+点击创建产品按钮，如下图所示。
+
+<div align="center">
+<img src=./../../../images/1_创建产品.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+在新建产品设定页面按照下图所示，设定“产品名称”，选择所属的“自定义品类”（自定义品类的物模型为空，需要自己创建，也可以通过导入外部物模型的方式导入），节点类型选择“直连设备”，联网方式选择“Wi-Fi”，数据格式选择“ICA标准数据格式”，检验类型和认证方式选择默认设定即可。还可以根据开发者自己的需求在“产品描述”页面添加针对此产品的描述。
+<div align="center">
+<img src=./../../../images/4_新建火焰检测设备.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+选择之后，点击“确认”按钮，即可完成产品创建。返回“产品”页面之后可以看到产品类表中会出现刚刚创建的“火焰检测系统”的产品，如下图所示。
+
+<div align="center">
+<img src=./../../../images/4_火焰检测系统_产品列表页.png width=100%/>
+</div>
+
+
+<br>
+
+### 2.2、创建产品属性（物模型）
+&emsp;&emsp;
+点击上图中的“查看”按钮，即可看到产品信息，Topic列表，功能定义，数据解析等跟产品相关功能的设定。点开“功能定义”标签页，可以看到设备物模型定义。
+
+<div align="center">
+<img src=./../../../images/4_火焰检测系统_产品详情页面.png width=100%/>
+</div>
+
+
+
+&emsp;&emsp;
+标识符是设备端上报设备属性状态的消息中需要使用的标识符，并且只有在设备上报的属性内容符合“数据定义”中的数据取值范围的时候才会被物联网平台记录，否则会被物联网平台认定为非法属性而过滤掉。
+
+&emsp;&emsp;
+本节我们选择导入物模型的方式来创建此系统需要的物模型信息，点击上图中的”编辑草稿“按钮。然后按照下图的步骤，选择本地文件[火焰检测系统物模型](./link_platform/fire_detector_model.zip)进行导入。
+
+<div align="center">
+<img src=./../../../images/4_火焰检测系统_发布物模型.png width=100%/>
+</div>
+
+
+&emsp;&emsp;
+物模型导入成功后可以看到网页出现了我们刚刚导入的物模型属性。其中alarmState代表的是火焰的报警状态，1处于报警状态，0代表没有报警；fireVoltage代表火焰传感器检测到的电压值。
+
+
+<div align="center">
+<img src=./../../../images/4_火焰检测系统_物模型.png width=100%/>
+</div>
+&emsp;&emsp;
+产品及其物模型创建完成后，就可以创建这个产品的设备了。
+
+<br>
+
+### 2.3、创建云端设备（获取三元组）
+&emsp;&emsp;
+在产品列表页面中，点击”火焰检测系统“后的“管理设备”，就会进到设备管理页面。
+
+<div align="center">
+<img src=./../../../images/4_火焰检测系统_产品页_管理设备.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“设备”页面点击“添加设备”按钮，如下图所示。
+<div align="center">
+<img src=./../../../images/4_火焰传感器_添加设备入口.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“添加设备”页面中设定“deviceName”，这里开发者可以自己填入自己想设定的设备名称，也可以不填任何内容让系统自动生成设备名称，如下图所示。
+<div align="center">
+<img src=./../../../images/1_添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备添加完成后，点击“前往查看”按钮，就可以看到此设备端详细信息了。
+<div align="center">
+<img src=./../../../images/1_完成添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备信息中有两个信息需要和设备端开发相匹配：
+1. 三元组
+2. 物模型属性信息
+
+<div align="center">
+<img src=./../../../images/4_火焰检测系统_设备详情.png width=100%/>
+</div>
+
+<br>
+
+#### 2.4.1、**获取设备三元组**
+&emsp;&emsp;
+如上图所示，点击“查看”按钮，就可以看到设备的三元组信息，三元组是物联网设备端和物联网云端设备相关联的唯一标识符，在设备端连接云端的时候会使用三元组信息和云端进行鉴权，鉴权通过之后云端会认为设备已激活并上线。
+
+<div align="center">
+<img src=./../../../images/4_火焰检测系统_设备三元组.png width=50%/>
+</div>
+
+<br>
+
+#### 2.4.2、**查看设备属性信息**
+&emsp;&emsp;
+设备详情信息页中的“物模型数据”标签页中可以看到设备的所有属性信息、设备时间上报情况及设备服务调用情况，如下图所示。待物联网设备按照设备属性对应的标识符上报设备属性的时候，本图片中的“火焰检测电压“，”报警状态“等属性值就会显示设备最新的属性信息。
+<div align="center">
+<img src=./../../../images/4_火焰检测系统_设备物模型数据.png width=100%/>
+</div>
+
+<br>
+
+> 创建产品和设备的过程是按照面向对象的思想进行设计的，其中创建产品可以看成是新建一个类，其中的物模型则是类的对象，创建设备则是进行类的实例化。
+
+<br>
+
+## 3、设备端开发
+
+### 3.1、开发环境
+&emsp;&emsp;
+在进行下一步之前请确保HaaS EDU K1开发环境已经搭建完毕。详情请参考[HaaS EDU K1 快速开始](../../../startup/HaaS_EDU_K1_startup.md)的说明。
+<br>
+
+### 3.2、创建解决方案
+
+&emsp;&emsp;
+如下图所示，在Haas Studio中创建项目。先选择左侧的“开发板型号”再从右侧的案例中选择“火焰检测系统”案例点击“立即创建”即可。
+
+<div align="center">
+<img src=./../../../images/HaaS_Studio_创建工程示范.png width=100%/>
+</div>
+<br>
+
+1. **修改路由器名称及密码**
+
+&emsp;&emsp;
+修改工程里main.py中wifiSsid和wifiPassword的值为读者实际要连接的路由器的名称及密码（请注意名称和密码都需要放在""符号中间）。
+
+```python
+# Wi-Fi SSID和Password设置
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+```
+
+&emsp;&emsp;
+修改完成之后get_wifi_status函数中的wlan.connect(wifiSsid, wifiPassword) 语句就会连接读者自己设定的路由器。
+
+2. **修改设备端三元组**
+
+&emsp;&emsp;
+修改fire_detector工程里main.py中productKey、deviceName和deviceSecret的值为读者创建的物联网设备的三元组信息。
+
+```python
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+```
+
+3. **修改设备端上报数据所用标识符**
+
+&emsp;&emsp;
+fire_detector工程里main.py中下面的代码实现的是上传火焰检测结果和报警灯状态到云端的功能。其中fireVoltage便是火焰检测结果上报云端所用的标识符。
+```python
+# 无限循环
+while True:
+    # 获取电压值
+    fireVoltage = fireDev.getVoltage()
+    print("The fire status Voltage ",fireVoltage)
+
+    # 生成上报到物联网平台的属性值字串，此处的属性标识符"fireVoltage"和"alarmState"必须和物联网平台的属性一致
+    # "fireVoltage" - 代表火焰传感器测量到的电压值
+    # "alarmState" - 代表报警灯的当前状态
+    upload_data = {'params': ujson.dumps({
+        'fireVoltage': fireVoltage,
+        'alarmState': alarm_on
+    })
+    }
+    # 上传火焰传感器测量结果和报警灯状态到物联网平台
+    device.postProps(upload_data)
+
+    # 每2秒钟上报一次
+    utime.sleep(2)
+```
+<br>
+
+## 4、物联网应用开发
+
+### 4.1、火焰亮度监控系统
+&emsp;&emsp;
+下图是一个典型的物联网应用程序开发的流程图，接下来本节就按照这个流程介绍如何完成火焰监控系统web端应用程序的开发。
+
+<div align="center">
+<img src=./../../../images/1_物联网应用开发的一般流程.png width=30%/>
+</div>
+
+<br>
+
+### 4.2、**新建“普通项目”**
+&emsp;&emsp;
+打开[IoT Studio官网](https://studio.iot.aliyun.com/)，在项目管理中创建一个空白项目，如下图所示，将此项目命名为“火焰监控报警系统”。
+<div align="center">
+<img src=./../../../images/4_火焰监控报警系统_创建IoTStudio项目.png width=80%/>
+</div>
+
+<br>
+
+### 4.3、**新建“web应用”**
+&emsp;&emsp;
+新建“普通项目”之后，在新项目的首页新建一个web应用，命名为“火焰实时监控”。
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_web应用创建.png width=80%/>
+</div>
+
+
+&emsp;&emsp;
+web应用创建成功后会进入到应用界面设计页面。
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_移动应用_页面编辑页.png width=80%/>
+</div>
+
+
+&emsp;&emsp;
+点击上图红框中的“组件”按钮图标，就可以看到可用的组件列表。各组件的说明请参考[IoT Studio组件说明](https://help.aliyun.com/document_detail/125196.html)。
+
+<br>
+
+### 4.4、**页面设计**
+&emsp;&emsp;
+这里我们用到3个组件:
+* 实时曲线
+用于显示火焰亮度的历史变化曲线及实时数据
+* 指示灯
+显示和控制空调和火焰的当前报警状态
+* 设备地图
+用于显示设备所在位置
+
+将三个组件拖到中间的画布区，适当调整组件布局，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_火焰监控系统_实时监控页面设计.png width=80%/>
+</div>
+
+<br>
+
+### 4.5、**关联产品和设备**
+&emsp;&emsp;
+此时回到”火焰监控系统“项目的主页，对产品和设备进行关联，如下图所示：
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_关联产品和设备.png width=80%/>
+</div>
+
+
+&emsp;&emsp;
+关联产品和设备的过程如下，选中左下角的“关联产品的同时关联其下所有设备”之后 ，该产品下创建的所有的产品都会被关联到这个项目中。
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_关联产品和设备.png width=80%/>
+</div>
+
+&emsp;&emsp;
+产品和设备关联完毕之后，就可以将把组件和设备的属性关联起来了。
+
+<br>
+
+### 4.6、**关联数据源**
+&emsp;&emsp;
+关联数据源分为如下3个步骤，每个步骤的截图如下：
+* 关联产品
+* 关联设备
+* 关联属性
+
+&emsp;&emsp;
+具体操作步骤如下：
+1. 选中”指示灯“组件，点击右侧的“配置数据源”。
+
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_指示灯_配置数据源.png width=80%/>
+</div>
+
+2. 选择目标产品
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_指示灯_选择产品.png width=80%/>
+</div>
+
+3. 选择目标设备
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_开关_配置数据源_设备.png width=80%/>
+</div>
+
+
+4. 选择“报警灯”属性
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_指示灯_配置数据源_报警灯.png width=80%/>
+</div>
+
+&emsp;&emsp;
+选择好产品、设备和属性之后，需要修改指示灯大小及其展示样式（设置为图片），并且分别为”开始报警“/”停止报警“两种状态上传图片，如下图所示。图片位于[开启报警](../../../images/4_火焰燃烧示意图.png)和[关闭报警](../../../images/4_火焰熄灭示意图.png)。
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_指示灯_配置数据源_报警灯图片.png width=80%/>
+</div>
+
+
+&emsp;&emsp;
+同样的方式为”实时曲线“设置为目标设备的”火焰检测电压“，并显示最近半小时的数据，如下图所示。
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_实时曲线设定.png width=80%/>
+</div>
+
+&emsp;&emsp;
+选中”地图“组件，点击“编辑设备地图”按钮，如下图所示。
+
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_地图_编辑入口.png width=80%/>
+</div>
+
+&emsp;&emsp;
+点击“选择产品”按钮 ，选中“火焰检测系统”，如下图所示。如果此时设备已经上线，则地图会自动跳到设备当前所在位置。
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_地图_选择产品.png width=80%/>
+</div>
+
+<br>
+
+### 4.7、**业务逻辑开发**
+&emsp;&emsp;
+业务逻辑的主要目的是为了让用户设定物联网设备端的行为逻辑，常规物联网系统都是在设备端固化行为逻辑，出厂之后如果需要修改设备的行为，则需要进行OTA升级。本节课程则向读者介绍如何通过IoT Studio完成业务逻辑的开发。
+
+&emsp;&emsp;
+新建一条名为“火焰亮度监控报警设定”的规则。
+<div align="center">
+<img src=./../../../images/4_火焰检测系统_创建业务逻辑.png width=80%/>
+</div>
+
+&emsp;&emsp;
+系统会自动进入到业务逻辑编辑页面，如下图所示，点击左侧的“节点”按钮，则可以看到所有可用的节点选项。右侧红框是如何设计一个业务逻辑的介绍。
+
+<div align="center">
+<img src=./../../../images/4_火焰监控报警.png width=80%/>
+</div>
+
+1. 选择目标节点
+
+&emsp;&emsp;
+此逻辑需要通过“火焰检测系统”上报的“火焰检测电压”当低于高于电压阈值的时候打开报警灯，否则关闭报警灯。所以需要如下4个节点：
+* 设备触发节点
+* 条件判断节点
+* 开启报警灯节点
+* 关闭报警灯节点
+
+&emsp;&emsp;
+分别从左侧拖动“设备触发”，“条件判断”和2个“火焰检测系统”4个节点到右侧的业务逻辑编辑框。
+
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_节点列表.png width=80%/>
+</div>
+
+2. 建立节点间的关联关系
+
+&emsp;&emsp;
+按照预设的逻辑建立，如下图所示（在节点的一侧按下鼠标拖动到另一节点的一侧即可建立连线关系）。
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_节点逻辑关系建立.png width=80%/>
+</div>
+
+1. 业务逻辑编辑
+* 设备触发节点
+
+&emsp;&emsp;
+此设备触发选择“火焰检测设备”的“火焰检测电压”属性即可，如下图所示（和前面“组件”设定类似，同样是鼠标选中第节点，在右侧的配置选项中进行配置）。
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_设备触发节点配置.png width=80%/>
+</div>
+
+* 条件判断节点
+
+&emsp;&emsp;
+此处我们设定为当传感器测量到的电压值高于1000mV则开始报警。设定步骤如下。
+> 在没有检测到火焰的时候传感器输出高电平，在检测到火焰之后，输出电压会下降
+
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_比较节点配置.png width=80%/>
+</div>
+
+* 设备节点行为设定
+
+&emsp;&emsp;
+分别为设备节点设定开启报警灯和关闭报警灯的行为，如下图所示。
+
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_设备节点行为设定.png width=80%/>
+</div>
+
+
+* 业务逻辑保存和部署
+
+&emsp;&emsp;
+依此点击右上角的“保存”和“部署”按钮，即可将此业务逻辑设定完毕。
+<br>
+
+<br>
+
+### 4.8、**预览和发布上线**
+
+&emsp;&emsp;
+业务逻辑设定完毕之后，可以在“火焰监控报警系统”页面编辑页面点击“预览”按钮进行预览，如下图所示。
+
+<div align="center">
+<img src=./../../../images/4_火焰监控系统_预览.png width=80%/>
+</div>
+
+&emsp;&emsp;
+在发布之前可以点击上图的“预览”查看应用的实际运行效果。实际运行效果如下所示，同时可以扫描二维码在手机上面查看实际运行效果。
+
+<div align="center">
+<img src=./../../../images/4_火焰监控报警系统效果.gif width=80%/>
+</div>
+
+&emsp;&emsp;
+此时查看设备上面的报警灯的状态会同步和web应用的报警灯状态同步显示。
+
+
+## 5、运行结果
+### 5.1、本地查看
+&emsp;&emsp;
+Python脚本推送到HaaS EDU K1之后 ，会自动运行，运行过程中日志如下。其中：
+
+* "物联网平台连接成功" 代表成功连接到物联网平台
+* 打火机打着火后，靠近火焰传感器电压值降低
+* 打火机打着火后，远离火焰传感器电压值升高
+
+```python
+...
+Wi-Fi connected
+...
+DeviceIP:172.20.10.10
+...
+success to establish tcp, fd=54
+物联网平台连接成功
+
+uploading data to the cloud,  {"alarmState": 1, "fireVoltage": 2598}
+uploading data to the cloud,  {"alarmState": 1, "fireVoltage": 2598}
+uploading data to the cloud,  {"alarmState": 1, "fireVoltage": 2598}
+```
+
+
+> 打火机打着火后，远离和靠近火焰传感器的二极管，查看设备端日志的量测值是否有变化。
+> 请务必注意安全！！！
+
+<br>
+
+
+### 5.2、物联网平台端设备信息查看
+
+&emsp;&emsp;
+物联网设备的系统启动成功并连接到物联网平台之后，物联网平台上对应的设备状态会从”未激活状态“变为”上线“，在物模型数据标签页上会显示设备上报到物联网平台的属性值。
+
+<div align="center">
+<img src=./../../../images/1_火焰检测系统_设备状态及属性.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此时如果开发板周围的火焰强度发生变化，物联网平台的物模型数据会更新为设备上报的最新的属性值。
+
+<br>
+
+### 5.3、物联网平台控制报警灯状态
+&emsp;&emsp;
+物联网设备上线之后，可以通过”监控运维“中的"在线调试"功能进行调试，详细操作步骤见下图：
+<div align="center">
+<img src=./../../../images/1_火焰检测系统_物联网平台在线调试功能.png width=60%/>
+</div>
+
+&emsp;&emsp;
+此产品的物模型属性中，"火焰检测电压值"设置的是只读，也就是说智能从设备端读取，不支持设置此状态到设备端，所以点开"火焰检测电压"后面的”调试“之后，里边只有获取的选项。”报警状态“设置的是可读可写，所以点开”报警状态“后面的”调试“之后，里边有”获取“、”设置”和“设置期望值”三个选项。
+这里可以选择打开报警状态之后点击“设置”进行报警灯功能的调试。
+
+<div align="center">
+<img src=./../../../images/1_火焰检测系统_云端打开报警灯.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此时查看设备端LED是否已经打开，打开成功则代表控制报警灯成功。
+
+<br>
+
+<br>
+
+&emsp;&emsp;
+这样整个火焰检测系统的创意案例就完成了。如果想要看整个案例更详细的操作步骤，请参考“[火焰检测系统详解](https://gitee.com/haasedu/haasedu/blob/release_2.0/4-%E6%99%BA%E6%85%A7%E5%B7%A5%E4%B8%9A/%E5%9C%BA%E6%99%AF1-%E7%81%AB%E7%84%B0%E7%9B%91%E6%8E%A7%E6%8A%A5%E8%AD%A6%E7%B3%BB%E7%BB%9F/README.md)”中的说明。
+
+<br>
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/code/board.json b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/code/board.json
new file mode 100644
index 0000000000..3e0f491e59
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/code/board.json
@@ -0,0 +1,205 @@
+{
+    "name": "haaseduk1",
+    "version": "1.0.0",
+    "io": {
+      "fire": {
+        "type": "ADC",
+        "port": 2,
+        "sampling": 12000000
+      },
+      "mpu6050": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 105
+      },
+      "ap3216c": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 30
+      },
+      "si7006": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 64
+      },
+      "spl06": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 119
+      },
+      "qmc5883": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 13
+      },
+      "cht8305": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 1000000,
+        "mode": "master",
+        "devAddr": 64
+      },
+      "qmi8610": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 106
+      },
+      "qmp6988": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 86
+      },
+      "qmc6310": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 28
+      },
+      "ADC2": {
+        "type": "ADC",
+        "port": 2,
+        "sampling": 12000000
+      },
+      "GPIO2": {
+        "type": "GPIO",
+        "port": 2,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "GPIO3": {
+        "type": "GPIO",
+        "port": 3,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO4": {
+        "type": "GPIO",
+        "port": 4,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO5": {
+        "type": "GPIO",
+        "port": 5,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO6": {
+        "type": "GPIO",
+        "port": 6,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO7": {
+        "type": "GPIO",
+        "port": 7,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO19": {
+        "type": "GPIO",
+        "port": 19,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO22": {
+        "type": "GPIO",
+        "port": 22,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO23": {
+        "type": "GPIO",
+        "port": 23,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "I2C1": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 60
+      },
+      "led_r": {
+        "type": "GPIO",
+        "port": 36,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "led_g": {
+        "type": "GPIO",
+        "port": 35,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "led_b": {
+        "type": "GPIO",
+        "port": 34,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "SPI0": {
+        "type": "SPI",
+        "port": 0,
+        "mode": "master",
+        "freq": 2000000
+      },
+      "oled_spi": {
+        "type": "SPI",
+        "port": 1,
+        "mode": "master",
+        "freq": 26000000
+      },
+      "oled_dc": {
+        "type": "GPIO",
+        "port": 28,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "oled_res": {
+        "type": "GPIO",
+        "port": 30,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "serial2": {
+        "type": "UART",
+        "port": 2,
+        "dataWidth": 8,
+        "baudRate": 9600,
+        "stopBits": 1,
+        "flowControl": "disable",
+        "parity": "none"
+      }
+    },
+    "debugLevel": "ERROR",
+    "repl": "disable"
+  }
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/code/fire.py b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/code/fire.py
new file mode 100644
index 0000000000..e7d37240d3
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/code/fire.py
@@ -0,0 +1,17 @@
+from driver import ADC
+
+class Fire(object):
+
+    def __init__(self, adcObj):
+        self.adcObj = None
+        if not isinstance(adcObj, ADC):
+            raise ValueError("parameter is not an ADC object")
+
+        self.adcObj = adcObj
+
+    def getVoltage(self):
+        if self.adcObj is None:
+            raise ValueError("invalid ADC object")
+
+        value = self.adcObj.readVoltage()
+        return value
diff --git a/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/code/main.py b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/code/main.py
new file mode 100644
index 0000000000..8293f1cdcd
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/code/main.py
@@ -0,0 +1,172 @@
+# -*- encoding: utf-8 -*-
+
+
+from aliyunIoT import Device # aliyunIoT组件是连接阿里云物联网平台的组件
+import utime                 # 延时API所在组件
+import ujson                # json字串解析库
+import fire
+from driver import GPIO     # HaaS EDU K1 LED使用GPIO进行控制
+from driver import ADC      # ADC类，通过微处理器的ADC模块读取ADC通道输入电压
+import netmgr as nm         # netmgr是Wi-Fi网络连接的组件
+
+adcDev = 0                     # ADC通道对象
+ledDev = 0               # 报警LED对象
+alarm_on = 0                # 记录报警状态
+
+# 物联网平台连接标志位
+iot_connected = False
+
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+
+# Wi-Fi SSID和Password设置
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+
+# 物联网设备实例
+device = None
+
+def alarm_control(on):
+    global ledDev
+
+    if on == 0:
+        ledDev.write(0)  # GPIO写入0，执行灭灯操作
+    else:
+        ledDev.write(1)  # GPIO写入 1，执行亮灯报警动作
+
+# 等待Wi-Fi成功连接到路由器
+def get_wifi_status():
+   nm.init()
+   nm.disconnect()
+   wifi_connected = nm.getStatus()
+
+   # 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
+   print("start to connect " , wifiSsid)
+   nm.connect(wifiSsid, wifiPassword)
+
+   while True :
+      if wifi_connected == 5:               # nm.getStatus()返回5代表连线成功
+        break
+      else:
+        wifi_connected = nm.getStatus() # 获取Wi-Fi连接路由器的状态信息
+        utime.sleep(0.5)
+   print("Wi-Fi connected")
+   print('DeviceIP:' + nm.getInfo()['ip'])  # 打印Wi-Fi的IP地址信息
+
+# 物联网平台连接成功的回调函数
+def on_connect(data):
+    global iot_connected
+    iot_connected = True
+
+# 设置props 事件接收函数（当云平台向设备下发属性时）
+def on_props(request):
+    global alarm_on, device
+    # print(request)
+    payload = ujson.loads(request['params'])
+
+    # 获取dict状态字段 注意要验证键存在 否则会抛出异常
+    if "alarmState" in payload.keys():
+        alarm_on = payload["alarmState"]
+        if (alarm_on):
+            print("开始报警")
+        else:
+            print("结束报警")
+
+    # print(alarm_on)
+
+    # 根据云端设置的报警灯状态改变本地LED状态
+    alarm_control(alarm_on)
+
+    # 要将更改后的状态同步上报到云平台
+    prop = ujson.dumps({'alarmState': alarm_on})
+    # print('uploading data: ', prop)
+
+    upload_data = {'params': prop}
+    # 上报本地报警灯状态到云端
+    device.postProps(upload_data)
+
+
+# 连接物联网平台
+def connect_lk(productKey, deviceName, deviceSecret):
+    global device, iot_connected
+    key_info = {
+        'region': 'cn-shanghai',
+        'productKey': productKey,
+        'deviceName': deviceName,
+        'deviceSecret': deviceSecret,
+        'keepaliveSec': 60
+    }
+    # 将三元组信息设置到iot组件中
+    device = Device()
+
+    # 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
+    device.on(Device.ON_CONNECT, on_connect)
+
+    # 配置收到云端属性控制指令的回调函数
+    # 如果收到物联网平台发送的属性控制消息，则调用on_props函数
+    device.on(Device.ON_PROPS, on_props)
+
+    # 启动连接阿里云物联网平台过程
+    device.connect(key_info)
+
+    # 等待设备成功连接到物联网平台
+    while(True):
+        if iot_connected:
+            print('物联网平台连接成功')
+            break
+        else:
+            print('sleep for 1 s')
+            utime.sleep(1)
+
+# 上传火焰传感器检测电压信息和报警信息到物联网平台
+def upload_fire_detector_state():
+    global device, alarm_on
+
+    fireVoltage = 0
+
+    # 无限循环
+    while True:
+        fireVoltage = fireDev.getVoltage()   # 获取电压值
+        # print("The fire status Voltage ",fireVoltage)
+
+        # 生成上报到物联网平台的属性值字串
+        # 此处的属性标识符"fireVoltage"和"alarmState"必须和物联网平台的属性一致
+        # "fireVoltage" - 代表燃气传感器测量到的电压值
+        # "alarmState" - 代表报警灯的当前状态
+        prop = ujson.dumps({
+            'fireVoltage': fireVoltage,
+            'alarmState': alarm_on
+        })
+        print("uploading data to the cloud, ", prop)
+        upload_data = {'params': prop}
+        # 上传火焰传感器测量结果和报警灯状态到物联网平台
+        device.postProps(upload_data)
+
+        # 每2秒钟上报一次
+        utime.sleep(2)
+
+if __name__ == '__main__':
+    global fireDev
+
+    alarm_on = 0
+    # 硬件初始化
+    # 初始化 ADC
+    adcDev = ADC()
+    adcDev.open("fire")
+    fireDev = fire.Fire(adcDev)
+
+    # 初始化LED所连接GPIO
+    ledDev = GPIO()
+    ledDev.open("led_r")
+    alarm_control(alarm_on)         # 关闭报警灯
+
+    # 请替换物联网平台申请到的产品和设备信息,可以参考文章:https://blog.csdn.net/HaaSTech/article/details/114360517
+    get_wifi_status()
+
+    connect_lk(productKey, deviceName, deviceSecret)
+    upload_fire_detector_state()
+
+    adcDev.close()
+    ledDev.close()
diff --git a/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/link_platform/fire_detector_model.zip b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/link_platform/fire_detector_model.zip
new file mode 100644
index 0000000000..2cc4b63282
Binary files /dev/null and b/haas_lib_bundles/python/docs/examples/fire_detector/haaseduk1/link_platform/fire_detector_model.zip differ
diff --git a/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/README.md b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/README.md
new file mode 100644
index 0000000000..2630ecdfb2
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/README.md
@@ -0,0 +1,609 @@
+# 花卉养植
+&emsp;&emsp;
+下图是本案例除硬件连线外的3步导学，每个步骤中实现的功能请参考图中的说明。
+<div align="center">
+<img src=./../../../images/3_花卉养植系统_步骤概述.jpg width=70%/>
+</div>
+
+## 1、简介
+&emsp;&emsp;
+我们国家的现代农业和过去相比已经有了长足的进步,其中花卉养植监控系统也是高效农业的一个重要组成部分。
+
+&emsp;&emsp;
+花卉养植监控系统是一种可以改变植物生长环境、为植物生长创造最佳条件、避免外界四季变化和恶劣气候对其影响的场所。它以采光覆盖材料作为全部或部分结构材料，可在冬季或其他不适宜露地植物生长的季节栽培植物。花卉养植监控系统生产以达到调节产期，促进生长发育，防治病虫害及提高质量、产量等为目的。而花卉养植监控系统设施的关键技术是环境控制，该技术的最终目标是提高控制与作业精度。
+
+&emsp;&emsp;
+本章课程就以山茶花养植为例介绍如何打造一个最适合茶花生长的花卉养植系统。
+
+&emsp;&emsp;
+按照茶花的生长习性，最适宜茶花的生长环境因素主要有3个：
+1. 温度：20~28度
+2. 湿度：~70%
+3. 光照：不能太强
+
+&emsp;&emsp;
+为了制造适合茶花生长的环境，本场景的示意图如下图所示，场景设计的行为如下：
+1. 通过温度传感器测量环境温度，并在温度过高时打开空调进行降低环境温度
+2. 通过湿度传感器测量环境湿度，并在湿度过低的时候控制加湿器进行加湿操作
+
+### 1.1、准备
+&emsp;&emsp;
+本实验只需要如下硬件，无需外接其它硬件：
+* [HaaS EDU K1开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C5AB3B8A4A88800000001&dataId=800C5AB3B8A4A888)   一台
+* Type-C USB数据线    一条
+
+&emsp;&emsp;
+案例中需要两颗LED模拟控制空调和加湿器的开关的功能，此处就借助于HaaS EDU  K1的蓝色和绿色LED灯，其中：
+* 蓝色LED模拟空调的开关
+* 绿色LED模拟加湿器的开关
+
+&emsp;&emsp;
+如果要模拟控制空调打开，则需要拉高P34（蓝色LED）；如需模拟控制加湿器打开，则需要拉高P35（绿色LED）。
+
+## 2、物联网平台开发
+### 2.1、开通公共实例
+&emsp;&emsp;
+对于第一次使用物联网平台的读者，需要开通实例以使用物联网平台的功能。这里可以使用免费的公共实例进行开发。
+
+&emsp;&emsp;
+在[物联网平台](https://iot.console.aliyun.com/lk/summary/new)中，左上角选择“华东2-上海”，点击“公共实例”，即可开通。
+
+<div align="center">
+<img src=./../../../images/5_3_开通公共实例.png
+ width=100%/>
+</div>
+
+开通物联网平台功能之后，需要完成下面的4个步骤完成云端设备的设定：
+1. 创建云端产品
+2. 创建产品属性（物模型）
+3. 创建云端设备（获取三元组）
+4. 多设备场景联动设定
+
+<br>
+
+### 2.2、创建云端产品
+&emsp;&emsp;
+点击上图中的“公共实例”，即可进入[控制台](https://iot.console.aliyun.com/lk/summary/new)进行产品创建。然后，点击创建产品按钮，如下图所示。
+
+<div align="center">
+<img src=./../../../images/1_创建产品.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+在新建产品设定页面按照下图所示，设定“产品名称”，选择所属的“标准品类”（如果创建的产品品类为非标品类，可以选择自定义品类），节点类型选择“直连设备”，联网方式选择“Wi-Fi”，数据格式选择“ICA标准数据格式”，检验类型和认证方式选择默认设定即可。还可以根据开发者自己的需求在“产品描述”页面添加针对此产品的描述。
+<div align="center">
+<img src=./../../../images/1_新建产品页面.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+选择之后，点击“确认”按钮，即可完成产品创建。返回“产品”页面之后可以看到产品类表中会出现刚刚创建的“温湿度检测装置”的产品，如下图所示。
+
+<div align="center">
+<img src=./../../../images/1_产品列表页.png width=100%/>
+</div>
+
+<br>
+
+### 2.3、创建产品属性（物模型）
+&emsp;&emsp;
+点击上图中的“查看”按钮，即可看到产品信息，Topic列表，功能定义，数据解析等跟产品相关功能的设定。点开“功能定义”标签页，可以看到设备物模型定义。
+> 物模型中的“地理位置”属性本案例后面的内容没有用到，读者可忽略。
+
+<div align="center">
+<img src=./../../../images/1_产品详情页面.png width=100%/>
+</div>
+
+&emsp;&emsp;
+因为在创建产品的过程中选择了标准的产品品类，这里会出现标准品类中自带的物模型设定，包含“当前温度”、“当前湿度”和“地理位置”信息。这三条都适合属性信息，其标识符、数据类型、数据定义及该属性支持的操作都可以在这个页面看到。
+
+&emsp;&emsp;
+标识符是设备端上报设备属性状态的消息中需要使用的标识符，并且只有在设备上报的属性内容符合“数据定义”中的数据取值范围的时候才会被物联网平台记录，否则会被物联网平台认定为非法属性而过滤掉。
+
+&emsp;&emsp;
+如果在创建产品的时候没有选择标准的品类，则需要在这个地方新增物模型的属性或服务。详情请参考[物联网平台](../../../拓展知识/物联网平台/README.md)中的内容。
+
+&emsp;&emsp;
+产品及其物模型创建完成后就可以创建这个产品的设备了。
+
+<br>
+
+### 2.4、创建云端设备（获取三元组）
+&emsp;&emsp;
+在产品列表页面中，点击“管理设备”，就会进到设备管理页面。
+
+<div align="center">
+<img src=./../../../images/1_管理设备入口.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“设备”页面点击“添加设备”按钮，如下图所示。
+<div align="center">
+<img src=./../../../images/1_添加设备入口.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“添加设备”页面中设定“deviceName”，这里开发者可以自己填入自己想设定的设备名称，也可以不填任何内容让系统自动生成设备名称，如下图所示。
+<div align="center">
+<img src=./../../../images/1_添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备添加完成后，点击“前往查看”按钮，就可以看到此设备端详细信息了。
+<div align="center">
+<img src=./../../../images/1_完成添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备信息中有两个信息需要和设备端开发相匹配：
+1. 三元组
+2. 物模型属性信息
+
+<div align="center">
+<img src=./../../../images/1_设备详细信息.png width=100%/>
+</div>
+
+<br>
+
+##### 2.4.1、**获取设备三元组**
+&emsp;&emsp;
+如上图所示，点击“查看”按钮，就可以看到设备的三元组信息，三元组是物联网设备端和物联网云端设备相关联的唯一标识符，在设备端连接云端的时候会使用三元组信息和云端进行鉴权，鉴权通过之后云端会认为设备已激活并上线。
+
+<div align="center">
+<img src=./../../../images/1_三元组信息.png width=60%/>
+</div>
+
+<br>
+
+#### 2.4.2、**查看设备属性信息**
+&emsp;&emsp;
+设备详情信息页中的“物模型数据”标签页中可以看到设备的所有属性信息、设备时间上报情况及设备服务调用情况，如下图所示。待物联网设备按照设备属性对应的标识符上报设备属性的时候，本图片中的“当前温度“，”当前湿度“等属性值就会显示设备最新的属性信息。
+<div align="center">
+<img src=./../../../images/1_设备物模型数据.png width=100%/>
+</div>
+
+<br>
+
+> 创建产品和设备的过程是按照面向对象的思想进行设计的，其中创建产品可以看成是新建一个类，其中的物模型则是类的对象，创建设备则是进行类的实例化。
+
+### 2.5、**云端物模型**
+&emsp;&emsp;
+在此产品的物模型中新增两个bool类型的属性，命名为"airconditioner"和"humidifier"分别用来控制空调和加湿器。
+* 当需要打开空调时，云端将“airconditioner”的属性值设置为True；需要关闭空调时，将其设置为False。
+* 当需要打开加湿器时，云端将“humidifier”的属性值设置为True；需要关闭空调时，将其设置为False。
+
+&emsp;&emsp;
+添加物模型属性的过程下所述：
+1. 在产品的“功能定义”标签页中点击"编辑草稿"，如果没有“编辑草稿”的按钮，说明此产品的物模型已经发布，需要点击右上角的“取消发布”按钮才能添加或删除属性。
+<div align="center">
+<img src=./../../../images/3_添加物模型属性_编辑草稿.png width=80%/>
+</div>
+
+2. 点击“添加自定义功能”按钮，如下图所示：
+<div align="center">
+<img src=./../../../images/3_花卉养植_添加空调和加湿器属性.png width=80%/>
+</div>
+
+ 3. 添加属性名称、标识符、类型等信息，如下图所示：
+* 添加“airconditioner”属性
+<div align="center">
+<img src=./../../../images/3_花卉养植_添加控制空调属性.png width=40%/>
+</div>
+
+* 添加“humidifier”属性
+<div align="center">
+<img src=./../../../images/3_花卉养植_添加控制加湿器属性.png width=40%/>
+</div>
+
+&emsp;&emsp;
+添加完属性之后，点击左下角的“发布上线”按钮 ，根据系统提示进行确认即可，如下图所示：
+<div align="center">
+<img src=./../../../images/3_花卉养植_属性发布上线.png width=80%/>
+</div>
+
+<div align="center">
+<img src=./../../../images/3_花卉养植_属性发布上线_确认.png width=40%/>
+</div>
+
+### 2.6、**多设备场景联动设定**
+&emsp;&emsp;
+控制逻辑有两种实现方式：
+1. 使用物联网平台的规则引擎功能
+2. 使用IoT Studio的业务逻辑功能
+
+&emsp;&emsp;
+本节接下来就开始介绍使用物联网平台的规则引擎来完成此控制逻辑的设定。
+
+&emsp;&emsp;
+按照下图所示的步骤创建场景联动的规则：
+<div align="center">
+<img src=./../../../images/3_花卉养植_创建场景联动规则.png width=80%/>
+</div>
+
+&emsp;&emsp;
+点击“创建规则”之后，填入场景规则名称，这里我们先创建第一个“温度过高开启空调”的规则。
+
+<div align="center">
+<img src=./../../../images/3_花卉养植_创建场景联动规则_温度过高开启空调.png width=40%/>
+</div>
+
+&emsp;&emsp;
+规则创建完成后，等待几秒钟系统会自动跳转到规则编辑页面，这里需要配置如下两步完整一整条规则的创建：
+1. 设置“触发器”为温湿度监控器的“当前温度"属性高于茶花最适宜生长的温度28度触发此规则的执行，如下图所示
+
+<div align="center">
+<img src=./../../../images/3_花卉养植_温度过高开启空调_触发器设定.png width=80%/>
+</div>
+
+2. 设置“执行动作"为控制设备打开”空调开关“属性
+<div align="center">
+<img src=./../../../images/3_花卉养植_温度过高开启空调_执行器设定.png width=80%/>
+</div>
+
+&emsp;&emsp;
+点击保存之后”温度过高打开空调“的场景联动规则就创建好了。
+&emsp;&emsp;
+用相同的方式创建另外三条场景联动规则：
+* "温度合适关闭空调"，如下图所示
+
+<div align="center">
+<img src=./../../../images/3_花卉养植_创建场景联动规则_温度合适关闭空调.png width=80%/>
+</div>
+* ”湿度适合关闭加湿器“，如下图所示
+
+<div align="center">
+<img src=./../../../images/3_花卉养植_创建场景联动规则_湿度适合关闭加湿器.png width=80%/>
+</div>
+
+* "湿度过低打开加湿器“，如下图所示
+
+<div align="center">
+<img src=./../../../images/3_花卉养植_创建场景联动规则_湿度过低开启加湿器.png width=80%/>
+</div>
+
+&emsp;&emsp;
+创建完这几条规则之后，在”场景联动“页面中点击规则后面的启动按钮，则所有的规则都会运行起来。
+<div align="center">
+<img src=./../../../images/3_花卉养植_开启场景联动规则.png width=80%/>
+</div>
+
+## 3、设备端开发
+
+### 3.1、开发环境
+
+&emsp;&emsp;
+在进行下一步之前请确保HaaS EDU K1开发环境已经搭建完毕。详情请参考[HaaS EDU K1开发环境](../../../startup/HaaS_EDU_K1_startup.md)的说明。
+
+### 3.2、创建解决方案
+
+&emsp;&emsp;
+如下图所示，在Haas Studio中创建项目。先选择左侧的“开发板型号”再从右侧的案例中选择“花卉养植”案例点击“立即创建”即可。
+
+<div align="center">
+<img src=./../../../images/HaaS_Studio_创建工程示范.png width=100%/>
+</div>
+<br>
+
+1. **修改路由器名称及密码**
+
+&emsp;&emsp;
+修改工程里main.py中wifiSsid和wifiPassword的值为读者实际要连接的路由器的名称及密码（请注意名称和密码都需要放在""符号中间）。
+
+```python
+# Wi-Fi SSID和Password设置
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+```
+
+&emsp;&emsp;
+修改完成之后get_wifi_status函数中的wlan.connect(wifiSsid, wifiPassword)语句就会连接读者自己设定的路由器。
+
+2. **修改设备端三元组**
+
+&emsp;&emsp;
+修改humiture工程里main.py中productKey、deviceName和deviceSecret的值为读者创建的物联网设备的三元组信息，如下图所示：
+```python
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+```
+
+3. **修改设备端上报温湿度信息所用标识符**
+
+&emsp;&emsp;
+humiture工程里main.py中下面的代码实现的是上传温湿度值到云端的功能。其中CurrentTemperature和CurrentHumidity便是温湿度值上报时所用的标识符。
+```python
+# 上传温度信息和湿度信息到物联网平台
+def upload_temperature_and_Humidity():
+    global device
+
+    while True:
+        data = get_temp_humi()                      # 读取温度信息和湿度信息
+        # 生成上报到物联网平台的属性值字串
+        prop = ujson.dumps({
+            'CurrentTemperature': data[0],
+            'CurrentHumidity': data[1]
+            })
+        print('uploading data: ', prop)
+
+        upload_data = {'params': prop}
+        # 上传温度和湿度信息到物联网平台
+        device.postProps(upload_data)
+        utime.sleep(2)
+```
+&emsp;&emsp;
+确保这两个标识符和物联网产品的物模型中属性标识符是一样的，如下图所示：
+<div align="center">
+<img src=./../../../images/Haa2200_humiture_属性标识符修改.png
+ width=80%/>
+</div>
+
+&emsp;&emsp;
+<b>下面是本节添加的重点代码段落讲解：</b>
+
+* 新增两个变量用来控制空调和加湿器对应的GPIO
+```python
+# 空调和加湿器状态变量
+airconditioner = 0
+humidifier = 0
+```
+
+* 新增函数处理云端信息并控制GPIO的接口
+```python
+# 设置props 事件接收函数（当云平台向设备下发属性时）
+def on_props(request):
+    global airconditioner, humidifier, airconditioner_value, humidifier_value
+
+    # {"airconditioner":1} or {"humidifier":1} or {"airconditioner":1, "humidifier":1}
+    payload = ujson.loads(request['params'])
+    # print (payload)
+    # 获取dict状态字段 注意要验证键存在 否则会抛出异常
+    if "airconditioner" in payload.keys():
+        airconditioner_value = payload["airconditioner"]
+        if (airconditioner_value):
+            print("打开空调")
+        else:
+            print("关闭空调")
+
+    if "humidifier" in payload.keys():
+        humidifier_value = payload["humidifier"]
+        if (humidifier_value):
+            print("打开加湿器")
+        else:
+            print("关闭加湿器")
+
+    # print(airconditioner_value, humidifier_value)
+
+    airconditioner.write(airconditioner_value) # 控制空调开关
+    humidifier.write(humidifier_value)         # 控制加湿器开关
+
+    # 要将更改后的状态同步上报到云平台
+    prop = ujson.dumps({
+        'airconditioner': airconditioner_value,
+        'humidifier': humidifier_value,
+    })
+
+    upload_data = {'params': prop}
+    # 上报空调和加湿器属性到云端
+    device.postProps(upload_data)
+```
+
+<br>
+
+## 4、运行结果
+&emsp;&emsp;
+推送此脚本到HaaS EDU K1之后，运行此脚本，HaaS EDU K1串口会周期性的打印如下日志。其中：
+* “物联网平台连接成功” 代表成功连接到物联网平台
+* "uploading data:"之后跟着的为设备端向云端发布的温湿度属性信息，其中CurrentTemperature后面的数值为温度值，单位：摄氏度；CurrentHumidity后面数值为相对湿度值。
+* 设备端解析到云端送下来的控制指令中包含“{"humidifier":1}”之后会打印"打开加湿器"并点亮绿色LED模拟打开控制加湿器的继电器的动作
+* 设备端解析到云端送下来的控制指令包含"{"airconditioner":1}"之后会打印"打开空调"并点亮蓝色LED模拟打开控制空调的继电器的动作
+
+```log
+...
+...
+Wi-Fi connected
+...
+DeviceIP:172.20.10.10
+...
+success to establish tcp, fd=54
+物联网平台连接成功
+物联网平台连接成功
+sleep for 2s
+uploading data:  {"CurrentTemperature": 28.30015, "CurrentHumidity": 50.82117}
+打开空调
+打开加湿器
+```
+&emsp;&emsp;
+开发板实际效果如下：
+• 在温度高于阈值时，可以看到日志中出现"打开空调"的字样，伴随着蓝色LED灯亮起
+• 在温度低于阈值之后 ，可以看到日志中出现“关闭空调”的字样，伴随着蓝色LED灯熄灭
+• 在湿度低于阈值时，可以看到日志中出现"打开加湿器"的字样，伴随着绿色LED灯亮起
+• 在湿度高于阈值时，可以看到日志中出现"关闭加湿器"的字样，伴随着绿色LED灯熄灭
+
+### 4.1、物联网平台端设备信息查看
+
+&emsp;&emsp;
+物联网设备的系统启动成功并连接到物联网平台之后，物联网平台上对应的设备状态会从”未激活状态“变为”上线“，在物模型数据标签页上会显示设备上报到物联网平台的属性值。
+
+<div align="center">
+<img src=./../../../images/1_温湿度监控设备状态及属性.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此时如果开发板温度和周围湿度发生变化，物联网平台的物模型数据会更新为设备上报的最新的属性值。
+
+## 5、物联网应用开发
+
+&emsp;&emsp;
+现代花卉养植的过程中越来越多的需要农业专家的参与，但和养花的农户来说，农业专家的数量是很少的。在茶花生长出现问题的时候，怎样让农业专家远程迅速的完成对茶花异常生长状况的诊断是很重要的一个研究议题。本节要介绍的中控大屏就是将茶花当前生产环境的信息通过网页的形式直观的展现出来，一方面方便农户很方便的查看相关信息并判断是否需要人为干预；另一方面在出现问题的时候可以让专家远程快速的对问题进行诊断。
+
+<br>
+
+### 5.1、中控大屏目标
+&emsp;&emsp;
+本节课程主要目标是设计一个总控大屏的web应用，能实时的查看如下信息：
+1. 过去3小时的温湿度实时信息
+2. 空调及加湿器状态实时状态显示
+3. 手动控制空调或加湿器的开关状态
+
+<br>
+
+### 5.2、茶花生长环境监控系统
+&emsp;&emsp;
+下图是一个典型的物联网应用程序开发的流程图，接下来本节就按照这个流程介绍如何花卉养植系统中控大屏的web应用程序的开发。
+
+<div align="center">
+<img src=./../../../images/1_物联网应用开发的一般流程.png width=80%/>
+</div>
+
+<br>
+
+#### 5.2.1、**新建“普通项目”**
+&emsp;&emsp;
+打开[IoT Studio官网](https://studio.iot.aliyun.com/)，在项目管理中创建一个空白项目，如下图所示，将此项目命名为“茶花养植系统”。
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_创建IoTStudio项目.png width=80%/>
+</div>
+
+<br>
+
+#### 5.2.2、**新建“Web应用”**
+&emsp;&emsp;
+新建“普通项目”之后，在新项目的首页新建一个Web应用，命名为“茶花生长环境实时监控”。
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控.png width=80%/>
+</div>
+
+&emsp;&emsp;
+Web应用创建成功后会进入到应用界面设计页面。
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_页面编辑页.png width=80%/>
+</div>
+
+
+&emsp;&emsp;
+点击上图红框中的“组件”按钮图标，就可以看到可用的组件列表。各组件的说明请参考[IoT Studio组件说明](https://help.aliyun.com/document_detail/125196.html)。
+
+<br>
+
+#### 5.2.3、**页面设计**
+&emsp;&emsp;
+这里我们用到3个组件:
+* 实时曲线
+用于显示温湿度的历史变化曲线及实时数据
+* 开关
+显示和控制空调和加湿器的当前状态
+* 图片
+空调或加湿器的示意图
+
+&emsp;&emsp;
+将三个组件拖到中间的画布区，适当调整组件布局。然后选中图片组件，点击右边的“上传图片”按钮，分别上传空调和加湿器的图片，如下图所示。
+
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_图片上传.png width=80%/>
+</div>
+
+<br>
+
+#### 5.2.4、**关联产品和设备**
+&emsp;&emsp;
+此时回到”茶花养植系统“项目的主页，对产品和设备进行关联，如下图所示：
+<div align="center">
+<img src=./../../../images/3_花卉养殖系统_关联产品和设备.png width=80%/>
+</div>
+
+&emsp;&emsp;
+关联产品的过程如下：
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花养植系统_关联产品.png width=80%/>
+</div>
+
+&emsp;&emsp;
+关联设备的过程如下：
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_关联设备.png width=80%/>
+</div>
+&emsp;&emsp;
+产品和设备关联完毕之后，就可以将把组件和设备的属性关联起来了。
+
+<br>
+
+#### 5.2.5、**关联数据源**
+&emsp;&emsp;
+关联数据源分为如下3个步骤，每个步骤的截图如下：
+* 关联产品
+* 关联设备
+* 关联属性
+
+&emsp;&emsp;
+具体操作步骤如下：
+1. 选中”开关“组件，点击右侧的“配置数据源”。
+
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_开关_配置数据源.png width=80%/>
+</div>
+
+2. 选择目标产品
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_选择产品.png width=80%/>
+</div>
+
+3. 选择目标设备
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_开关_配置数据源_设备.png width=80%/>
+</div>
+
+
+4. 选择“空调开关”属性
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_开关_配置数据源_空调开关.png width=80%/>
+</div>
+
+&emsp;&emsp;
+选择好产品、设备和属性之后，可以看到湿度计表盘上面的湿度值已经已经更新为物联网平台设备属性中最新的湿度值。
+
+&emsp;&emsp;
+同样的方式为另一个”开关“组件选择相同设备的“加湿器”属性。
+接下来需要为”实时曲线“组件设定数据源。同样点击该组件后，点击右边的配置数据源。因为本场景中的温湿度测量和空调/加湿器控制都是通过一个物联网设备完成的，所以本页中要选择”单设备多属性“。然后选择好本场景创建的产品，如下图所示。
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_实时曲线_设备选择.png width=80%/>
+</div>
+
+&emsp;&emsp;
+选择相同的设备，如下图所示。
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_实时曲线_选择设备.png width=80%/>
+</div>
+
+&emsp;&emsp;
+本场景显示的是茶花生长环境的温度信息和湿度信息，所以”数据项“中要选择这两项属性。
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_实时曲线_历史数据属性.png width=80%/>
+</div>
+
+&emsp;&emsp;
+最后选择要显示的实时温湿度数据的时间长度，这里选择3小时，如下图所示。
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_实时曲线_数据时间段.png width=80%/>
+</div>
+
+<br>
+
+#### 5.2.6、**发布上线**
+<div align="center">
+<img src=./../../../images/1_IoT_Studio_HaaS_EDU_K1_预览和发布.png width=80%/>
+</div>
+
+&emsp;&emsp;
+在发布之前可以点击上图的“预览”查看应用的实际运行效果。实际运行效果如下图所示：
+
+<div align="center">
+<img src=./../../../images/3_茶花养植系统_茶花生长环境实时监控_运行效果.png width=80%/>
+</div>
+
+<br>
+
+&emsp;&emsp;
+这样我们就完成了一个花卉养植系统从设备端温湿度测量，设备控制、物联网云平台开发及物联网应用开发全链路的开发。
diff --git a/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/board.json b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/board.json
new file mode 100644
index 0000000000..fb881fc250
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/board.json
@@ -0,0 +1,200 @@
+{
+  "name": "haaseduk1",
+  "version": "1.0.0",
+  "io": {
+    "mpu6050": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 105
+    },
+    "ap3216c": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 30
+    },
+    "si7006": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 400000,
+      "mode": "master",
+      "devAddr": 64
+    },
+    "spl06": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 400000,
+      "mode": "master",
+      "devAddr": 119
+    },
+    "qmc5883": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 400000,
+      "mode": "master",
+      "devAddr": 13
+    },
+    "cht8305": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 1000000,
+      "mode": "master",
+      "devAddr": 64
+    },
+    "qmi8610": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 106
+    },
+    "qmp6988": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 86
+    },
+    "qmc6310": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 28
+    },
+    "ADC2": {
+      "type": "ADC",
+      "port": 2,
+      "sampling": 12000000
+    },
+    "GPIO2": {
+      "type": "GPIO",
+      "port": 2,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "GPIO3": {
+      "type": "GPIO",
+      "port": 3,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO4": {
+      "type": "GPIO",
+      "port": 4,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO5": {
+      "type": "GPIO",
+      "port": 5,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO6": {
+      "type": "GPIO",
+      "port": 6,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO7": {
+      "type": "GPIO",
+      "port": 7,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO19": {
+      "type": "GPIO",
+      "port": 19,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO22": {
+      "type": "GPIO",
+      "port": 22,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO23": {
+      "type": "GPIO",
+      "port": 23,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "I2C1": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 60
+    },
+    "led_r": {
+      "type": "GPIO",
+      "port": 36,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "led_g": {
+      "type": "GPIO",
+      "port": 35,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "led_b": {
+      "type": "GPIO",
+      "port": 34,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "SPI0": {
+      "type": "SPI",
+      "port": 0,
+      "mode": "master",
+      "freq": 2000000
+    },
+    "oled_spi": {
+      "type": "SPI",
+      "port": 1,
+      "mode": "master",
+      "freq": 26000000
+    },
+    "oled_dc": {
+      "type": "GPIO",
+      "port": 28,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "oled_res": {
+      "type": "GPIO",
+      "port": 30,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "serial2": {
+      "type": "UART",
+      "port": 2,
+      "dataWidth": 8,
+      "baudRate": 9600,
+      "stopBits": 1,
+      "flowControl": "disable",
+      "parity": "none"
+    }
+  },
+  "debugLevel": "ERROR",
+  "repl": "disable"
+}
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/cht8305.py b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/cht8305.py
new file mode 100644
index 0000000000..77a36e2007
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/cht8305.py
@@ -0,0 +1,147 @@
+"""
+Copyright (C) 2015-2021 Alibaba Group Holding Limited
+
+    MicroPython's driver for CHT8305
+
+    Author: HaaS
+    Date:   2021/09/14
+"""
+
+from micropython import const
+from utime import sleep_ms
+from driver import I2C
+
+CHT8305_REG_TEMP = 0x00
+CHT8305_REG_HUMI = 0x01
+
+# The register address in CHT8305 controller.
+
+class CHT8305Error(Exception):
+    def __init__(self, value=0, msg="cht8305 common error"):
+        self.value = value
+        self.msg = msg
+
+    def __str__(self):
+        return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
+
+    __repr__ = __str__
+
+
+class CHT8305(object):
+    """
+    This class implements cht8305 chip's functions.
+    """
+    def __init__(self, i2cDev):
+        self._i2cDev = None
+        if not isinstance(i2cDev, I2C):
+            raise ValueError("parameter is not an I2C object")
+        # make CHT8305's internal object points to i2cDev
+        self._i2cDev = i2cDev
+
+    def getTemperature(self):
+        """Get temperature."""
+        # make sure CHT8305's internal object is valid before I2C operation
+        if self._i2cDev is None:
+            raise ValueError("invalid I2C object")
+
+        # send temperature register to CHT8305
+        reg = bytearray([CHT8305_REG_TEMP])
+        self._i2cDev.write(reg)
+        # wait for 30ms
+        sleep_ms(30)
+        readData = bytearray(2)
+        # read temperature from CHT8305
+        self._i2cDev.read(readData)
+
+        # convert the temperature data to actual value
+        value = (readData[0] << 8) | readData[1]
+        if (value & 0xFFFC):
+            temperature = (165.0 * float(value)) / 65536.0 - 40.0
+        else:
+            raise CHT8305Error("failed to get temperature.")
+        return temperature
+
+    def getHumidity(self):
+        """Get humidity."""
+        # make sure CHT8305's internal object is valid before I2C operation
+        if self._i2cDev is None:
+            raise ValueError("invalid I2C object")
+
+         # send humidity register to CHT8305
+        reg = bytearray([CHT8305_REG_HUMI])
+        self._i2cDev.write(reg)
+        sleep_ms(30)
+        # read humidity from CHT8305
+        readData = bytearray(2)
+        self._i2cDev.read(readData)
+
+        # convert the humidity data to actual value
+        value = (readData[0] << 8) | readData[1]
+        if (value & 0xFFFE):
+            humidity = ((125.0 * float(value)) / 65535.0) - 6.0
+        else:
+            raise CHT8305Error("failed to get humidity.")
+
+        return humidity
+
+    def getTempHumidity(self):
+        """Get temperature and humidity."""
+        # make sure CHT8305's internal object is valid before I2C operation
+        if self._i2cDev is None:
+            raise ValueError("invalid I2C object")
+
+        temphumidity = [0, 1]
+         # send temperature register to CHT8305
+        reg = bytearray([CHT8305_REG_TEMP])
+        self._i2cDev.write(reg)
+        sleep_ms(30)
+
+        # 4 bytes means read temperature and humidity back in one read operation
+        readData = bytearray(4)
+        self._i2cDev.read(readData)
+        #print("rawdata %d-%d-%d-%d" %(readData[0],readData[1],readData[2],readData[3]))
+
+        # convert the temperature and humidity data to actual value
+        value = (readData[0] << 8) | readData[1]
+        if (value & 0xFFFC):
+            temphumidity[0] = (165.0 * float(value)) / 65536.0 - 40.0
+        else:
+            raise CHT8305Error("failed to get temperature.")
+
+        value = (readData[2] << 8) | readData[3]
+        if (value & 0xFFFE):
+            temphumidity[1] = ((125.0 * float(value)) / 65535.0) - 6.0
+        else:
+            raise CHT8305Error("failed to get humidity.")
+
+        return temphumidity
+
+
+if __name__ == "__main__":
+    '''
+    The below i2c configuration is needed in your board.json.
+    "cht8305": {
+    "type": "I2C",
+    "port": 1,
+    "addrWidth": 7,
+    "freq": 400000,
+    "mode": "master",
+    "devAddr": 64
+    }
+    '''
+    print("Testing cht8305 ...")
+
+    i2cDev = I2C()
+    i2cDev.open("cht8305")
+
+    cht8305Dev = CHT8305(i2cDev)
+
+    temperature = cht8305Dev.getTemperature()
+    print("The temperature is: %f" % temperature)
+
+    humidity = cht8305Dev.getHumidity()
+    print("The humidity is: %f" % humidity)
+
+    i2cDev.close()
+
+    print("Test cht8305 done!")
diff --git a/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/haaseduk1.py b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/haaseduk1.py
new file mode 100644
index 0000000000..c5ed62c9b9
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/haaseduk1.py
@@ -0,0 +1,62 @@
+"""
+Copyright (C) 2015-2021 Alibaba Group Holding Limited
+"""
+from driver import I2C
+import kv
+
+class HAASEDUK1(object):
+    def __init__(self):
+        self.i2cDev = None
+
+    # 获取版本号
+    # 返回值为1，代表k1c
+    # 返回值为0，代表k1
+    def getHWID(self):
+        hwId = -1
+        result = kv.geti("HAASEDU_NAME")
+        if (result != None):
+            if (result == 1):
+                print("HAASEDUK1 hw version is 1.1")
+                return 1
+            elif (result == 0):
+                print("HAASEDUK1 hw version is 1.0")
+                return 0
+            else:
+                pass
+        # kv中不存在HAASEDU_NAME键值对，则通过外围传感器进行判断
+        # 读取QMI8610传感器device identifier register的值
+        self.i2cDev = I2C()
+        self.i2cDev.open("qmi8610")
+        buf = bytearray(1)
+        buf[0] = 0
+        self.i2cDev.memRead(buf, 0, 8) # register address:0 - FIS device identifier register address
+        self.i2cDev.close()
+        if buf[0] == 0xfc:
+            hwId = 1
+        else:
+            # 读取QMI8610传感器chip id register的值
+            self.i2cDev.open("qmp6988")
+            buf[0] = 0xD1 # chip id register
+            self.i2cDev.write(buf)
+            self.i2cDev.read(buf)
+            self.i2cDev.close()
+            if buf[0] == 0x5C:
+                hwId = 1
+            else:
+                # 读取QMC6310传感器chip id register的值
+                self.i2cDev.open("qmc6310")
+                buf[0] = 0x00 # chip id register
+                self.i2cDev.write(buf)
+                self.i2cDev.read(buf)
+                self.i2cDev.close()
+                if buf[0] == 0x80:
+                    hwId = 1
+        if hwId == 1:
+            kv.seti("HAASEDU_NAME", 1)
+            print("HAASEDUK1 hw version is 1.1")
+            return 1
+        else:
+            kv.seti("HAASEDU_NAME", 0)
+            print("HAASEDUK1 hw version is 1.0")
+            return 0
+
diff --git a/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/main.py b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/main.py
new file mode 100644
index 0000000000..706ab9d861
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/main.py
@@ -0,0 +1,202 @@
+# -*- encoding: utf-8 -*-
+'''
+@File       :    main.py
+@Description:    温湿度上云
+@Author     :    ethan.lcz
+@version    :    1.0
+'''
+from aliyunIoT import Device      # aliyunIoT组件是连接阿里云物联网平台的组件
+import netmgr as nm               # Wi-Fi功能所在库
+import utime                      # 延时API所在组件
+from driver import I2C            # I2C总线驱动库
+from driver import GPIO           # ESP32和使用GPIO控制LED
+from haaseduk1 import HAASEDUK1   # 引入haaseduk1库，目标用于区分K1版本
+import ujson                      # json字串解析库
+
+
+
+# 物联网平台连接标志位
+iot_connected = False
+
+# 物联网设备实例
+device = None
+
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+
+
+# Wi-Fi SSID和Password设置
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+
+# 空调和加湿器状态变量
+airconditioner = 0
+humidifier = 0
+airconditioner_value = 0
+humidifier_value = 0
+
+humitureDev = 0
+board = HAASEDUK1()                  # 新建HAASEDUK1对象
+hwID = board.getHWID()               # 获取开发板ID
+i2cObj = I2C()
+
+if (hwID == 1):
+    from cht8305 import CHT8305      # HaaS EDU K1C上的温湿度传感器采用的是CHT8305
+    i2cObj.open("cht8305")           # 按照board.json中名为"cht8305"的设备节点的配置参数（主设备I2C端口号，从设备地址，总线频率等）初始化I2C类型设备对象
+    humitureDev = CHT8305(i2cObj)   # 初始化CHT8305传感器
+    # print("cht8305 inited!")
+else:
+    from si7006 import SI7006        # HaaS EDU K1上的温湿度传感器采用的是SI7006
+    i2cObj.open("si7006")            # 按照board.json中名为"si7006"的设备节点的配置参数（主设备I2C端口号，从设备地址，总线频率等）初始化I2C类型设备对象
+    humitureDev = SI7006(i2cObj)   # 初始化SI7006传感器
+    version = humitureDev.getVer()  # 获取SI7006的版本信息
+    chipID = humitureDev.getID()    # 获取SI7006 ID信息
+    # print("si7006 version:%d, chipID:%d" , version, chipID)
+
+
+# 等待Wi-Fi成功连接到路由器
+def get_wifi_status():
+   nm.init()
+   nm.disconnect()
+   wifi_connected = nm.getStatus()
+   print("start to connect " , wifiSsid)
+   nm.connect(wifiSsid, wifiPassword)       # 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
+
+   while True :
+      if wifi_connected == 5:               # nm.getStatus()返回5代表连线成功
+        break
+      else:
+        wifi_connected = nm.getStatus() # 获取Wi-Fi连接路由器的状态信息
+        utime.sleep(0.5)
+   print("Wi-Fi connected")
+   print('DeviceIP:' + nm.getInfo()['ip'])  # 打印Wi-Fi的IP地址信息
+
+# 通过温湿度传感器读取温湿度信息
+def get_temp_humi():
+    global humitureDev
+    '''
+    # 如果需要同时获取温湿度信息，可以呼叫getTempHumidity，实例代码如下:
+    humniture = humitureDev.getTempHumidity()          # 获取温湿度传感器测量到的温湿度值
+    temperature = humniture[0]                          # get_temp_humidity返回的字典中的第一个值为温度值
+    humidity = humniture[1]                             # get_temp_humidity返回的字典中的第二个值为相对湿度值
+    '''
+    temperature = humitureDev.getTemperature()         # 获取温度测量结果
+    # print("The temperature is: %.1f" % temperature)
+
+    humidity = humitureDev.getHumidity()               # 获取相对湿度测量结果
+    # print("The humidity is: %d" % humidity)
+
+    return temperature, humidity                        # 返回读取到的温度值和相对湿度值
+
+# 物联网平台连接成功的回调函数
+def on_connect(data):
+    global iot_connected
+    iot_connected = True
+
+# 设置props 事件接收函数（当云平台向设备下发属性时）
+def on_props(request):
+    global airconditioner, humidifier, airconditioner_value, humidifier_value
+
+    # {"airconditioner":1} or {"humidifier":1} or {"airconditioner":1, "humidifier":1}
+    payload = ujson.loads(request['params'])
+    # print (payload)
+    # 获取dict状态字段 注意要验证键存在 否则会抛出异常
+    if "airconditioner" in payload.keys():
+        airconditioner_value = payload["airconditioner"]
+        if (airconditioner_value):
+            print("打开空调")
+        else:
+            print("关闭空调")
+
+    if "humidifier" in payload.keys():
+        humidifier_value = payload["humidifier"]
+        if (humidifier_value):
+            print("打开加湿器")
+        else:
+            print("关闭加湿器")
+
+    # print(airconditioner_value, humidifier_value)
+
+    airconditioner.write(airconditioner_value) # 控制空调开关
+    humidifier.write(humidifier_value)         # 控制加湿器开关
+
+    # 要将更改后的状态同步上报到云平台
+    prop = ujson.dumps({
+        'airconditioner': airconditioner_value,
+        'humidifier': humidifier_value,
+    })
+
+    upload_data = {'params': prop}
+    # 上报空调和加湿器属性到云端
+    device.postProps(upload_data)
+
+
+# 连接物联网平台
+def connect_lk(productKey, deviceName, deviceSecret):
+    global device, iot_connected
+    key_info = {
+        'region': 'cn-shanghai',
+        'productKey': productKey,
+        'deviceName': deviceName,
+        'deviceSecret': deviceSecret,
+        'keepaliveSec': 60
+    }
+    # 将三元组信息设置到iot组件中
+    device = Device()
+
+    # 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
+    device.on(Device.ON_CONNECT, on_connect)
+
+    # 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
+    device.on(Device.ON_PROPS, on_props)
+
+    # 启动连接阿里云物联网平台过程
+    device.connect(key_info)
+
+    # 等待设备成功连接到物联网平台
+    while(True):
+        if iot_connected:
+            print('物联网平台连接成功')
+            break
+        else:
+            print('sleep for 1 s')
+            utime.sleep(1)
+
+# 上传温度信息和湿度信息到物联网平台
+def upload_temperature_and_Humidity():
+    global device
+
+    while True:
+        data = get_temp_humi()                      # 读取温度信息和湿度信息
+
+        # 生成上报到物联网平台的属性值字串
+        prop = ujson.dumps({
+            'CurrentTemperature': data[0],
+            'CurrentHumidity': data[1]
+            })
+        print('uploading data: ', prop)
+
+        upload_data = {'params': prop}
+        # 上传温度和湿度信息到物联网平台
+        device.postProps(upload_data)
+        utime.sleep(2)
+
+if __name__ == '__main__':
+    # 硬件初始化
+    # 初始化 GPIO
+    airconditioner = GPIO()
+    humidifier = GPIO()
+
+    humidifier.open('led_g')     # 加湿器使用board.json中led_g节点定义的GPIO，对应HaaS EDU K1上的绿灯
+    airconditioner.open('led_b') # 空调使用board.json中led_b节点定义的GPIO，对应HaaS EDU K1上的蓝灯
+
+    # 请替换物联网平台申请到的产品和设备信息,可以参考文章:https://blog.csdn.net/HaaSTech/article/details/114360517
+    # global productKey, deviceName, deviceSecret ,on_request, on_play
+    get_wifi_status()
+
+    connect_lk(productKey, deviceName, deviceSecret)
+    upload_temperature_and_Humidity()
+
+humitureDev.close()
diff --git a/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/si7006.py b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/si7006.py
new file mode 100644
index 0000000000..3f280e2819
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/floriculture/haaseduk1/code/si7006.py
@@ -0,0 +1,181 @@
+"""
+Copyright (C) 2015-2021 Alibaba Group Holding Limited
+
+    MicroPython's drive for SI7006
+
+    Author: HaaS
+    Date:   2021/09/09
+"""
+
+from driver import I2C
+from utime import sleep_ms
+
+
+# The commands provided by SI7006
+Si7006_MEAS_REL_HUMIDITY_MASTER_MODE    = 0xE5
+Si7006_MEAS_REL_HUMIDITY_NO_MASTER_MODE = 0xF5
+Si7006_MEAS_TEMP_MASTER_MODE            = 0xE3
+Si7006_MEAS_TEMP_NO_MASTER_MODE         = 0xF3
+Si7006_READ_OLD_TEMP                    = 0xE0
+Si7006_RESET                            = 0xFE
+Si7006_READ_ID_LOW_0                    = 0xFA
+Si7006_READ_ID_LOW_1                    = 0x0F
+Si7006_READ_ID_HIGH_0                   = 0xFC
+Si7006_READ_ID_HIGH_1                   = 0xC9
+Si7006_READ_Firmware_Revision_0         = 0x84
+Si7006_READ_Firmware_Revision_1         = 0xB8
+
+class SI7006Error(Exception):
+    def __init__(self, value=0, msg="si7006 common error"):
+        self.value = value
+        self.msg = msg
+
+    def __str__(self):
+        return "Error code:%d, Error message: %s" % (self.value, str(self.msg))
+
+    __repr__ = __str__
+
+
+class SI7006(object):
+    """
+    This class implements SI7006 chip's functions.
+    """
+    # i2cDev should be an I2C object and it should be opened before __init__ is called
+    def __init__(self, i2cDev):
+        self._i2cDev = None
+        if not isinstance(i2cDev, I2C):
+            raise ValueError("parameter is not an I2C object")
+        # make SI7006's internal object points to i2cDev
+        self._i2cDev = i2cDev
+
+    def getVer(self):
+        """
+        Get the firmware version of the chip.
+        """
+        # make sure SI7006's internal object is valid before I2C operation
+        if self._i2cDev is None:
+            raise ValueError("invalid I2C object")
+        # send read firmware version command to SI7006
+        reg = bytearray([Si7006_READ_Firmware_Revision_0, Si7006_READ_Firmware_Revision_1])
+        self._i2cDev.write(reg)
+        sleep_ms(30)
+        version = bytearray(1)
+        # read the version info back
+        self._i2cDev.read(version)
+        return version[0]
+
+    def getID(self):
+        """Get the chip ID."""
+        # make sure SI7006's internal object is valid before I2C operation
+        if self._i2cDev is None:
+            raise ValueError("invalid I2C object")
+
+        # send read chip id‘s lower part command to SI7006
+        reg = bytearray([Si7006_READ_ID_LOW_0, Si7006_READ_ID_LOW_1])
+        self._i2cDev.write(reg)
+        sleep_ms(30)
+        id_buf_low = bytearray(4)
+        # read the id info back
+        self._i2cDev.read(id_buf_low)
+
+        # send read chip id‘s higher part command to SI7006
+        reg = bytearray([Si7006_READ_ID_HIGH_0, Si7006_READ_ID_HIGH_1])
+        id_buf_high = bytearray(4)
+        self._i2cDev.read(id_buf_high)
+
+        return id_buf_low + id_buf_high
+
+    def getTemperature(self):
+        """Get temperature."""
+        # make sure SI7006's internal object is valid before I2C operation
+        if self._i2cDev is None:
+            raise ValueError("invalid I2C object")
+
+        # send measure temperature command to SI7006
+        reg = bytearray([Si7006_MEAS_TEMP_NO_MASTER_MODE])
+        self._i2cDev.write(reg)
+        # wait for 30ms to wait for the measure finish according to SI7006's datasheet
+        sleep_ms(30)
+        readData = bytearray(2)
+        # read the temperature measure result
+        self._i2cDev.read(readData)
+        value = (readData[0] << 8 | readData[1])
+
+        # convert to actual temperature
+        if (value & 0xFFFC):
+            temperature = (175.72 * value) / 65536.0 - 46.85
+            return round(temperature, 1)
+        else:
+            raise SI7006Error("failed to get temperature.")
+
+    def getHumidity(self):
+        """Get humidity."""
+        # make sure SI7006's internal object is valid before I2C operation
+        if self._i2cDev is None:
+            raise ValueError("invalid I2C object")
+
+        # send measure humidity command to SI7006
+        reg = bytearray([Si7006_MEAS_REL_HUMIDITY_NO_MASTER_MODE])
+        self._i2cDev.write(reg)
+        # wait for 30ms to wait for the measure finish according to SI7006's datasheet
+        sleep_ms(30)
+        readData = bytearray(2)
+        self._i2cDev.read(readData)
+        value = (readData[0] << 8) | readData[1]
+
+        # convert to actual humidity
+        if (value & 0xFFFE):
+            humidity = (125.0 * value) / 65535.0 - 6.0
+            return round(humidity)
+        else:
+            raise SI7006Error("failed to get humidity.")
+
+    def getTempHumidity(self):
+        """Get temperature and humidity."""
+        # make sure SI7006's internal object is valid before I2C operation
+        if self._i2cDev is None:
+            raise ValueError("invalid I2C object")
+
+        # read tempperature and humidity in sequence
+        temphumidity = [0, 0]
+        temphumidity[0] = self.getTemperature()
+        temphumidity[1] = self.getHumidity()
+        return temphumidity
+
+
+if __name__ == "__main__":
+    '''
+    The below i2c configuration is needed in your board.json.
+    "si7006": {
+    "type": "I2C",
+    "port": 1,
+    "addrWidth": 7,
+    "freq": 400000,
+    "mode": "master",
+    "devAddr": 64
+    }
+    '''
+    print("Testing si7006 ...")
+
+    i2cDev = I2C()
+    i2cDev.open("si7006")
+
+    si7006Dev = SI7006(i2cDev)
+
+    version = si7006Dev.getVer()
+    print("si7006 version is: %d" % version)
+
+    chipID = si7006Dev.getID()
+    print("si7006 chip id is:", chipID)
+
+
+    temperature = si7006Dev.getTemperature()
+    print("The temperature is: %f" % temperature)
+
+    humidity = si7006Dev.getHumidity()
+    print("The humidity is: %d" % humidity)
+
+    i2cDev.close()
+
+    print("Test si7006 done!")
+
diff --git a/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/README.md b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/README.md
new file mode 100644
index 0000000000..1976d75284
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/README.md
@@ -0,0 +1,559 @@
+# 燃气检测系统
+&emsp;&emsp;
+下图是本案例除硬件连线外的3步导学，每个步骤中实现的功能请参考图中的说明。
+<div align="center">
+<img src=./../../../images/2_燃气检测_步骤概述.jpg width=70%/>
+</div>
+
+## 1、简介
+&emsp;&emsp;
+天然气是国人目前家庭里边烹饪和取暖所用的主要燃料，其主要成分是甲烷（CH4），同时还含有少量的丙烷、乙烷、丁烷等其他少量气体。天然气本身无色无味，密度比空气小。如果发生天然气泄漏，其在空气中浓度达到5%～15%时，遇到明火就会爆炸。如今天然气普及，每年由于因使用不当、人为因素（忘记关闭开关）造成的燃气泄漏爆炸事故接连不断。
+
+&emsp;&emsp;
+本节内容就以此为背景教开发者如何一步一步打造一个燃气泄漏检测系统。
+
+### 1.1、准备
+&emsp;&emsp;
+完成本节内容的学习需要如下硬件：
+1. [HaaS EDU K1开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C5AB3B8A4A88800000001&dataId=800C5AB3B8A4A888)       一台
+2. [MQ2燃气传感器](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800CEE990B95992200000002&dataId=800CEE990B959922)             一个
+3. 连接线若干
+
+
+&emsp;&emsp;
+硬件连线图如下图所示：
+<div align="center">
+<img src=./../../../images/2_燃气检测_HaaS_EDU_K1_MQ2连线.png width=70%/>
+</div>
+<br>
+
+## 2、物联网平台开发
+&emsp;&emsp;
+对于第一次使用物联网平台的读者，需要开通实例以使用物联网平台的功能。这里可以使用免费的公共实例进行开发。
+
+&emsp;&emsp;
+在[物联网平台](https://iot.console.aliyun.com/lk/summary/new)中，左上角选择“华东2-上海”，点击“公共实例”，即可开通。开通后点击“公共实例”，即可进入[控制台](https://iot.console.aliyun.com/lk/summary/new)进行产品创建。
+
+<div align="center">
+<img src=./../../../images/5_3_开通公共实例.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+开通物联网平台功能之后，需要完成下面的3个步骤完成云端设备的创建：
+1. 创建云端产品
+2. 创建产品属性（物模型）
+3. 创建云端设备（获取三元组）
+
+### 2.1、创建云端产品
+&emsp;&emsp;
+点击上图中的“公共实例”，即可进入[控制台](https://iot.console.aliyun.com/lk/summary/new)进行产品创建。然后，点击创建产品按钮，如下图所示。
+
+<div align="center">
+<img src=./../../../images/1_创建产品.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+在新建产品设定页面按照下图所示，设定“产品名称”，选择所属的“自定义品类”（自定义品类的物模型为空，需要自己创建，也可以通过导入外部物模型的方式导入），节点类型选择“直连设备”，联网方式选择“Wi-Fi”，数据格式选择“ICA标准数据格式”，检验类型和认证方式选择默认设定即可。还可以根据开发者自己的需求在“产品描述”页面添加针对此产品的描述。
+<div align="center">
+<img src=./../../../images/2_新建燃气检测设备.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+选择之后，点击“确认”按钮，即可完成产品创建。返回“产品”页面之后可以看到产品类表中会出现刚刚创建的“燃气检测系统”的产品，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_燃气检测系统_产品列表页.png width=100%/>
+</div>
+
+<br>
+
+### 2.2、创建产品属性（物模型）
+&emsp;&emsp;
+点击上图中的“查看”按钮，即可看到产品信息，Topic列表，功能定义，数据解析等跟产品相关功能的设定。点开“功能定义”标签页，可以看到设备物模型定义。
+
+<div align="center">
+<img src=./../../../images/2_燃气检测系统_产品详情页面.png width=100%/>
+</div>
+
+&emsp;&emsp;
+标识符是设备端上报设备属性状态的消息中需要使用的标识符，并且只有在设备上报的属性内容符合“数据定义”中的数据取值范围的时候才会被物联网平台记录，否则会被物联网平台认定为非法属性而过滤掉。
+
+&emsp;&emsp;
+本节我们选择导入物模型的方式来创建此系统需要的物模型信息，点击上图中的”编辑草稿“按钮。然后按照下图的步骤，选择本地文件导入[燃气检测系统物模型](./link_platform/gas_detector_model.zip)。
+
+<div align="center">
+<img src=./../../../images/2_燃气检测系统_快速导入物模型.png width=100%/>
+</div>
+
+&emsp;&emsp;
+物模型导入成功后可以看到网页出现了我们刚刚导入的物模型属性。其中alarmLight代表的是燃气灯的报警状态，1处于报警状态，0代表没有报警；gasVoltage代表MQ2燃气传感器检测到的电压值。
+
+
+<div align="center">
+<img src=./../../../images/2_燃气检测系统_发布物模型.png width=100%/>
+</div>
+&emsp;&emsp;
+产品及其物模型创建完成后就可以创建这个产品的设备了。
+
+<br>
+
+### 2.3、创建云端设备（获取三元组）
+&emsp;&emsp;
+在产品列表页面中，点击”燃气检测系统“后的“管理设备”，就会进到设备管理页面。
+
+<div align="center">
+<img src=./../../../images/2_燃气检测系统_产品页_管理设备.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“设备”页面点击“添加设备”按钮，如下图所示。
+<div align="center">
+<img src=./../../../images/2_燃气检测系统_添加设备入口.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“添加设备”页面中设定“deviceName”，这里开发者可以自己填入自己想设定的设备名称，也可以不填任何内容让系统自动生成设备名称，如下图所示。
+<div align="center">
+<img src=./../../../images/1_添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备添加完成后，点击“前往查看”按钮，就可以看到此设备端详细信息了。
+<div align="center">
+<img src=./../../../images/1_完成添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备信息中有两个信息需要和设备端开发相匹配：
+1. 三元组
+2. 物模型属性信息
+
+<div align="center">
+<img src=./../../../images/2_燃气检测系统设备详情.png width=100%/>
+</div>
+
+<br>
+
+#### 2.4.1、**获取设备三元组**
+&emsp;&emsp;
+如上图所示，点击“查看”按钮，就可以看到设备的三元组信息，三元组是物联网设备端和物联网云端设备相关联的唯一标识符，在设备端连接云端的时候会使用三元组信息和云端进行鉴权，鉴权通过之后云端会认为设备已激活并上线。
+
+<div align="center">
+<img src=./../../../images/2_燃气检测系统_设备三元组.png width=50%/>
+</div>
+
+<br>
+
+#### 2.4.2、**查看设备属性信息**
+&emsp;&emsp;
+设备详情信息页中的“物模型数据”标签页中可以看到设备的所有属性信息、设备时间上报情况及设备服务调用情况，如下图所示。待物联网设备按照设备属性对应的标识符上报设备属性的时候，本图片中的“燃气检测电压值“，”报警灯“等属性值就会显示设备最新的属性信息。
+<div align="center">
+<img src=./../../../images/2_燃气检测系统_设备物模型数据.png width=100%/>
+</div>
+
+<br>
+
+> 创建产品和设备的过程是按照面向对象的思想进行设计的，其中创建产品可以看成是新建一个类，其中的物模型则是类的对象，创建设备则是进行类的实例化。
+
+<br>
+
+## 3、设备端开发
+
+### 3.1、开发环境
+
+&emsp;&emsp;
+在进行下一步之前请确保HaaS EDU K1开发环境已经搭建完毕。详情请参考[HaaS EDU K1开发环境](../../../startup/HaaS_EDU_K1_startup.md)的说明。
+
+### 3.2、创建解决方案
+
+&emsp;&emsp;
+如下图所示，在Haas Studio中创建项目。先选择左侧的“开发板型号”再从右侧的案例中选择“燃气检测系统”案例点击“立即创建”即可。
+
+<div align="center">
+<img src=./../../../images/HaaS_Studio_创建工程示范.png width=100%/>
+</div>
+<br>
+
+1. **修改路由器名称及密码**
+&emsp;&emsp;
+修改工程里main.py中wifiSsid和wifiPassword的值为读者实际要连接的路由器的名称及密码（请注意名称和密码都需要放在""符号中间）。
+
+```python
+# Wi-Fi SSID和Password设置
+wifi_ssid = "请填写您的路由器名称"
+wifi_password = "请填写您的路由器密码"
+```
+
+&emsp;&emsp;
+修改完成之后get_wifi_status函数中的代码就会连接读者自己设定的路由器。
+
+2. **修改设备端三元组**
+
+&emsp;&emsp;
+修改gas_detector工程里main.py中productKey、deviceName和deviceSecret的值为读者创建的物联网设备的三元组信息，如下所示：
+
+```python
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+```
+
+3. **修改设备端上报数据所用标识符**
+&emsp;&emsp;
+gas_detector工程里main.py中下面的代码实现的是上传燃气检测结果和报警灯状态到云端的功能。其中gasVoltate便是燃气检测结果上报云端所用的标识符。代码逻辑及功能说明如下：
+
+```python
+# 上传燃气传感器检测电压信息和报警信息到物联网平台
+def upload_gas_detector_state():
+    global device, alarmOn, mq2Dev
+
+    gasVoltage = 0
+
+    # 无限循环
+    while True:
+        gasVoltage = mq2Dev.getVoltage()   # 呼叫mq2传感器库提供的getVoltage函数获取电压值，单位：mV
+
+        print(gasVoltage)
+        data = ujson.dumps({
+            'gasVoltage': gasVoltage,
+            'alarmLight': alarmOn
+        })
+        # 生成上报到物联网平台的属性值字串，此处的属性标识符"gasVoltage"和"alarmLight"必须和物联网平台的属性一致
+        # "gasVoltage" - 代表燃气传感器测量到的电压值
+        # "alarmLight" - 代表报警灯的当前状态
+        uploadData = {'params': data}
+        # 上传燃气传感器检测电压信息和报警信息到物联网平台
+
+        device.postProps(uploadData)
+
+        # 每2秒钟上报一次
+        utime.sleep(2)
+```
+
+&emsp;&emsp;
+确保这两个标识符和物联网产品的物模型中属性标识符是一样的，如下图所示：
+<div align="center">
+<img src=./../../../images/1_ESP32_gasVoltage_属性标识符.png
+ width=70%/>
+</div>
+
+<br>
+
+## 4、运行结果
+### 4.1、本地查看
+
+&emsp;&emsp;
+推送此脚本到HaaS EDU K1之后，通过PC端串口调试工具可以看到HaaS EDU K1打印如下日志。其中:
+* “物联网平台连接成功” 代表成功连接到物联网平台
+* "reporting data to cloud:"之后跟着的为设备端向云端发布的燃气检测结果信息，gasVoltage后 的值为燃气传感器检测的电压值，单位：mV
+* "{"alarmLight":x}"则是收到云端回复的控制报警灯亮灭的控制指令，1代表打开报警灯，此时接在HaaS EDU K1的红色LED应该亮起；0代表关闭报警灯，此时接在HaaS EDU K1的红色LED应该熄灭。(注意：这条log的及报警灯亮灭的行为是云端下发控制指令触发，只有在完成下一步“物联网应用开发”小节之后才会打印)
+
+```log
+...
+             Welcome to AliOS Things           
+dev /dev/wifi0 is already add
+ ==== python execute from /data/pyamp/main.py ====
+ Welcome to MicroPython 
+...
+Wi-Fi connected
+DeviceIP:192.168.0.107
+sleep for 1 s
+...
+success to establish tcp, fd=4
+物联网平台连接成功
+reporting data to cloud: {"gasVoltage": 381, "alarmLight": 0}
+{"alarmLight":0}
+结束报警
+reporting data to cloud: {"gasVoltage": 382, "alarmLight": 0}
+{"alarmLight":0}
+结束报警
+reporting data to cloud: {"gasVoltage": 1200, "alarmLight": 1}
+{"alarmLight":1}
+开始报警
+...
+```
+### 4.2、物联网平台端设备信息查看
+
+&emsp;&emsp;
+物联网设备的系统启动成功并连接到物联网平台之后，物联网平台上对应的设备状态会从”未激活状态“变为”上线“，在物模型数据标签页上会显示设备上报到物联网平台的属性值。
+
+<div align="center">
+<img src=./../../../images/1_燃气检测系统_设备状态及属性.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此时如果开发板周围的燃气浓度发生变化，物联网平台的物模型数据会更新为设备上报的最新的属性值。
+
+<br>
+
+### 4.3、物联网平台控制报警灯状态
+<br>
+&emsp;&emsp;
+物联网设备上线之后，可以通过”监控运维“中的"在线调试"功能进行调试，详细操作步骤见下图：
+<div align="center">
+<img src=./../../../images/1_燃气检测系统_物联网平台在线调试功能.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此产品的物模型属性中，"燃气检测电压值"设置的是只读，也就是说智能从设备端读取，不支持设置此状态到设备端，所以点开"燃气超标标志"后面的”调试“之后，里边只有获取的选项。”报警灯“设置的是可读可写，所以点开”报警灯“后面的”调试“之后，里边有”获取“、”设置”和“设置期望值”三个选项。
+这里可以选择打开报警灯之后点击“设置”进行报警灯功能的调试。
+
+<div align="center">
+<img src=./../../../images/1_燃气检测系统_云端打开报警灯.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此时查看设备端LED是否已经打开，打开成功则代表控制报警灯成功。
+<br>
+<br>
+
+## 5、物联网应用开发
+
+&emsp;&emsp;
+通过本节课程的学习，读者可以搭建一个在手机上面可以随时随地查看燃气监控系统状态的应用。
+
+<br>
+
+### 5.1、燃气监控系统
+&emsp;&emsp;
+下图是一个典型的物联网应用程序开发的流程图，接下来本节就按照这个流程介绍如何完成燃气监控系统移动端应用程序的开发。
+
+<div align="center">
+<img src=./../../../images/1_物联网应用开发的一般流程.png width=80%/>
+</div>
+
+<br>
+
+### 5.2、**新建“普通项目”**
+&emsp;&emsp;
+打开[IoT Studio官网](https://studio.iot.aliyun.com/)，在项目管理中创建一个空白项目，如下图所示，将此项目命名为“燃气监控报警系统”。
+<div align="center">
+<img src=./../../../images/2_燃气监控报警系统_创建IoTStudio项目.png width=80%/>
+</div>
+
+<br>
+
+### 5.3、**新建“移动应用”**
+&emsp;&emsp;
+新建“普通项目”之后，在新项目的首页新建一个移动应用，命名为“燃气实时监控”。
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_移动应用创建.png width=80%/>
+</div>
+
+创建完移动应用之后系统会自动跳转到”新建页面“，这里选择”创建页面“完成应用页面的创建，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_移动应用_新建页面.png width=80%/>
+</div>
+
+&emsp;&emsp;
+移动端应用创建成功后会进入到应用界面设计页面。
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_移动应用_页面编辑页.png width=80%/>
+</div>
+
+
+&emsp;&emsp;
+点击上图红框中的“组件”按钮图标，就可以看到可用的组件列表。各组件的说明请参考[IoT Studio组件说明](https://help.aliyun.com/document_detail/125196.html)。
+
+<br>
+
+### 5.4、**页面设计**
+&emsp;&emsp;
+这里我们用到3个组件:
+* 实时曲线
+用于显示温湿度的历史变化曲线及实时数据
+* 指示灯
+显示和控制空调和加湿器的当前状态
+* 天气
+用于显示目的地天气
+
+&emsp;&emsp;
+将三个组件拖到中间的画布区，适当调整组件布局，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_实时监控页面设计.png width=80%/>
+</div>
+
+<br>
+
+### 5.5、**关联产品和设备**
+&emsp;&emsp;
+此时回到”燃气监控系统“项目的主页，对产品和设备进行关联，如下图所示：
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_关联产品和设备.png width=80%/>
+</div>
+
+
+&emsp;&emsp;
+关联产品的过程如下：
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_关联产品.png width=80%/>
+</div>
+
+&emsp;&emsp;
+关联设备的过程如下：
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_关联设备.png width=80%/>
+</div>
+&emsp;&emsp;
+产品和设备关联完毕之后，就可以将把组件和设备的属性关联起来了。
+
+<br>
+
+### 5.6、**关联数据源**
+&emsp;&emsp;
+关联数据源分为如下3个步骤，每个步骤的截图如下：
+* 关联产品
+* 关联设备
+* 关联属性
+
+&emsp;&emsp;
+具体操作步骤如下：
+1. 选中”开关“组件，点击右侧的“配置数据源”。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_指示灯_配置数据源.png width=80%/>
+</div>
+
+1. 选择目标产品
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_指示灯_选择产品.png width=80%/>
+</div>
+
+3. 选择目标设备
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_开关_配置数据源_设备.png width=80%/>
+</div>
+
+4. 选择“报警灯”属性
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_指示灯_配置数据源_报警灯.png width=80%/>
+</div>
+
+&emsp;&emsp;
+选择好产品、设备和属性之后，需要修改指示灯大小及”开始报警“/”停止报警“时指示灯的颜色，如下图所示。
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_指示灯_配置数据源_报警灯颜色.png width=80%/>
+</div>
+
+
+&emsp;&emsp;
+同样的方式为”实时曲线“设置为目标设备的”燃气检测电压“，并显示最近半小时的数据，如下图所示。
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_实时曲线设定.png width=80%/>
+</div>
+
+&emsp;&emsp;
+选中”天气“组件，可以设定要显示的是什么位置的天气，本节课程中显示默认地址即可，读者也可以设定自己所在地的信息，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_位置信息设定.png width=80%/>
+</div>
+
+<br>
+
+### 5.7、**业务逻辑开发**
+&emsp;&emsp;
+业务逻辑的主要目的是为了让用户设定物联网设备端的行为逻辑，常规物联网系统都是在设备端固化行为逻辑，出厂之后如果需要修改设备的行为，则需要进行OTA升级。本节课程则向读者介绍如何通过IoT Studio完成业务逻辑的开发。
+
+&emsp;&emsp;
+新建一条名为“燃气浓度超过阈值报警”的规则。
+<div align="center">
+<img src=./../../../images/2_燃气检测系统_创建业务逻辑.png width=80%/>
+</div>
+
+&emsp;&emsp;
+系统会自动进入到业务逻辑编辑页面，如下图所示，点击左侧的“节点”按钮，则可以看到所有可用的节点选项。右侧红框是如何设计一个业务逻辑的介绍。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_高浓度报警.png width=80%/>
+</div>
+
+1. 选择目标节点
+
+&emsp;&emsp;
+此逻辑需要通过“燃气检测设备”上报的“燃气测量电压”当超过阈值的时候打开报警灯，否则关闭报警灯。所以需要如下4个节点：
+* 设备触发节点
+* 条件判断节点
+* 开启报警灯节点
+* 关闭报警灯节点
+
+&emsp;&emsp;
+分别从左侧拖动“设备触发”，“条件判断”和2个“燃气检测系统”4个节点到右侧的业务 逻辑编辑框。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_节点列表.png width=80%/>
+</div>
+
+2. 建立节点间的关联关系
+
+&emsp;&emsp;
+按照预设的逻辑建立，如下图所示（在节点的一侧按下鼠标拖动到另一节点的一侧即可建立连线关系）。
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_节点逻辑关系建立.png width=80%/>
+</div>
+
+3. 业务逻辑编辑
+* 设备触发节点
+
+&emsp;&emsp;
+此设备触发选择“燃气检测设备”的“燃气检测电压”属性即可，如下图所示（和前面“组件”设定类似，同样是鼠标选中第节点，在右侧的配置选项中进行配置）。
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_设备触发节点配置.png width=80%/>
+</div>
+
+* 条件判断节点
+
+&emsp;&emsp;
+此处我们设定为当传感器测量到的电压值高于900mV则开始报警。设定步骤如下。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_比较节点配置.png width=80%/>
+</div>
+
+* 设备节点行为设定
+
+&emsp;&emsp;
+分别为设备节点设定开启报警灯和关闭报警灯的行为，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_设备节点行为设定.png width=80%/>
+</div>
+
+
+* 业务逻辑保存和部署
+
+&emsp;&emsp;
+依此点击右上角的“保存”和“部署”按钮，即可将此业务逻辑设定完毕。
+<br>
+
+
+<br>
+
+### 5.8、**预览和发布上线**
+
+&emsp;&emsp;
+业务逻辑设定完毕之后，可以在“燃气监控报警系统”页面编辑页面点击“预览”按钮进行预览，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控系统_预览.png width=80%/>
+</div>
+
+&emsp;&emsp;
+在发布之前可以点击上图的“预览”查看应用的实际运行效果。实际运行效果如下所示，同时可以扫描二维码在手机上面查看实际运行效果。
+
+<div align="center">
+<img src=./../../../images/2_燃气监控报警系统效果.gif width=80%/>
+</div>
+
+&emsp;&emsp;
+此时查看设备上面的报警灯的状态会同步和移动端应用的报警灯状态同步显示。
+<br>
+
+&emsp;&emsp;
+到此为止，燃气检测系统的案例就已经完成了。如果想要学习燃气检测系统更详细的操作步骤，请参考“[燃气检测系统详解](https://gitee.com/haasedu/haasedu/blob/release_2.0/2-%E6%99%BA%E8%83%BD%E7%94%9F%E6%B4%BB/%E5%9C%BA%E6%99%AF1-%E5%AE%88%E6%8A%A4%E5%AE%B6%E5%BA%AD%E5%81%A5%E5%BA%B7/%E7%87%83%E6%B0%94%E6%B3%84%E6%BC%8F%E6%A3%80%E6%B5%8B/README.md)”中的说明。
diff --git a/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/code/board.json b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/code/board.json
new file mode 100644
index 0000000000..b19ea70ccd
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/code/board.json
@@ -0,0 +1,195 @@
+{
+    "name": "haasedu",
+    "version": "1.0.0",
+    "io": {
+      "mq2": {
+        "type": "ADC",
+        "port": 2,
+        "sampling": 12000000
+      },
+      "led": {
+        "type": "GPIO",
+        "port": 36,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "led_r": {
+        "type": "GPIO",
+        "port": 36,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "ap3216c": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 30
+      },
+      "mpu6050": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 105
+      },
+      "si7006": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 64
+      },
+      "spl06": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 119
+      },
+      "qmc5883": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 13
+      },
+      "GPIO2": {
+        "type": "GPIO",
+        "port": 2,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "GPIO3": {
+        "type": "GPIO",
+        "port": 3,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO4": {
+        "type": "GPIO",
+        "port": 4,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO5": {
+        "type": "GPIO",
+        "port": 5,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO6": {
+        "type": "GPIO",
+        "port": 6,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO7": {
+        "type": "GPIO",
+        "port": 7,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO19": {
+        "type": "GPIO",
+        "port": 19,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO22": {
+        "type": "GPIO",
+        "port": 22,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "KEY_1": {
+        "type": "GPIO",
+        "port": 23,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "KEY_2": {
+        "type": "GPIO",
+        "port": 20,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "KEY_3": {
+        "type": "GPIO",
+        "port": 21,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "KEY_4": {
+        "type": "GPIO",
+        "port": 26,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "I2C1": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 60
+      },
+      "led_g": {
+        "type": "GPIO",
+        "port": 35,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "led_b": {
+        "type": "GPIO",
+        "port": 34,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "SPI0": {
+        "type": "SPI",
+        "port": 0,
+        "mode": "master",
+        "freq": 2000000
+      },
+      "oled_spi": {
+        "type": "SPI",
+        "port": 1,
+        "mode": "master",
+        "freq": 26000000
+      },
+      "oled_dc": {
+        "type": "GPIO",
+        "port": 28,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "oled_res": {
+        "type": "GPIO",
+        "port": 30,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "serial2": {
+        "type": "UART",
+        "port": 2,
+        "dataWidth": 8,
+        "baudRate": 115200,
+        "stopBits": 1,
+        "flowControl": "disable",
+        "parity": "none"
+      }
+    },
+    "debugLevel": "ERROR",
+    "repl": "disable"
+  }
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/code/main.py b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/code/main.py
new file mode 100644
index 0000000000..7e846c0a3e
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/code/main.py
@@ -0,0 +1,174 @@
+# -*- encoding: utf-8 -*-
+'''
+@File       :    main.py
+@Description:    燃气检测和报警灯控制
+@Author     :    ethan.lcz
+@version    :    1.0
+'''
+
+from aliyunIoT import Device  # aliyunIoT组件是连接阿里云物联网平台的组件
+import utime                   # 延时API所在组件
+import ujson                  # json字串解析库
+from driver import GPIO       # 开发板 LED使用GPIO进行控制
+from driver import ADC        # ADC类，通过微处理器的ADC模块读取ADC通道输入电压
+import netmgr as nm           # netmgr是Wi-Fi网络连接的组件
+import mq2                    # 引入MQ2传感器驱动库
+import ujson                  # json库
+
+adcObj = 0                 # ADC类型的外设对象
+mq2Dev = 0                 # MQ2燃气传感器对象
+alarmLed = 0               # 报警LED对象
+alarmOn = 0                # 记录报警状态
+
+# 物联网平台连接标志位
+iot_connected = False
+
+# Wi-Fi SSID和Password设置
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+
+wlan = None
+
+# 物联网设备实例
+device = None
+
+# 等待Wi-Fi成功连接到路由器
+def get_wifi_status():
+   nm.init()
+   nm.disconnect()
+   wifi_connected = nm.getStatus()
+   print("start to connect " + wifiSsid)
+   nm.connect(wifiSsid, wifiPassword)       # 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
+
+   while True :
+      if wifi_connected == 5:               # nm.getStatus()返回5代表连线成功
+            break
+      else:
+            wifi_connected = nm.getStatus() # 获取Wi-Fi连接路由器的状态信息
+            utime.sleep(0.5)
+            print("wifi_connected: " + wifi_connected)
+
+   print("Wi-Fi connected")
+   print('DeviceIP:' + nm.getInfo()['ip'])  # 打印Wi-Fi的IP地址信息
+
+# 设置props 事件接收函数（当云平台向设备下发属性时）
+def on_props(request):
+    global alarmOn
+    # print(request)
+    # {"alarmLight":1} or {"alarmLight":0}
+    payload = ujson.loads(request['params'])
+
+    # 获取dict状态字段 注意要验证键存在 否则会抛出异常
+    if "alarmLight" in payload.keys():
+        print(payload)
+        alarmOn = payload["alarmLight"]
+        if (alarmOn):
+            print("开始报警")
+        else:
+            print("结束报警")
+
+    # 根据云端设置的报警灯状态改变本地LED状态
+    led_control(alarmOn)
+
+    # 要将更改后的状态同步上报到云平台
+    data = ujson.dumps({'alarmLight': alarmOn,})
+    uploadData = { 'params': data }
+    # 上报本地报警灯状态到云端
+    device.postProps(uploadData)
+
+# 物联网平台连接成功的回调函数
+def on_connect(data):
+    global iot_connected
+    iot_connected = True
+
+def connect_lk(productKey, deviceName, deviceSecret):
+    global device, iot_connected
+    key_info = {
+        'region': 'cn-shanghai',
+        'productKey': productKey,
+        'deviceName': deviceName,
+        'deviceSecret': deviceSecret,
+        'keepaliveSec': 60
+    }
+    # 将三元组信息设置到iot组件中
+    device = Device()
+
+    # 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
+    device.on(Device.ON_CONNECT, on_connect)
+
+    # 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
+    device.on(Device.ON_PROPS, on_props)
+
+    # 启动连接阿里云物联网平台过程
+    device.connect(key_info)
+
+    # 等待设备成功连接到物联网平台
+    while(True):
+        if iot_connected:
+            print('物联网平台连接成功')
+            break
+        else:
+            print('sleep for 1 s')
+            utime.sleep(1)
+
+def led_control(on):
+    global alarmLed
+
+    if on == 0:
+        alarmLed.write(0)  # GPIO写入0，执行灭灯操作
+    else:
+        alarmLed.write(1)  # GPIO写入 1，执行亮灯报警动作
+
+
+# 上传燃气传感器测量结果和报警灯状态到物联网平台
+def upload_gas_detector_state():
+    global device, alarmOn, mq2Dev
+
+    gasVoltage = 0
+
+    # 无限循环
+    while True:
+        gasVoltage = mq2Dev.getVoltage()   # 呼叫mq2传感器库提供的getVoltage函数获取电压值，单位：mV
+
+        data = ujson.dumps({
+            'gasVoltage': gasVoltage,
+            'alarmLight': alarmOn
+        })
+        # 生成上报到物联网平台的属性值字串，此处的属性标识符"gasVoltage"和"alarmLight"必须和物联网平台的属性一致
+        # "gasVoltage" - 代表燃气传感器测量到的电压值
+        # "alarmLight" - 代表报警灯的当前状态
+        print('reporting data to cloud:', data)
+        uploadData = {'params': data}
+
+        # 上传燃气传感器测量结果和报警灯状态到物联网平台
+        device.postProps(uploadData)
+
+        # 每2秒钟上报一次
+        utime.sleep(2)
+
+if __name__ == '__main__':
+    # 硬件初始化
+    # 初始化 ADC
+    adcObj = ADC()                 # ADC通道对象
+    adcObj.open("mq2")             # 按照board.json中名为"mq2"节点的配置初始化ADC设备对象
+    mq2Dev = mq2.MQ2(adcObj)       # 初始化MQ2设备对象
+
+    # 初始化红色LED所连接GPIO
+    alarmLed = GPIO()
+    alarmLed.open('led')          # LED报警灯使用board.json中名为led的节点中定义的GPIO进行控制
+    led_control(alarmOn)          # 关闭报警灯
+
+    # 请替换物联网平台申请到的产品和设备信息,可以参考文章:https://blog.csdn.net/HaaSTech/article/details/114360517
+    # global productKey, deviceName, deviceSecret ,on_request, on_play
+    get_wifi_status()
+
+    connect_lk(productKey, deviceName, deviceSecret)
+    upload_gas_detector_state()
+
+    adcObj.close()
+    alarmLed.close()
diff --git a/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/code/mq2.py b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/code/mq2.py
new file mode 100644
index 0000000000..369901907a
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/code/mq2.py
@@ -0,0 +1,17 @@
+from driver import ADC
+
+class MQ2(object):
+
+    def __init__(self, adcObj):
+        self.adcObj = None
+        if not isinstance(adcObj, ADC):
+            raise ValueError("parameter is not an ADC object")
+
+        self.adcObj = adcObj
+
+    def getVoltage(self):
+        if self.adcObj is None:
+            raise ValueError("invalid ADC object")
+
+        value = self.adcObj.readVoltage()
+        return value
diff --git a/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/link_platform/gas_detector_model.zip b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/link_platform/gas_detector_model.zip
new file mode 100644
index 0000000000..be9cf87945
Binary files /dev/null and b/haas_lib_bundles/python/docs/examples/gas_detector/haaseduk1/link_platform/gas_detector_model.zip differ
diff --git a/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/README.md b/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/README.md
new file mode 100644
index 0000000000..cd008b6843
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/README.md
@@ -0,0 +1,308 @@
+# 甲醛浓度检测系统
+&emsp;&emsp;
+下图是本案例除硬件连线外的2步导学，每个步骤中实现的功能请参考图中的说明。在硬件连线完成之后我们建议您先使用“一分钟上云体验”功能预先体验本案例的实际运行效果。
+<div align="center">
+<img src=./../../../images/2_甲醛检测系统_步骤概述.jpg width=70%/>
+</div>
+
+## 1、简介
+&emsp;&emsp;
+甲醛(化学式HCHO或CH2O)是一种有特殊刺激气味的气体，对人的眼睛和鼻子有强烈的刺激作用。若空气中甲醛浓度过高，比如新装修的房子、新买的汽车等，可引起中毒反应，严重的可致癌。甲醛是空气中的杀手之一，需要时刻提防。
+
+### 1.1、背景知识
+&emsp;&emsp;
+本系统的核心在于如何精准的检测家庭中的甲醛浓度。现在市面上有很多种甲醛检测的仪器，大多企业在用的都是通过电化学的方法来检测。
+<div align="center">
+<img src=./../../../images/2_电化学甲醛传感器.jpeg  width=30%/>
+</div>
+&emsp;&emsp;
+电化学甲醛传感器对比其它方式来检测的的抗干扰能力强，响应专一，灵敏度高，测量结果精确，检测下限低，恢复-响应特性佳。
+
+&emsp;&emsp;
+本节选用的是HCHO甲醛传感器，可精确测量空气中的甲醛浓度，并能抑制干扰气体，具有稳定性高、抗干扰气体能力强等特点。分辨率高达0.01ppm，支持3.3~6V宽电压输入，具备良好的兼容性，并且使用寿命长达2年。 简单易用的Gravity接口、宽输入电压、支持模拟电压或者串口输出，几乎可兼容所有的主控器。
+
+<div align="center">
+<img src=./../../../images/2_DFROBOT甲醛传感器.jpeg  width=30%/>
+</div>
+
+> 甲醛传感器在使用之前需要预热5分钟以上。
+
+
+### 1.2、准备
+* [HaaS EDU K1开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C5AB3B8A4A88800000001&dataId=800C5AB3B8A4A888)     一台
+* [HCHO甲醛传感器](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C4F2BE3C4C4E800000002&dataId=800C4F2BE3C4C4E8)        一个
+* 杜邦连接线若干
+
+&emsp;&emsp;
+硬件连线图如下图所示：
+<div align="center">
+<img src=./../../../images/2_甲醛检测_HaaS_EDU_K1_HCHO_DAC_连线.jpg width=90%/>
+</div>
+<br>
+
+## 3、物联网平台开发
+### 3.1、开通公共实例
+&emsp;&emsp;
+对于第一次使用物联网平台的读者，需要开通实例以使用物联网平台的功能。这里可以使用免费的公共实例进行开发。
+
+&emsp;&emsp;
+在[物联网平台](https://iot.console.aliyun.com/lk/summary/new)中，左上角选择“华东2-上海”，点击“公共实例”，即可开通。
+<div align="center">
+<img src=./../../../images/5_3_开通公共实例.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+开通物联网平台功能之后，需要完成下面的3个步骤完成云端设备的创建：
+1. 创建云端产品
+2. 创建产品属性（物模型）
+3. 创建云端设备（获取三元组）
+
+### 3.2、创建云端产品
+&emsp;&emsp;
+点击上图中的“公共实例”，即可进入[控制台](https://iot.console.aliyun.com/lk/summary/new)进行产品创建。然后，点击创建产品按钮，如下图所示。
+<div align="center">
+<img src=./../../../images/1_创建产品.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+在新建产品设定页面按照下图所示，设定“产品名称”，选择所属的“自定义品类”（自定义品类的物模型为空，需要自己创建，也可以通过导入外部物模型的方式导入），节点类型选择“直连设备”，联网方式选择“Wi-Fi”，数据格式选择“ICA标准数据格式”，检验类型和认证方式选择默认设定即可。还可以根据开发者自己的需求在“产品描述”页面添加针对此产品的描述。
+<div align="center">
+<img src=./../../../images/2_新建甲醛检测设备.png width=50%/>
+</div>
+
+&emsp;&emsp;
+选择之后，点击“确认”按钮，即可完成产品创建。返回“产品”页面之后可以看到产品类表中会出现刚刚创建的“甲醛检测”的产品，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_甲醛检测系统_产品列表页.png width=100%/>
+</div>
+
+<br>
+
+### 3.3、创建产品属性（物模型）
+&emsp;&emsp;
+点击上图中的“查看”按钮，即可看到产品信息，Topic列表，功能定义，数据解析等跟产品相关功能的设定。点开“功能定义”标签页，可以看到设备物模型定义。
+
+<div align="center">
+<img src=./../../../images/2_甲醛检测系统_产品详情页面.png width=100%/>
+</div>
+
+&emsp;&emsp;
+标识符是设备端上报设备属性状态的消息中需要使用的标识符，并且只有在设备上报的属性内容符合“数据定义”中的数据取值范围的时候才会被物联网平台记录，否则会被物联网平台认定为非法属性而过滤掉。
+
+&emsp;&emsp;
+本节我们选择创建自定义物模型的方式来创建此系统需要的物模型信息，点击上图中的”编辑草稿“按钮。然后按照下图的步骤，选择添加自定义功能。
+
+<div align="center">
+<img src=./../../../images/2_甲醛检测_创建自定义物模型1.png width=100%/>
+</div>
+
+然后按照下图选择甲醛浓度属性添加。
+<div align="center">
+<img src=./../../../images/2_甲醛检测_创建自定义物模型2.png width=50%/>
+</div>
+
+&emsp;&emsp;
+物模型添加成功之后可以看到网页出现了我们刚刚创建的物模型属性。其中HCHO代表甲醛传感器检测到的浓度值，数据类型为double浮点型，单位为ppm。此时点击“发布”按钮，按照系统提示一步一步进行下去就可以将刚刚创建的物模型属性发布到产品中。
+
+
+<div align="center">
+<img src=./../../../images/2_甲醛检测_发布物模型.png width=100%/>
+</div>
+&emsp;&emsp;
+产品及其物模型创建完成后就可以创建这个产品的设备了。
+
+<br>
+
+### 3.4、创建云端设备（获取三元组）
+&emsp;&emsp;
+在产品列表页面中，点击”甲醛检测“后的“管理设备”，就会进到设备管理页面。
+
+<div align="center">
+<img src=./../../../images/2_甲醛检测_产品页_管理设备.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“设备”页面点击“添加设备”按钮，如下图所示。
+<div align="center">
+<img src=./../../../images/1_添加设备入口.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“添加设备”页面中设定“deviceName”，这里开发者可以自己填入自己想设定的设备名称，也可以不填任何内容让系统自动生成设备名称，如下图所示。
+<div align="center">
+<img src=./../../../images/1_添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备添加完成后，点击“前往查看”按钮，就可以看到此设备端详细信息了。
+<div align="center">
+<img src=./../../../images/1_完成添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备信息中有两个信息需要和设备端开发相匹配：
+1. 三元组（点击下图中的“查看”及可看到三元组信息）
+2. 物模型属性信息
+
+<div align="center">
+<img src=./../../../images/2_甲醛检测设备详情.png width=100%/>
+</div>
+
+<br>
+
+#### 3.4.1、**获取设备三元组**
+&emsp;&emsp;
+如上图所示，点击“查看”按钮，就可以看到设备的三元组信息（如下图所示），三元组是物联网设备端和物联网云端设备相关联的唯一标识符，在设备端连接云端的时候会使用三元组信息和云端进行鉴权，鉴权通过之后云端会认为设备已激活并上线。
+
+<div align="center">
+<img src=./../../../images/1_设备三元组_马赛克.png width=50%/>
+</div>
+
+<br>
+
+#### 3.4.2、**查看设备属性信息**
+&emsp;&emsp;
+设备详情信息页中的“物模型数据”标签页中可以看到设备的所有属性信息、设备事件上报情况及设备服务调用情况，如下图所示。待物联网设备按照设备属性对应的标识符上报设备属性的时候，本图片中的“甲醛浓度“属性值就会显示设备最新的属性信息。
+<div align="center">
+<img src=./../../../images/2_甲醛检测设备详情.png width=100%/>
+</div>
+
+<br>
+
+> 创建产品和设备的过程是按照面向对象的思想进行设计的，其中创建产品可以看成是新建一个类，其中的物模型则是类的对象，创建设备则是进行类的实例化。
+
+<br>
+
+
+## 3、设备端开发
+### 3.1、开发环境
+在进行下一步之前请确保HaaS EDU K1开发环境已经搭建完毕。详情请参考[HaaS EDU K1开发环境](../../../startup/HaaS_EDU_K1_startup.md)的说明。
+
+&emsp;&emsp;
+该款甲醛传感器支持Uart和ADC两种方式，本案例中采用了ADC模式。
+> 使用ADC模式前，请先将拨码开关切换到ADC一端。
+
+&emsp;&emsp;
+输出模拟电压（V）与浓度(ppm)是线性关系，0.4V对应0ppm, 2.0V对应5ppm，因此电压与浓度的线性关系图如下图所示：
+<div align="center">
+<img src=./../../../images/2_甲醛检测_DAC电压曲线.png  width=80%/>
+</div>
+
+### 3.2、创建解决方案
+
+&emsp;&emsp;
+如下图所示，在Haas Studio中创建项目。先选择左侧的“开发板型号”再从右侧的案例中选择“甲醛检测系统”案例点击“立即创建”即可。
+<div align="center">
+<img src=./../../../images/HaaS_Studio_创建工程示范.png width=100%/>
+</div>
+<br>
+
+> Python脚本的详细说明请参考脚本内嵌的文字版注释
+
+1. **修改路由器名称及密码**
+
+&emsp;&emsp;
+修改main.py中wifiSsid和wifiPassword的值为读者实际要连接的路由器的名称及密码（请注意名称和密码都需要放在""符号中间）。
+
+```python
+# Wi-Fi SSID和Password设置
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+```
+
+&emsp;&emsp;
+修改完成之后get_wifi_status函数中的nm.connect(wifiSsid, wifiPassword) 语句就会连接读者自己设定的路由器。
+
+2. **修改设备端三元组**
+
+&emsp;&emsp;
+修改本工程里main.py中productKey、deviceName和deviceSecret的值为读者创建的物联网设备的三元组信息。
+
+```python
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+```
+
+1. **修改设备端上报数据所用标识符**
+
+&emsp;&emsp;
+main.py中下面的代码实现的是上传甲醛检测结果到云端的功能。其中HCHO便是甲醛检测结果上报云端所用的标识符。
+
+```python
+    data = get_hcho_value()
+    H_str = "Hcho : " + str(round(data,2))+'ppm'
+    print('Hcho :' + str(round(data,2)) +'ppm')
+
+    # "HCHO" - 代表甲醛传感器测量到的浓度值
+    upload_data = {'params': ujson.dumps({
+        'HCHO': round(data,2),
+    })
+    }
+    # 上传甲醛浓度信息到物联网平台
+    device.postProps(upload_data)
+
+    # 每2秒钟上报一次
+    utime.sleep(2)
+```
+
+确保这个标识符和物联网产品的物模型中属性标识符是一样的，如下图所示：
+<div align="center">
+<img src=./../../../images/2_甲醛检测_属性标识符修改.png
+ width=100%/>
+</div>
+
+<br>
+
+## 4、运行结果
+
+### 4.1、本地查看
+
+&emsp;&emsp;
+推送此脚本到HaaS EDU K1之后并运行，串口会周期性的打印如下日志，其中：
+* Wi-Fi connected 代表Wi-Fi连线成功
+* Hcho:0.02ppm 代表检测到的甲醛浓度为0.02ppm
+
+```log
+>>> execfile("/data/pyamp/main.py")
+...
+             Welcome to AliOS Things           
+amp shakehand begin...
+dev /dev/wifi0 is already add
+ ==== python execute from /data/pyamp/main.py ====
+ Welcome to MicroPython 
+...
+Wi-Fi connected
+DeviceIP:192.168.0.107
+sleep for 1 s
+...
+success to establish tcp, fd=4
+物联网平台连接成功
+Hcho :0.02ppm
+Hcho :0.02ppm
+Hcho :0.02ppm
+```
+
+### 4.2、物联网平台端设备信息查看
+
+&emsp;&emsp;
+物联网设备的系统启动成功并连接到物联网平台之后，物联网平台上对应的设备状态会从”未激活状态“变为”上线“，在物模型数据标签页上会显示设备上报到物联网平台的属性值。
+
+<div align="center">
+<img src=./../../../images/2_甲醛检测_设备状态及属性.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此时如果开发板周围的甲醛浓度发生变化，物联网平台的物模型数据会更新为设备上报的最新的属性值。通过点击查看数据，可以看到一段时间监测到的甲醛浓度值。
+<div align="center">
+<img src=./../../../images/2_甲醛检测_查看数据.png width=100%/>
+</div>
+
+<br>
+
+&emsp;&emsp;
+到此为止，甲醛检测系统的案例就已经完成了。如果想要学习甲醛检测系统更详细的操作步骤，请参考“[甲醛检测系统详解](https://gitee.com/haasedu/haasedu/blob/release_2.0/2-%E6%99%BA%E8%83%BD%E7%94%9F%E6%B4%BB/%E5%9C%BA%E6%99%AF1-%E5%AE%88%E6%8A%A4%E5%AE%B6%E5%BA%AD%E5%81%A5%E5%BA%B7/%E7%94%B2%E9%86%9B%E6%A3%80%E6%B5%8B/README.md)”中的说明。
diff --git a/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/code/board.json b/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/code/board.json
new file mode 100644
index 0000000000..9819e89539
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/code/board.json
@@ -0,0 +1,194 @@
+{
+    "name": "haasedu",
+    "version": "1.0.0",
+    "io": {
+      "hcho": {
+        "type": "ADC",
+        "port": 2,
+        "sampling": 12000000
+      },
+      "led_r": {
+        "type": "GPIO",
+        "port": 36,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "ap3216c": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 30
+      },
+      "mpu6050": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 105
+      },
+      "si7006": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 64
+      },
+      "spl06": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 119
+      },
+      "qmc5883": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 13
+      },
+      "ADC2": {
+        "type": "ADC",
+        "port": 0,
+        "sampling": 12000000
+      },
+      "GPIO2": {
+        "type": "GPIO",
+        "port": 2,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "GPIO3": {
+        "type": "GPIO",
+        "port": 3,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO4": {
+        "type": "GPIO",
+        "port": 4,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO5": {
+        "type": "GPIO",
+        "port": 5,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO6": {
+        "type": "GPIO",
+        "port": 6,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO7": {
+        "type": "GPIO",
+        "port": 7,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO19": {
+        "type": "GPIO",
+        "port": 19,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO22": {
+        "type": "GPIO",
+        "port": 22,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "KEY_1": {
+        "type": "GPIO",
+        "port": 23,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "KEY_2": {
+        "type": "GPIO",
+        "port": 20,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "KEY_3": {
+        "type": "GPIO",
+        "port": 21,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "KEY_4": {
+        "type": "GPIO",
+        "port": 26,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "I2C1": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 60
+      },
+      "led_g": {
+        "type": "GPIO",
+        "port": 35,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "led_b": {
+        "type": "GPIO",
+        "port": 34,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "SPI0": {
+        "type": "SPI",
+        "port": 0,
+        "mode": "master",
+        "freq": 2000000
+      },
+      "oled_spi": {
+        "type": "SPI",
+        "port": 1,
+        "mode": "master",
+        "freq": 26000000
+      },
+      "oled_dc": {
+        "type": "GPIO",
+        "port": 28,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "oled_res": {
+        "type": "GPIO",
+        "port": 30,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "serial2": {
+        "type": "UART",
+        "port": 2,
+        "dataWidth": 8,
+        "baudRate": 115200,
+        "stopBits": 1,
+        "flowControl": "disable",
+        "parity": "none"
+      }
+    },
+    "debugLevel": "ERROR",
+    "repl": "disable"
+  }
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/code/hcho.py b/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/code/hcho.py
new file mode 100644
index 0000000000..95d52d9396
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/code/hcho.py
@@ -0,0 +1,36 @@
+from driver import ADC
+
+class HCHO(object):
+
+    def __init__(self, adcObj):
+        self.adcObj = None
+        if not isinstance(adcObj, ADC):
+            raise ValueError("parameter is not an ADC object")
+
+        self.adcObj = adcObj
+
+    def getPPM(self):
+        if self.adcObj is None:
+            raise ValueError("invalid ADC object")
+        min = 400
+        max = 0
+        value = 0
+        total = 0
+        i = 0
+        for i in range(32):
+            value = self.adcObj.readVoltage()
+            total += value
+            # print(value)
+            if (min >= value):
+                min = value
+            if (max <= value):
+                max = value
+        analogVoltage = (total - min - max) / 30
+        analogVoltage += 23
+        analogVoltage /= 1000.0
+        #linear relationship(0.4V for 0 ppm and 2V for 5ppm)
+        ppm = 3.125 * analogVoltage - 1.25
+        if ppm < 0 :
+           ppm = 0
+        return ppm
+
diff --git a/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/code/main.py b/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/code/main.py
new file mode 100644
index 0000000000..674b994b35
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/hcho_detector/haaseduk1/code/main.py
@@ -0,0 +1,129 @@
+# -*- encoding: utf-8 -*-
+
+from aliyunIoT import Device     # iot组件是连接阿里云物联网平台的组件
+import netmgr as nm              # Wi-Fi功能所在库
+import utime                     # 延时API所在组件
+import ujson                     # json字串解析库
+from driver import ADC           # ADC类，通过微处理器的ADC模块读取ADC通道输入电压
+import hcho                      # 甲醛hcho传感器类
+adcObj = 0                     # ADC通道对象
+uartObj = 0                    # UART通道对象
+
+
+# 物联网平台连接标志位
+iot_connected = False
+
+# Wi-Fi SSID和Password设置
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+
+# 三元组信息
+productKey = "产品密钥"  #需要填入物联网云平台申请到的productKey信息
+deviceName = "设备名称"  #需要填入物联网云平台申请到的deviceName信息
+deviceSecret = "设备密钥" #需要填入物联网云平台申请到的deviceSecret信息
+
+# 物联网设备实例
+device = None
+
+hchoDev = 0
+
+def hcho_init():
+    global adcObj,hchoDev
+
+    adcObj = ADC()
+    adcObj.open("hcho")
+    hchoDev = hcho.HCHO(adcObj)
+
+def get_hcho_value():
+    global hchoDev
+
+    return hchoDev.getPPM()
+
+# 等待Wi-Fi成功连接到路由器
+def get_wifi_status():
+   nm.init()
+   nm.disconnect()
+   wifi_connected = nm.getStatus()
+   print("start to connect " , wifiSsid)
+   nm.connect(wifiSsid, wifiPassword)       # 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
+
+   while True :
+      if wifi_connected == 5:               # nm.getStatus()返回5代表连线成功
+            break
+      else:
+            wifi_connected = nm.getStatus() # 获取Wi-Fi连接路由器的状态信息
+            utime.sleep(0.5)
+            print("wifi_connected: " , wifi_connected)
+
+   print("Wi-Fi connected")
+   print('DeviceIP:' + nm.getInfo()['ip'])  # 打印Wi-Fi的IP地址信息
+
+# 物联网平台连接成功的回调函数
+def on_connect(data):
+    global iot_connected
+    iot_connected = True
+
+# 设置props 事件接收函数（当云平台向设备下发属性时）
+def on_props(request):
+    pass
+
+# 连接物联网平台
+def connect_lk(productKey, deviceName, deviceSecret):
+    global device, iot_connected
+    key_info = {
+        'region': 'cn-shanghai',
+        'productKey': productKey,
+        'deviceName': deviceName,
+        'deviceSecret': deviceSecret,
+        'keepaliveSec': 60
+    }
+    # 将三元组信息设置到iot组件中
+    device = Device()
+
+    # 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
+    device.on(Device.ON_CONNECT, on_connect)
+
+    # 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
+    device.on(Device.ON_PROPS, on_props)
+
+    # 启动连接阿里云物联网平台过程
+    ret = device.connect(key_info)
+
+    # 等待设备成功连接到物联网平台
+    while(True):
+        if iot_connected:
+            print('物联网平台连接成功')
+            break
+        else:
+            print('sleep for 1 s')
+            utime.sleep(1)
+
+# 上传甲醛浓度信息到物联网平台
+def upload_hcho_detector_state():
+    global device
+    # 无限循环
+    while True:
+        data = get_hcho_value()
+        H_str = "Hcho : " + str(round(data,2))+'ppm'
+        print('Hcho :' + str(round(data,2)) +'ppm')
+
+        # "HCHO" - 代表甲醛传感器测量到的浓度值
+        upload_data = {'params': ujson.dumps({
+            'HCHO': round(data,2),
+        })}
+        # 上传甲醛浓度信息到物联网平台
+        device.postProps(upload_data)
+
+        # 每2秒钟上报一次
+        utime.sleep(2)
+
+if __name__ == '__main__':
+    # 运行此demo之前务必保证模块已经上电5分钟以上
+    hcho_init()
+
+    # 请替换物联网平台申请到的产品和设备信息,可以参考文章:https://blog.csdn.net/HaaSTech/article/details/114360517
+    # global productKey, deviceName, deviceSecret ,on_request, on_play
+    get_wifi_status()
+
+    connect_lk(productKey, deviceName, deviceSecret)
+    upload_hcho_detector_state()
diff --git a/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/README.md b/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/README.md
new file mode 100644
index 0000000000..3651f8a7b2
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/README.md
@@ -0,0 +1,296 @@
+# 起夜灯
+&emsp;&emsp;
+下图是本案例除硬件连线外的2步导学，每个步骤中实现的功能请参考图中的说明。
+<div align="center">
+<img src=./../../../images/2_起夜灯_步骤概述.jpg width=60%/>
+</div>
+
+## 1、简介
+
+### 1.1、背景
+&emsp;&emsp;
+**红外线**是一种人类肉眼看不到的光，虽然看不见，但他有一个显著的特性就是具有热效应，即所有高于绝对零度的物质都会产生红外线。人体热释电红外传感器就是一种能探测人体红外光谱变化的传感器，他能检测人发射的红外线，并转化为电信号输出。
+
+&emsp;&emsp;
+使用一个控制器来接收人体热释电红外传感器的信号，通过这个信号来控制灯的开启和关闭，就可以制作一个实用的起夜灯。
+
+<div align="center">
+<img src=./../../../images/2_起夜灯_起夜灯原理.png width=60%/>
+</div>
+
+<br>
+
+### 1.1、准备
+
+* [HaaS EDU K1开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C5AB3B8A4A88800000001&dataId=800C5AB3B8A4A888) 一套
+* [人体热释电红外传感器](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800CE1DD3CE998E000000002&dataId=800CE1DD3CE998E0) 一个
+* 连接线 若干
+
+&emsp;&emsp;
+硬件连线图如下图所示：
+<div align="center">
+<img src=./../../../images/2_2_HaaS_EDU_K1_起夜灯硬件接线图.png width=85%/>
+</div>
+<br>
+
+## 2、物联网平台开发
+
+&emsp;&emsp;
+对于第一次使用物联网平台的读者，需要开通实例以使用物联网平台的功能。这里可以使用免费的公共实例进行开发。
+
+&emsp;&emsp;
+在[物联网平台](https://iot.console.aliyun.com/lk/summary/new)中，左上角选择“华东2-上海”，点击“公共实例”，即可开通。
+
+<div align="center">
+<img src=./../../../images/5_3_开通公共实例.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+开通物联网平台功能之后，需要完成下面的3个步骤完成云端设备的创建：
+1. 创建云端产品
+2. 创建产品属性（物模型）
+3. 创建云端设备（获取三元组）
+
+<br>
+
+### 2.1、创建云端产品
+&emsp;&emsp;
+点击上图中的“公共实例”，即可进入[控制台](https://iot.console.aliyun.com/lk/summary/new)进行产品创建。然后，点击创建产品按钮，如下图所示。
+
+<div align="center">
+<img src=./../../../images/1_创建产品.png
+ width=60%/>
+</div>
+
+&emsp;&emsp;
+在新建产品设定页面按照下图所示，设定“产品名称”，选择所属的“自定义品类”（自定义品类的物模型为空，需要自己创建，也可以通过导入外部物模型的方式导入），节点类型选择“直连设备”，联网方式选择“Wi-Fi”，数据格式选择“ICA标准数据格式”，检验类型和认证方式选择默认设定即可。还可以根据开发者自己的需求在“产品描述”页面添加针对此产品的描述。
+<div align="center">
+<img src=./../../../images/2_2_新建起夜灯设备.png
+ width=60%/>
+</div>
+
+&emsp;&emsp;
+选择之后，点击“确认”按钮，即可完成产品创建。返回“产品”页面之后可以看到产品类表中会出现刚刚创建的“起夜灯”的产品，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_产品列表页.png width=60%/>
+</div>
+
+<br>
+
+### 2.2、创建产品属性（物模型）
+&emsp;&emsp;
+点击上图中的“查看”按钮，即可看到产品信息，Topic列表，功能定义，数据解析等跟产品相关功能的设定。点开“功能定义”标签页，可以看到设备物模型定义。
+
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_产品详情页面.png width=60%/>
+</div>
+
+&emsp;&emsp;
+其中标识符是设备端上报设备属性状态的消息中需要使用的标识符，并且只有在设备上报的属性内容符合“数据定义”中的数据取值范围的时候才会被物联网平台记录，否则会被物联网平台认定为非法属性而过滤掉。
+
+&emsp;&emsp;
+本节我们选择直接新建方式来创建此产品需要的物模型信息，点击上图中的”编辑草稿“按钮。然后如下图再点击“添加自定义功能”。
+
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_编辑草稿.png width=60%/>
+</div>
+
+&emsp;&emsp;
+如下图添加一个“LED开关”的默认功能。其中标识符为LEDSwith, 0表示LED灯关闭，1表示LED开启。
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_添加自定义功能.png width=60%/>
+</div>
+
+点击确定后回到前一个页面，再点击“发布上线”
+
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_发布物模型.png
+width=60%/>
+</div>
+&emsp;&emsp;
+产品及其物模型创建完成后就可以创建这个产品的设备了。
+
+<br>
+
+### 2.3、创建云端设备（获取三元组）
+&emsp;&emsp;
+在产品列表页面中，点击”起夜灯“后的“管理设备”，就会进到设备管理页面。
+
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_产品页_管理设备.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“设备”页面点击“添加设备”按钮，如下图所示。
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_添加设备入口.png width=80%/>
+</div>
+
+&emsp;&emsp;
+在“添加设备”页面中设定“deviceName”，这里开发者可以自己填入自己想设定的设备名称，也可以不填任何内容让系统自动生成设备名称，如下图所示。
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备添加完成后，点击“前往查看”按钮，就可以看到此设备端详细信息了。
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_完成添加设备.png width=40%/>
+</div>
+
+&emsp;&emsp;
+设备信息中有两个信息需要和设备端开发相匹配：
+1. 三元组
+2. 物模型属性信息
+
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_设备详情.png width=100%/>
+</div>
+
+<br>
+
+#### 2.3.1、**获取设备三元组**
+&emsp;&emsp;
+如上图所示，点击deviceSecret后面的“查看”按钮，就可以看到设备的三元组信息，三元组是物联网设备端和物联网云端设备相关联的唯一标识符，在设备端连接云端的时候会使用三元组信息和云端进行鉴权，鉴权通过之后云端会认为设备已激活并上线。
+
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_设备三元组.png width=50%/>
+</div>
+
+<br>
+
+#### 2.3.2、**查看设备属性信息**
+&emsp;&emsp;
+设备详情信息页中的“物模型数据”标签页中可以看到设备的所有属性信息、设备时间上报情况及设备服务调用情况，如下图所示。待物联网设备按照设备属性对应的标识符上报设备属性的时候，本图片中的“LED开关“，属性值就会显示设备最新的属性信息。
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_设备物模型数据.png width=80%/>
+</div>
+
+<br>
+
+> 创建产品和设备的过程是按照面向对象的思想进行设计的，其中创建产品可以看成是新建一个类，其中的物模型则是类的对象，创建设备则是进行类的实例化。
+<br>
+
+## 3、设备端开发
+
+### 3.1、开发环境
+&emsp;&emsp;
+在进行下一步之前请确保HaaS EDU K1开发环境已经搭建完毕。详情请参考[HaaS EDU K1快速开始](../../../startup/HaaS_EDU_K1_startup.md)的说明。
+<br>
+
+### 3.2、创建解决方案
+
+&emsp;&emsp;
+如下图所示，在Haas Studio中创建项目。先选择左侧的“开发板型号”再从右侧的案例中选择“起夜灯”案例点击“立即创建”即可。
+<div align="center">
+<img src=./../../../images/HaaS_Studio_创建工程示范.png width=100%/>
+</div>
+<br>
+
+> Python脚本的详细说明请参考脚本内嵌的文字注释
+
+
+1. **修改路由器名称及密码**
+
+&emsp;&emsp;
+修改main.py中wifiSsid和wifiPassword的值为读者实际要连接的路由器的名称及密码（请注意名称和密码都需要放在""符号中间）。
+
+```python
+# Wi-Fi SSID和Password设置
+wifiSsid = "请输入您的路由器名称"
+wifiPassword = "请输入您的路由器密码"
+```
+
+&emsp;&emsp;
+修改完成之后get_wifi_status函数中的nm.connect(wifiSsid, wifiPassword) 语句就会连接读者自己设定的路由器。
+
+2. **修改设备端三元组**
+
+&emsp;&emsp;
+修改main.py中productKey、deviceName和deviceSecret的值为读者创建的物联网设备的三元组信息。
+```python
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+```
+
+3. **修改设备端上报数据所用标识符**
+
+&emsp;&emsp;
+main.py中下面的代码实现的是上传起夜灯状态到云端的功能。其中LEDSwitch便是起夜灯状态上报云端所用的标识符。
+```python
+while True :
+    have_human = irDev.irDetect()   # 获取传感器的值
+    if (have_human == 1) :
+        print("human is here .....\r\n")
+    if (last_have_human != have_human) :
+        led_control(have_human)         # 控制LED亮灭
+
+        # 生成上报到物联网平台的属性值字串，此处的属性标识符"LEDSwith"必须和物联网平台的属性一致
+        # "LEDSwitch" - 表示起夜灯的状态
+        upload_data = {'params': ujson.dumps({
+            'LEDSwitch': have_human,
+        })
+        }
+        # 上传LED状态到物联网平台
+        device.postProps(upload_data)
+
+    last_have_human = have_human    # 记录当前状态
+    utime.sleep(1)                   # 休眠1秒
+```
+&emsp;&emsp;
+确保这起夜灯的标识符和物联网产品的物模型中属性标识符是一样的.
+
+<br>
+
+## 4、运行结果
+### 4.1、本地查看
+
+&emsp;&emsp;
+推送此脚本到HaaS EDU K1之后，串口会周期性的打印如下日志，其中：
+• “物联网平台连接成功” 代表成功连接到物联网平台
+• 人体感应传感器检测到有人体活动的时候变会打印“human is here”，同时HaaS EDU K1上面的红色LED会亮起。
+• 人体感应传感器没检测到人体活动的时候变会停止打印“human is here”，Haas EDU K1的红色LED灯也会随之熄灭。
+```log
+...
+             Welcome to AliOS Things           
+amp shakehand begin...
+dev /dev/wifi0 is already add
+ ==== python execute from /data/pyamp/main.py ====
+ Welcome to MicroPython 
+...
+Wi-Fi connected
+DeviceIP:192.168.0.107
+sleep for 1 s
+...
+success to establish tcp, fd=4
+物联网平台连接成功
+human is here ...
+
+human is here ...
+
+human is here ...
+...
+```
+
+<br>
+
+### 4.2、物联网平台端设备信息查看
+
+&emsp;&emsp;
+物联网设备的系统启动成功并连接到物联网平台之后，物联网平台上对应的设备状态会从”未激活状态“变为”上线“，在物模型数据标签页上会显示设备上报到物联网平台的属性值。
+
+<div align="center">
+<img src=./../../../images/2_2_起夜灯_设备状态及属性.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此时如果开发板周围有人经过，起夜灯就会开启，物联网平台的物模型数据会更新为设备上报的最新的属性值。
+
+<br>
+
+&emsp;&emsp;
+到此为止，起夜灯数据上云的案例就已经完成了。如果想要学习起夜灯案例更详细的操作步骤，请参考“[起夜灯系统详解](https://gitee.com/haasedu/haasedu/blob/release_2.0/2-%E6%99%BA%E8%83%BD%E7%94%9F%E6%B4%BB/%E5%9C%BA%E6%99%AF2-%E8%B5%B7%E5%A4%9C%E7%81%AF/README.md)”中的说明。
diff --git a/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/code/board.json b/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/code/board.json
new file mode 100644
index 0000000000..f5fce465a4
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/code/board.json
@@ -0,0 +1,201 @@
+{
+  "name": "haasedu",
+  "version": "1.0.0",
+  "io": {
+    "ir": {
+      "type": "GPIO",
+      "port": 7,
+      "dir": "input",
+      "pull": "pullup"
+    },
+    "led": {
+      "type": "GPIO",
+      "port": 36,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "led_r": {
+      "type": "GPIO",
+      "port": 36,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "ap3216c": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 30
+    },
+    "mpu6050": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 105
+    },
+    "si7006": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 400000,
+      "mode": "master",
+      "devAddr": 64
+    },
+    "spl06": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 400000,
+      "mode": "master",
+      "devAddr": 119
+    },
+    "qmc5883": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 400000,
+      "mode": "master",
+      "devAddr": 13
+    },
+    "ADC2": {
+      "type": "ADC",
+      "port": 0,
+      "sampling": 12000000
+    },
+    "GPIO2": {
+      "type": "GPIO",
+      "port": 2,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "GPIO3": {
+      "type": "GPIO",
+      "port": 3,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO4": {
+      "type": "GPIO",
+      "port": 4,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO5": {
+      "type": "GPIO",
+      "port": 5,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO6": {
+      "type": "GPIO",
+      "port": 6,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO7": {
+      "type": "GPIO",
+      "port": 7,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO19": {
+      "type": "GPIO",
+      "port": 19,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO22": {
+      "type": "GPIO",
+      "port": 22,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "KEY_1": {
+      "type": "GPIO",
+      "port": 23,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "KEY_2": {
+      "type": "GPIO",
+      "port": 20,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "KEY_3": {
+      "type": "GPIO",
+      "port": 21,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "KEY_4": {
+      "type": "GPIO",
+      "port": 26,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "I2C1": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 60
+    },
+    "led_g": {
+      "type": "GPIO",
+      "port": 35,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "led_b": {
+      "type": "GPIO",
+      "port": 34,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "SPI0": {
+      "type": "SPI",
+      "port": 0,
+      "mode": "master",
+      "freq": 2000000
+    },
+    "oled_spi": {
+      "type": "SPI",
+      "port": 1,
+      "mode": "master",
+      "freq": 26000000
+    },
+    "oled_dc": {
+      "type": "GPIO",
+      "port": 28,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "oled_res": {
+      "type": "GPIO",
+      "port": 30,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "serial2": {
+      "type": "UART",
+      "port": 2,
+      "dataWidth": 8,
+      "baudRate": 115200,
+      "stopBits": 1,
+      "flowControl": "disable",
+      "parity": "none"
+    }
+  },
+  "debugLevel": "ERROR",
+  "repl": "disable"
+}
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/code/ir.py b/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/code/ir.py
new file mode 100644
index 0000000000..ad5c88ef2d
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/code/ir.py
@@ -0,0 +1,17 @@
+from driver import GPIO
+
+class IR(object):
+
+    def __init__(self, gpioObj):
+        self.gpioObj = None
+        if not isinstance(gpioObj, GPIO):
+            raise ValueError("parameter is not a GPIO object")
+
+        self.gpioObj = gpioObj
+
+    def irDetect(self):
+        if self.gpioObj is None:
+            raise ValueError("invalid GPIO object")
+
+        value = self.gpioObj.read()
+        return value
diff --git a/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/code/main.py b/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/code/main.py
new file mode 100644
index 0000000000..2fb15fe598
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/human_detector/haaseduk1/code/main.py
@@ -0,0 +1,142 @@
+# -*- coding: UTF-8 -*-
+
+from aliyunIoT import Device     # aliyunIoT组件是连接阿里云物联网平台的组件
+import netmgr as nm              # Wi-Fi功能所在库
+import ujson                     # json字串解析库
+import utime                     # 延时API所在组件
+from driver import GPIO          # GPIO类，用于控制微处理器的输入输出功能
+import ir                        # ir人体红外传感器类
+
+gpioirDev = 0
+gpioledDev = 0
+irDev = 0
+
+# 物联网平台连接标志位
+iot_connected = False
+wlan = None
+
+# Wi-Fi SSID和Password设置
+wifiSsid = "请输入您的路由器名称"
+wifiPassword = "请输入您的路由器密码"
+
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+
+# 物联网设备实例
+device = None
+
+# 等待Wi-Fi成功连接到路由器
+def get_wifi_status():
+    nm.init()
+    nm.disconnect()
+
+    wifi_connected = nm.getStatus()
+    print("start to connect " + wifiSsid)
+    nm.connect(wifiSsid, wifiPassword)       # 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
+
+    while True :
+        if wifi_connected == 5:               # nm.getStatus()返回5代表连线成功
+            break
+        else:
+            wifi_connected = nm.getStatus() # 获取Wi-Fi连接路由器的状态信息
+            utime.sleep(0.5)
+            print("wifi_connected: " + str(wifi_connected))
+
+    print("Wi-Fi connected")
+    print('DeviceIP:' + nm.getInfo()['ip'])  # 打印Wi-Fi的IP地址信息
+
+# 物联网平台连接成功的回调函数
+def on_connect(data):
+    global iot_connected
+    iot_connected = True
+
+# 设置props 事件接收函数（当云平台向设备下发属性时）
+def on_props(request):
+    pass
+
+def connect_lk(productKey, deviceName, deviceSecret):
+    global device, iot_connected
+    key_info = {
+        'region': 'cn-shanghai',
+        'productKey': productKey,
+        'deviceName': deviceName,
+        'deviceSecret': deviceSecret,
+        'keepaliveSec': 60
+    }
+    # 将三元组信息设置到iot组件中
+    device = Device()
+
+    # 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
+    device.on(Device.ON_CONNECT, on_connect)
+
+    # 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
+    device.on(Device.ON_PROPS, on_props)
+
+    # 启动连接阿里云物联网平台过程
+    device.connect(key_info)
+
+    # 等待设备成功连接到物联网平台
+    while(True):
+        if iot_connected:
+            print('物联网平台连接成功')
+            break
+        else:
+            print('sleep for 1 s')
+            utime.sleep(1)
+    print('sleep for 2s')
+    utime.sleep(2)
+
+def human_check_init():
+    global gpioirDev,gpioledDev,irDev
+
+    gpioirDev = GPIO()
+    gpioirDev.open("ir")
+    irDev = ir.IR(gpioirDev)
+
+    gpioledDev = GPIO()
+    gpioledDev.open("led")
+
+def led_control(on):
+    global gpioledDev
+    if on == 0:
+        gpioledDev.write(0)        # GPIO写入0，灭灯
+    else:
+        gpioledDev.write(1)        # GPIO写入1，亮灯
+
+def human_detector() :
+    global gpioirDev,gpioledDev,irDev
+
+    last_have_human = 0                 # 记录初始值
+    while True :
+        have_human = irDev.irDetect()   # 获取传感器的值
+        if (have_human == 1) :
+            print("human is here ...\r\n")
+        if (last_have_human != have_human) :
+            led_control(have_human)         # 控制LED亮灭
+
+            # 生成上报到物联网平台的属性值字串，此处的属性标识符"LEDSwith"必须和物联网平台的属性一致
+            # "LEDSwitch" - 表示起夜灯的状态
+            upload_data = {'params': ujson.dumps({
+                'LEDSwitch': have_human,
+            })
+            }
+            # 上传LED状态到物联网平台
+            device.postProps(upload_data)
+
+        last_have_human = have_human    # 记录当前状态
+        utime.sleep(1)                  # 休眠1秒
+
+    gpioirDev.close()
+    gpioledDev.close()
+
+if __name__ == '__main__' :
+
+    # 请替换物联网平台申请到的产品和设备信息,可以参考文章:https://blog.csdn.net/HaaSTech/article/details/114360517
+    # global productKey, deviceName, deviceSecret ,on_request, on_play
+    get_wifi_status()
+
+    connect_lk(productKey, deviceName, deviceSecret)
+    human_check_init()
+    human_detector()
diff --git a/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/README.md b/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/README.md
new file mode 100644
index 0000000000..cf856533ad
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/README.md
@@ -0,0 +1,306 @@
+# 智慧路灯系统
+&emsp;&emsp;
+下图是本案例除硬件连线外的2步导学，每个步骤中实现的功能请参考图中的说明。在硬件连线完成之后我们建议您先使用“一分钟上云体验”功能预先体验本案例的实际运行效果。
+<div align="center">
+<img src=./../../../images/4_智慧路灯_步骤概述.jpg width=60%/>
+</div>
+
+## 1、简介
+&emsp;&emsp;
+随着城市化不断扩大，城市的灯光秀越来越多，让我们居住的城市生活变得五彩缤纷，灯火辉煌，让城市显得越来越繁华。但是，我们也会经常发现有些路边的灯，在天很黑了不会自动打开，或者到清晨，天很亮了，马路边的灯也不会自动熄灭，只会在固定时间统一开关控制，这样既不人性化也不环保。于是现在很多地方的路灯会根据周围环境亮度自动开启或关闭路边灯光，那这样的路灯就非常人性化，同时也非常环保，这才是真正的城市智慧路灯。
+
+### 1.1、背景知识
+&emsp;&emsp;
+本章课程打造的智慧路灯控制系统是当检测到周围环境亮度变暗的时候，系统会自动打开灯，当周围环境亮度变亮的时候，系统就会自动关闭灯。本智慧路灯控制系统默认设置一个亮度阈值，当亮度值超过阈值，关灯，当亮度值低于阈值，开灯，当然，这个阈值可以根据每个人对光的亮度感觉不同而调整。
+
+### 1.2、准备
+&emsp;&emsp;
+本案例之需要HaaS EDU K1开发一套。实验过程中会使用HaaS EDU K1内置的AP3216C传感器和红色LED。
+
+## 2、物联网平台开发
+### 2.1、开通公共实例
+&emsp;&emsp;
+对于第一次使用物联网平台的读者，需要开通实例以使用物联网平台的功能。这里可以使用免费的公共实例进行开发。
+
+&emsp;&emsp;
+在[物联网平台](https://iot.console.aliyun.com/lk/summary/new)中，左上角选择“华东2-上海”，点击“公共实例”，即可开通。
+
+<div align="center">
+<img src=./../../../images/5_3_开通公共实例.png
+ width=100%/>
+</div>
+
+### 2.2、云端创建产品
+1. **创建产品**
+
+&emsp;&emsp;
+点击上图中的“公共实例”，即可进入[控制台](https://iot.console.aliyun.com/lk/summary/new)进行产品创建。然后，点击创建产品按钮，如下图所示。
+
+<div align="center">
+<img src=./../../../images/2_3_创建产品.jpg
+ width=40%/>
+</div>
+
+&emsp;&emsp;
+这里创建了一个名称为“智慧路灯”的产品。
+<div align="center">
+<img src=./../../../images/5_1_新建智慧路灯产品.jpg
+ width=40%/>
+</div>
+
+&emsp;&emsp;
+点击确认，就可以在产品列表中出现智慧路灯。
+
+<div align="center">
+<img src=./../../../images/5_1_完成产品创建.jpg
+ width=40%/>
+</div>
+
+&emsp;&emsp;
+查看产品详情。
+<div align="center">
+<img src=./../../../images/5_1_产品功能定义.jpg
+ width=40%/>
+</div>
+
+&emsp;&emsp;
+编辑草稿，选择自定义功能。
+<div align="center">
+<img src=./../../../images/5_1_自定义产品物模型定义.jpg
+ width=40%/>
+</div>
+
+&emsp;&emsp;
+如下图设置对应产品的物模型，分别设置光强度电压值和灯开关两个模型。
+<div align="center">
+<img src=./../../../images/5_1_2产品物模型.jpg
+ width=40%/>
+ <img src=./../../../images/5_1_3产品物模型onoff.jpg
+ width=40%/>
+</div>
+
+&emsp;&emsp;
+在产品详情中增加产品的功能，可以看到刚才设置的光强度电压值和灯开关两个功能属性，点击发布上线。
+<div align="center">
+<img src=./../../../images/5_1_3完成物模型设置.jpg
+ width=80%/>
+</div>
+
+&emsp;&emsp;
+这样，整个智慧路灯产品在物联网平台也创建好了。
+
+2. **设备管理**
+
+&emsp;&emsp;
+选中最左边栏设备管理中的设备，然后添加设备，
+<div align="center">
+<img src=./../../../images/2_3_添加设备.jpg
+ width=40%/>
+</div>
+
+&emsp;&emsp;
+选择的产品为刚刚创建的智慧路灯，设备名设置为smartlight,点击确认，
+<div align="center">
+<img src=./../../../images/5_1_智慧路灯设备.jpg
+ width=40%/>
+</div>
+
+&emsp;&emsp;
+进入设备详情，获取设备三元组信息，
+<div align="center">
+<img src=./../../../images/5_1_设备三元组信息.jpg
+ width=40%/>
+</div>
+
+&emsp;&emsp;
+将设备三元组信息一键拷贝出来，在设备开发中会用到。
+<div align="center">
+<img src=./../../../images/2_3_设备证书.jpg
+ width=40%/>
+</div>
+
+3. **设备引擎**
+
+&emsp;&emsp;
+如何通过光感自适应控制灯的亮灭呢？可以在物联网平台上通过引擎规则实现，本课程使用的光强度传感器AP3216C返回值越低，说明周围的环境光强度越低；反之，返回值越高，说明周围的环境光强度越高。
+<div align="center">
+<img src=./../../../images/5_1_haaseduk1_规则引擎1.jpg
+ width=70%/>
+</div>
+
+&emsp;&emsp;
+当光强度大于100，说明周围的环境变亮，执行关灯的指令。<br />
+
+<div align="center">
+<img src=./../../../images/5_1_haaseduk1_规则引擎2.jpg
+ width=70%/>
+</div>
+
+&emsp;&emsp;
+当光强度电压值小于100，说明周围的环境变暗，执行开灯的指令。<br />
+<div align="center">
+<img src=./../../../images/5_1_haaseduk1_规则引擎3.jpg
+ width=70%/>
+</div>
+
+&emsp;&emsp;
+规则引擎创建完成以后，启动引擎即可。<br />
+<div align="center">
+<img src=./../../../images/5_1_haaseduk1_规则引擎4.jpg
+ width=70%/>
+</div>
+
+## 3、设备端开发
+### 3.1、开发环境
+
+&emsp;&emsp;
+在进行下一步之前请确保HaaS EDU K1开发环境已经搭建完毕。详情请参考“[HaaS EDU K1快速开始](https://hli.aliyuncs.com/haas-static/haasapi/index.html#/Python/docs/zh-CN/startup/HaaS_EDU_K1_startup)”的说明。
+
+### 3.2、创建解决方案
+&emsp;&emsp;
+如下图所示，在Haas Studio中创建项目。先选择左侧的“开发板型号”再从右侧的案例中选择“智能路灯系统”案例点击“立即创建”即可。
+
+<div align="center">
+<img src=./../../../images/HaaS_Studio_创建工程示范.png width=100%/>
+</div>
+<br>
+
+> Python脚本的详细说明请参考脚本内嵌的文字注释
+
+&emsp;&emsp;
+之后对代码进行如下修改。
+
+1. **修改路由器名称及密码**
+
+&emsp;&emsp;
+修改main.py中wifiSsid和wifiPassword的值为读者实际要连接的路由器的名称及密码（请注意名称和密码都需要放在""符号中间）。
+
+```python
+# wifi连接的的wifiSsid和wifiPassword定义
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+```
+
+&emsp;&emsp;
+修改完成之后get_wifi_status函数中的nm.connect(wifiSsid, wifiPassword) 语句就会连接读者自己设定的路由器。
+
+1. **修改设备端三元组**
+
+&emsp;&emsp;
+修改main.py中productKey、deviceName和deviceSecret的值为上面物联网平台创建的物联网设备的三元组信息。
+
+```python
+# 物联网平台相关的key和serect定义
+productKey     = "产品密钥"
+deviceName     = "设备名"
+deviceSecret   = "设备密钥"
+```
+
+3. **修改设备端上报光强度和下发开关标识符**
+
+&emsp;&emsp;
+main.py中下面的代码实现的是上传光强度值到云端的功能，以及云端下发对应的开关命令。其中Brightness便是光强度值上报时所用的标识符，onoff为云端下发的开关标识符。
+
+```python
+def report_light_data(l_data):
+    # 生成上报到物联网平台的属性值字串
+    prop = ujson.dumps({
+        'Brightness': l_data,
+    })
+    upload_data = {'params': prop}
+    # 上传光强度信息到物联网平台
+    device.postProps(upload_data)
+```
+&emsp;&emsp;
+下面是采集光照数据的时候，采样值是跨阈值100就需要进行上报。
+```python
+# 采集打印光照强度电压值
+def show_lightness():
+    global lightness,i_light,last_light,system_reset
+    i_light = int(lightness)
+    if system_reset == 1:
+        print("system first come")
+        system_reset = 0    # 系统第一次启动
+        report_light_data(i_light)
+    elif (i_light >= 1000 and last_light < 1000) or (i_light < 1000 and last_light >= 1000):
+        report_light_data(i_light)
+        print("light has change")
+    else:
+        print('no need report')
+    if i_light < 10:
+        T_str = "亮度:" + str(round(i_light, 1))
+    elif i_light >= 10 and i_light < 100:
+        T_str = "亮度:" + str(round(i_light, 2))
+    elif i_light >= 100 and i_light < 1000:
+        T_str = "亮度:" + str(round(i_light, 3))
+    elif i_light >= 1000 and i_light < 10000:
+        T_str = "亮度:" + str(round(i_light, 4))
+    print(T_str)
+    last_light = i_light
+```
+&emsp;&emsp;
+处理物联网平台过来的数据。
+```python
+# 设置props 事件接收函数（当云平台向设备下发属性时）
+def on_props(request):
+    global alarm_on, device
+    print(request)
+    payload = ujson.loads(request['params'])
+    # 获取dict状态字段 注意要验证键存在 否则会抛出异常
+    if "onoff" in payload.keys():
+        alarm_on = payload["onoff"]
+        if (alarm_on):
+            print("开灯")
+            ledOn()
+        else:
+            print("关灯")
+            ledOff()
+    # 要将更改后的状态同步上报到云平台
+    upload_data = {'params': ujson.dumps({
+        'onoff': alarm_on,
+    })
+    }
+    # 上报本地报警灯状态到云端
+    device.postProps(upload_data)
+```
+&emsp;&emsp;
+确保Brightness和onoff两个标识符和物联网产品的物模型中属性标识符是一样的，如下图所示：
+<div align="center">
+<img src=./../../../images/5_1_完成物模型设置.jpg
+ width=40%/>
+</div>
+
+
+## 4、运行结果
+
+&emsp;&emsp;
+推送此脚本到HaaS EDU K1之后，设备上打印光强度值，同时将相关的光强度值上传到云端，并且当光强度大于100，打开HaaS EDU K1开发板上的LED灯；当光强度小于100，关闭HaaS EDU K1开发板上的LED灯，如下日志所示：
+```bash
+...
+物联网平台连接成功
+...
+ap3216c init finished
+system first come
+...
+uploading data to the cloud: {'params': '{"Brightness": 304}'}
+亮度:304
+led off
+uploading data to the cloud: {'params': '{"Brightness": 0}'}
+light has change
+亮度:0
+led on
+no need report
+亮度:53
+uploading data to the cloud: {'params': '{"Brightness": 302}'}
+light has change
+亮度:302
+led off
+uploading data to the cloud: {'params': '{"Brightness": 5}'}
+light has change
+亮度:5
+led on
+...
+```
+
+&emsp;&emsp;
+到此为止，智慧路灯系统案例就已经完成了。如果想要学习智慧路灯实验更详细的操作步骤，请参考“[智慧路灯系统详解](https://gitee.com/haasedu/haasedu/blob/release_2.0/5-%E6%99%BA%E6%85%A7%E5%9F%8E%E5%B8%82/%E5%9C%BA%E6%99%AF1-%E6%99%BA%E6%85%A7%E8%B7%AF%E7%81%AF/README.md)”中的说明。
diff --git a/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/ap3216c.py b/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/ap3216c.py
new file mode 100644
index 0000000000..4295498491
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/ap3216c.py
@@ -0,0 +1,360 @@
+"""
+Copyright (C) 2015-2020 Alibaba Group Holding Limited
+
+The driver for AP3216C chip, The AP3216C is an integrated ALS & PS module
+that includes a digital ambient light sensor [ALS], a proximity sensor [PS],
+and an IR LED in a single package.
+"""
+from micropython import const
+from driver import I2C
+from utime import sleep_ms
+
+# System Register
+AP3216C_SYS_CONFIGURATION_REG    = const(0x00)
+AP3216C_SYS_INT_STATUS_REG       = const(0x01)
+AP3216C_SYS_INT_CLEAR_MANNER_REG = const(0x02)
+AP3216C_IR_DATA_L_REG            = const(0x0A)
+AP3216C_IR_DATA_H_REG            = const(0x0B)
+AP3216C_ALS_DATA_L_REG           = const(0x0C)
+AP3216C_ALS_DATA_H_REG           = const(0x0D)
+AP3216C_PS_DATA_L_REG            = const(0x0E)
+AP3216C_PS_DATA_H_REG            = const(0x0F)
+
+# ALS Register
+AP3216C_ALS_CONFIGURATION_REG    = const(0x10)
+AP3216C_ALS_CALIBRATION_REG      = const(0x19)
+AP3216C_ALS_THRESHOLD_LOW_L_REG  = const(0x1A)
+AP3216C_ALS_THRESHOLD_LOW_H_REG  = const(0x1B)
+AP3216C_ALS_THRESHOLD_HIGH_L_REG = const(0x1C)
+AP3216C_ALS_THRESHOLD_HIGH_H_REG = const(0x1D)
+
+# PS Register
+AP3216C_PS_CONFIGURATION_REG    = const(0x20)
+AP3216C_PS_LED_DRIVER_REG       = const(0x21)
+AP3216C_PS_INT_FORM_REG         = const(0x22)
+AP3216C_PS_MEAN_TIME_REG        = const(0x23)
+AP3216C_PS_LED_WAITING_TIME_REG = const(0x24)
+AP3216C_PS_CALIBRATION_L_REG    = const(0x28)
+AP3216C_PS_CALIBRATION_H_REG    = const(0x29)
+AP3216C_PS_THRESHOLD_LOW_L_REG  = const(0x2A)
+AP3216C_PS_THRESHOLD_LOW_H_REG  = const(0x2B)
+AP3216C_PS_THRESHOLD_HIGH_L_REG = const(0x2C)
+AP3216C_PS_THRESHOLD_HIGH_H_REG = const(0x2D)
+
+#mode value
+AP3216C_MODE_POWER_DOWN    = const(0x0)
+AP3216C_MODE_ALS           = const(0x1)
+AP3216C_MODE_PS            = const(0x2)
+AP3216C_MODE_ALS_AND_PS    = const(0x3)
+AP3216C_MODE_SW_RESET      = const(0x4)
+AP3216C_MODE_ALS_ONCE      = const(0x5)
+AP3216C_MODE_PS_ONCE       = const(0x6)
+AP3216C_MODE_ALS_AND_PS_ONCE  = const(0x7)
+
+#ap3216c_int_clear_manner
+AP3216C_INT_CLEAR_MANNER_BY_READING    = const(0x0)
+AP3216C_ALS_CLEAR_MANNER_BY_SOFTWARE   = const(0x1)
+
+#als_range
+AP3216C_ALS_RANGE_20661    = const(0x0)
+AP3216C_ALS_RANGE_5162     = const(0x1)
+AP3216C_ALS_RANGE_1291     = const(0x2)
+AP3216C_ALS_RANGE_323    = const(0x3)
+
+#als_range
+AP3216C_PS_GAIN1    = const(0x0)
+AP3216C_PS_GAIN2     = const(0x1)
+AP3216C_PS_GAIN4     = const(0x2)
+AP3216C_PS_GAIN8    = const(0x3)
+
+AP3216C_SYSTEM_MODE          = const(0x0)
+AP3216C_INT_PARAM            = const(0x1)
+AP3216C_ALS_RANGE            = const(0x2)
+AP3216C_ALS_PERSIST          = const(0x3)
+AP3216C_ALS_CALIBRATION      = const(0x4)
+AP3216C_ALS_LOW_THRESHOLD_L  = const(0x5)
+AP3216C_ALS_LOW_THRESHOLD_H  = const(0x6)
+AP3216C_ALS_HIGH_THRESHOLD_L = const(0x7)
+AP3216C_ALS_HIGH_THRESHOLD_H = const(0x8)
+AP3216C_PS_INTEGRATED_TIME   = const(0x9)
+AP3216C_PS_GAIN              = const(0xa)
+AP3216C_PS_PERSIST           = const(0xb)
+AP3216C_PS_LED_CONTROL       = const(0xc)
+AP3216C_PS_LED_DRIVER_RATIO  = const(0xd)
+AP3216C_PS_INT_MODE          = const(0xe)
+AP3216C_PS_MEAN_TIME         = const(0xf)
+AP3216C_PS_WAITING_TIME      = const(0x10)
+AP3216C_PS_CALIBRATION_L     = const(0x11)
+AP3216C_PS_CALIBRATION_H     = const(0x12)
+AP3216C_PS_LOW_THRESHOLD_L   = const(0x13)
+AP3216C_PS_LOW_THRESHOLD_H   = const(0x14)
+AP3216C_PS_HIGH_THRESHOLD_L  = const(0x15)
+AP3216C_PS_HIGH_THRESHOLD_H  = const(0x16)
+
+class AP3216C(object):
+    """
+    This class implements ap3216c chip's defs.
+    """
+    def __init__(self, i2cDev):
+        self._i2cDev = None
+        if not isinstance(i2cDev, I2C):
+            raise ValueError("parameter is not an I2C object")
+        # make AP3216C's internal object points to i2cDev
+        self._i2cDev = i2cDev
+        self.init()
+
+# 写寄存器的值
+    def write_reg(self, addr, data):
+        msgbuf = bytearray([data])
+        self._i2cDev.memWrite(msgbuf, addr, 8)
+        # print("--> write addr " + str(addr) + ", value = " + str(msgbuf))
+
+# 读寄存器的值
+    def read_regs(self, addr, len):
+        buf = bytearray(len)
+        self._i2cDev.memRead(buf, addr, 8)
+        # print("--> read " + str(len) + " bytes from addr " + str(addr) + ", " + str(len) + " bytes value = " + str(buf))
+        return buf
+
+    # 软件复位传感器
+    def reset_sensor(self):
+        self.write_reg(AP3216C_SYS_CONFIGURATION_REG, AP3216C_MODE_SW_RESET); # reset
+
+    def read_low_and_high(self, reg, len):
+        data = self.read_regs(reg, len)[0] | (self.read_regs(reg + 1, len)[0] << len * 8) # 读低字节 - 读高字节 - 合并数据
+
+        if (data > (1 << 15)):
+            data = data - (1<<16)
+
+        return data
+
+    def ap3216c_get_IntStatus(self):
+        # 读中断状态寄存器
+        IntStatus = self.read_regs(AP3216C_SYS_INT_STATUS_REG, 1)[0]
+        # IntStatus 第 0 位表示 ALS 中断，第 1 位表示 PS 中断。
+        return IntStatus # 返回状态
+
+    def ap3216c_int_init(self):
+        #print("ap3216c_int_init")
+        pass
+
+    #配置 中断输入引脚
+    def ap3216c_int_Config(self):
+        #print("ap3216c_int_Config")
+        pass
+
+    #初始化入口
+    def init(self):
+        # reset ap3216c
+        self.reset_sensor()
+        sleep_ms(100)
+        self.ap3216c_set_param(AP3216C_SYSTEM_MODE, AP3216C_MODE_ALS_AND_PS)
+        sleep_ms(150) # delay at least 112.5ms
+
+        self.ap3216c_int_Config()
+        self.ap3216c_int_init()
+
+
+    # This function reads light by ap3216c sensor measurement
+    # @param no
+    # @return the ambient light converted to float data.
+    #
+    def ap3216c_read_ambient_light(self):
+        read_data = self.read_low_and_high(AP3216C_ALS_DATA_L_REG, 1)
+        range = self.ap3216c_get_param(AP3216C_ALS_RANGE)
+        #print("ap3216c_read_ambient_light read_data is " , read_data, range)
+        if (range == AP3216C_ALS_RANGE_20661):
+            brightness = 0.35 * read_data # sensor ambient light converse to reality
+        elif (range == AP3216C_ALS_RANGE_5162):
+            brightness = 0.0788 * read_data # sensor ambient light converse to reality
+        elif (range == AP3216C_ALS_RANGE_1291):
+            brightness = 0.0197 * read_data # sensor ambient light converse to reality
+        elif (range == AP3216C_ALS_RANGE_323):
+            brightness = 0.0049 * read_data # sensor ambient light converse to reality
+
+        return brightness
+
+    #This function reads proximity by ap3216c sensor measurement
+    #@param no
+    #@return the proximity data.
+    def ap3216c_read_ps_data(self):
+        read_data = self.read_low_and_high(AP3216C_PS_DATA_L_REG, 1) # read two data
+        #print("ap3216c_read_ps_data read_data is " , read_data);
+        if (1 == ((read_data >> 6) & 0x01 or (read_data >> 14) & 0x01)) :
+            return 55555 # 红外过高（IR），PS无效 返回一个 55555 的无效数据
+
+        proximity = (read_data & 0x000f) + (((read_data >> 8) & 0x3f) << 4)
+        # sensor proximity converse to reality
+        if (proximity > (1 << 15)) :
+            proximity = proximity - (1<<16)
+
+        proximity |= read_data & 0x8000 # 取最高位，0 表示物体远离，1 表示物体靠近
+        return proximity # proximity 后十位是数据位，最高位为状态位
+
+
+    #This function reads ir by ap3216c sensor measurement
+    #@param no
+    #@return the ir data.
+    def ap3216c_read_ir_data(self):
+        read_data = self.read_low_and_high(AP3216C_IR_DATA_L_REG, 1) # read two data
+        #print("ap3216c_read_ir_data read_data is" , read_data);
+        proximity = (read_data & 0x0003) + ((read_data >> 8) & 0xFF)
+        # sensor proximity converse to reality
+        if (proximity > (1 << 15)) :
+            proximity = proximity - (1<<16)
+
+        return proximity
+
+    #This function sets parameter of ap3216c sensor
+    #@param cmd the parameter cmd of device
+    #@param value for setting value in cmd register
+    #@return the setting parameter status,RT_EOK reprensents setting successfully.
+
+    def ap3216c_set_param(self, cmd, value):
+        if cmd == AP3216C_SYSTEM_MODE:
+            # default 000,power down
+            self.write_reg(AP3216C_SYS_CONFIGURATION_REG, value)
+        elif cmd == AP3216C_INT_PARAM:
+            self.write_reg(AP3216C_SYS_INT_CLEAR_MANNER_REG, value)
+        elif cmd == AP3216C_ALS_RANGE:
+            args = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
+            args &= 0xcf
+            args |= value << 4
+            self.write_reg(AP3216C_ALS_CONFIGURATION_REG, args)
+        elif cmd == AP3216C_ALS_PERSIST:
+            args = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
+            args &= 0xf0
+            args |= value
+            self.write_reg(AP3216C_ALS_CONFIGURATION_REG, args)
+        elif cmd == AP3216C_ALS_LOW_THRESHOLD_L:
+            self.write_reg(AP3216C_ALS_THRESHOLD_LOW_L_REG, value)
+        elif cmd == AP3216C_ALS_LOW_THRESHOLD_H:
+           self.write_reg(AP3216C_ALS_THRESHOLD_LOW_H_REG, value)
+        elif cmd == AP3216C_ALS_HIGH_THRESHOLD_L:
+            self.write_reg(AP3216C_ALS_THRESHOLD_HIGH_L_REG, value)
+        elif cmd == AP3216C_ALS_HIGH_THRESHOLD_H:
+            self.write_reg(AP3216C_ALS_THRESHOLD_HIGH_H_REG, value)
+        elif cmd == AP3216C_PS_GAIN:
+            args = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
+            args &= 0xf3
+            args |= value
+            self.write_reg(AP3216C_PS_CONFIGURATION_REG, args)
+        elif cmd == AP3216C_PS_PERSIST:
+            args = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
+            args &= 0xfc
+            args |= value
+            self.write_reg(AP3216C_PS_CONFIGURATION_REG, args)
+        elif cmd == AP3216C_PS_LOW_THRESHOLD_L:
+            self.write_reg(AP3216C_PS_THRESHOLD_LOW_L_REG, value)
+        elif cmd == AP3216C_PS_LOW_THRESHOLD_H:
+            self.write_reg(AP3216C_PS_THRESHOLD_LOW_H_REG, value)
+        elif cmd == AP3216C_PS_HIGH_THRESHOLD_L:
+            self.write_reg(AP3216C_PS_THRESHOLD_HIGH_L_REG, value)
+        elif cmd == AP3216C_PS_HIGH_THRESHOLD_H:
+            self.write_reg(AP3216C_PS_THRESHOLD_HIGH_H_REG, value)
+
+    #This function gets parameter of ap3216c sensor
+    #@param cmd the parameter cmd of device
+    #@param value to get value in cmd register
+    #@return the getting parameter status,RT_EOK reprensents getting successfully.
+    def ap3216c_get_param(self, cmd):
+        if cmd == AP3216C_SYSTEM_MODE:
+            value = self.read_regs(AP3216C_SYS_CONFIGURATION_REG, 1)[0]
+        elif cmd == AP3216C_INT_PARAM:
+            value = self.read_regs(AP3216C_SYS_INT_CLEAR_MANNER_REG, 1)[0]
+        elif cmd == AP3216C_ALS_RANGE:
+            value = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
+            temp = (value & 0xff) >> 4
+            value = temp
+        elif cmd == AP3216C_ALS_PERSIST:
+            temp = self.read_regs(AP3216C_ALS_CONFIGURATION_REG, 1)[0]
+            temp = value & 0x0f
+            value = temp
+        elif cmd == AP3216C_ALS_LOW_THRESHOLD_L:
+            value = self.read_regs(AP3216C_ALS_THRESHOLD_LOW_L_REG, 1)[0]
+        elif cmd == AP3216C_ALS_LOW_THRESHOLD_H:
+            value = self.read_regs(AP3216C_ALS_THRESHOLD_LOW_H_REG, 1)[0]
+        elif cmd == AP3216C_ALS_HIGH_THRESHOLD_L:
+            value = self.read_regs(AP3216C_ALS_THRESHOLD_HIGH_L_REG, 1)[0]
+        elif cmd == AP3216C_ALS_HIGH_THRESHOLD_H:
+            value = self.read_regs(AP3216C_ALS_THRESHOLD_HIGH_H_REG, 1)[0]
+        elif cmd == AP3216C_PS_GAIN:
+            temp = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
+            value = (temp & 0xc) >> 2
+        elif cmd == AP3216C_PS_PERSIST:
+            temp = self.read_regs(AP3216C_PS_CONFIGURATION_REG, 1)[0]
+            value = temp & 0x3
+        elif cmd == AP3216C_PS_LOW_THRESHOLD_L:
+            value = self.read_regs(AP3216C_PS_THRESHOLD_LOW_L_REG, 1)[0]
+        elif cmd == AP3216C_PS_LOW_THRESHOLD_H:
+            value = self.read_regs(AP3216C_PS_THRESHOLD_LOW_H_REG, 1)[0]
+        elif cmd == AP3216C_PS_HIGH_THRESHOLD_L:
+            value = self.read_regs(AP3216C_PS_THRESHOLD_HIGH_L_REG, 1)[0]
+        elif cmd == AP3216C_PS_HIGH_THRESHOLD_H:
+            value = self.read_regs(AP3216C_PS_THRESHOLD_HIGH_H_REG, 1)[0]
+
+        return value
+
+    def getData(self):
+        ap3216c_dict = {'brightness': 0, 'ir': 0, 'ps': 0}
+
+        brightness = self.ap3216c_read_ambient_light()
+        ir_data = self.ap3216c_read_ir_data()
+        ps_data = self.ap3216c_read_ps_data()
+        ap3216c_dict['brightness'] = brightness
+        ap3216c_dict['ir'] = ir_data
+        ap3216c_dict['ps'] = ps_data
+        return ap3216c_dict
+
+    # 获取光照强度值
+    def getIlluminance(self):
+        if not self._i2cDev:
+            raise ValueError("i2cObj is not initialized")
+
+        return self.ap3216c_read_ambient_light()
+
+    # 获取接近状态：接近返回True，否则返回False
+    def isProximate(self):
+        if not self._i2cDev:
+            raise ValueError("i2cObj is not initialized")
+
+        ps = self.ap3216c_read_ps_data()
+        if ((ps >> 15) & 1):
+            return True
+        else:
+            return False
+
+if __name__ == "__main__":
+    '''
+    The below i2c configuration is needed in your board.json.
+    "ap3216c": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 30
+    }
+    '''
+    print("Testing ap3216c ...")
+
+    i2cDev = I2C()
+    i2cDev.open("ap3216c")
+
+    ap3216cDev = AP3216C(i2cDev)
+
+    illuminance = ap3216cDev.getIlluminance()
+    print("The illuminance is:", illuminance)
+
+    proxi = ap3216cDev.isProximate()
+    print("The proximity state is", proxi)
+
+    data = ap3216cDev.getData()
+
+    print("The total datais: ", data)
+
+    i2cDev.close()
+
+    del ap3216cDev
+    print("Test ap3216c done!")
+
diff --git a/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/board.json b/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/board.json
new file mode 100644
index 0000000000..b6faec8b31
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/board.json
@@ -0,0 +1,190 @@
+{
+  "name": "haasedu",
+  "version": "1.0.0",
+  "io": {
+    "led": {
+      "type": "GPIO",
+      "port": 36,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "ap3216c": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 30
+    },
+    "mpu6050": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 105
+    },
+    "si7006": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 400000,
+      "mode": "master",
+      "devAddr": 64
+    },
+    "spl06": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 400000,
+      "mode": "master",
+      "devAddr": 119
+    },
+    "qmc5883": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 400000,
+      "mode": "master",
+      "devAddr": 13
+    },
+    "GPIO2": {
+      "type": "GPIO",
+      "port": 2,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "GPIO3": {
+      "type": "GPIO",
+      "port": 3,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO4": {
+      "type": "GPIO",
+      "port": 4,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO5": {
+      "type": "GPIO",
+      "port": 5,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO6": {
+      "type": "GPIO",
+      "port": 6,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO7": {
+      "type": "GPIO",
+      "port": 7,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO19": {
+      "type": "GPIO",
+      "port": 19,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "GPIO22": {
+      "type": "GPIO",
+      "port": 22,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "KEY_1": {
+      "type": "GPIO",
+      "port": 23,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "KEY_2": {
+      "type": "GPIO",
+      "port": 20,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "KEY_3": {
+      "type": "GPIO",
+      "port": 21,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "KEY_4": {
+      "type": "GPIO",
+      "port": 26,
+      "dir": "irq",
+      "pull": "pullup",
+      "intMode": "rising"
+    },
+    "I2C1": {
+      "type": "I2C",
+      "port": 1,
+      "addrWidth": 7,
+      "freq": 100000,
+      "mode": "master",
+      "devAddr": 60
+    },
+    "led_r": {
+      "type": "GPIO",
+      "port": 36,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "led_g": {
+      "type": "GPIO",
+      "port": 35,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "led_b": {
+      "type": "GPIO",
+      "port": 34,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "SPI0": {
+      "type": "SPI",
+      "port": 0,
+      "mode": "master",
+      "freq": 2000000
+    },
+    "oled_spi": {
+      "type": "SPI",
+      "port": 1,
+      "mode": "master",
+      "freq": 26000000
+    },
+    "oled_dc": {
+      "type": "GPIO",
+      "port": 28,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "oled_res": {
+      "type": "GPIO",
+      "port": 30,
+      "dir": "output",
+      "pull": "pullup"
+    },
+    "serial2": {
+      "type": "UART",
+      "port": 2,
+      "dataWidth": 8,
+      "baudRate": 115200,
+      "stopBits": 1,
+      "flowControl": "disable",
+      "parity": "none"
+    }
+  },
+  "debugLevel": "ERROR",
+  "repl": "disable"
+}
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/main.py b/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/main.py
new file mode 100644
index 0000000000..66e420405e
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/smart_public_lighting/haaseduk1/code/main.py
@@ -0,0 +1,184 @@
+from aliyunIoT import Device     # aliyunIoT组件是连接阿里云物联网平台的组件
+import utime
+import ap3216c
+from driver import I2C
+from driver import GPIO
+import netmgr as nm
+import ujson
+
+# 三元组信息
+productKey = "产品密钥"
+deviceName = "设备名称"
+deviceSecret = "设备密钥"
+
+# Wi-Fi SSID和Password设置
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+
+adcDev = 0
+ledDev = 0
+lightness = 0
+
+# 物联网平台连接标志位
+iot_connected = False
+
+device = None
+on_connected = False
+
+# EDU K1上灯的初始化
+def ledInit():
+    global ledDev
+    ledDev = GPIO()
+    ledDev.open("led")
+
+# 点亮灯
+def ledOn():
+    global ledDev
+    ledDev.write(1)
+
+# 熄灭灯
+def ledOff():
+    global ledDev
+    ledDev.write(0)
+
+# ap3216c光照传感器初始化
+def ap3216c_init():
+    global ap3216cDev
+    i2cDev = I2C()
+    i2cDev.open("ap3216c")
+
+    ap3216cDev = ap3216c.AP3216C(i2cDev)
+    print("ap3216c init finished")
+
+# ap3216c光照传感器亮度获取
+def ap3216c_light():
+    global ap3216cDev,lightness
+    lightness = ap3216cDev.getIlluminance()
+
+# 关闭ap3216c光照传感器
+def ap3216c_close():
+    global ap3216cDev
+    i2cDev.close()
+    del ap3216cDev
+
+# 上报光照强度数据
+def show_lightness():
+    global lightness,i_light,last_light,system_reset
+
+    i_light = int(lightness)
+    if system_reset == 1:
+        print("system first come")
+        system_reset = 0    # 系统第一次启动
+        report_light_data(i_light)
+    elif (i_light >= 100 and last_light < 100) or (i_light < 100 and last_light >= 100):
+        report_light_data(i_light) # 每次采样值是跨阈值100就上报
+        print("light has change")
+    else:
+        print('no need report')
+
+    if i_light < 10:
+        T_str = "亮度:" + str(round(i_light, 1))
+    elif i_light >= 10 and i_light < 100:
+        T_str = "亮度:" + str(round(i_light, 2))
+    elif i_light >= 100 and i_light < 1000:
+        T_str = "亮度:" + str(round(i_light, 3))
+    elif i_light >= 1000 and i_light < 10000:
+        T_str = "亮度:" + str(round(i_light, 4))
+    print(T_str)
+    last_light = i_light
+
+# 等待Wi-Fi成功连接到路由器
+def get_wifi_status():
+    nm.init()
+    nm.disconnect()
+
+    wifi_connected = nm.getStatus()
+    nm.connect(wifiSsid,wifiPassword)
+    while True :
+        if wifi_connected:
+            break
+        else:
+            wifi_connected = nm.getStatus()
+        utime.sleep(0.5)
+    print("Wi-Fi connected")
+    print('DeviceIP:' + nm.getInfo()['ip'])
+
+
+# 物联网平台连接成功的回调函数
+def on_connect(data):
+    global iot_connected
+    iot_connected = True
+
+# 接收到到物联网服务端平台数据信息的回调函数
+def on_props(request):
+    #服务端返回的json转换成dict
+    payload = ujson.loads(request['params'])
+    #获取dict中的灯物模型状态字段
+    stat = payload["onoff"]
+    if stat == 1:
+        print('led on')
+        ledOn()
+    else:
+        print('led off')
+        ledOff()
+    utime.sleep_ms(200)
+
+# 连接物联网平台
+def connect_lk(productKey, deviceName, deviceSecret):
+
+    global device, iot_connected
+    # 初始化linkkit sdk
+    key_info = {
+        'region': 'cn-shanghai',
+        'productKey': productKey,
+        'deviceName': deviceName,
+        'deviceSecret': deviceSecret,
+        'keepaliveSec': 60
+    }
+    # 将三元组信息设置到iot组件中
+    device = Device()
+
+    # 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
+    device.on(Device.ON_CONNECT, on_connect)
+
+    device.on(Device.ON_PROPS, on_props)
+
+    # 启动连接阿里云物联网平台过程
+    device.connect(key_info)
+
+    # 等待设备成功连接到物联网平台
+    while(True):
+        if iot_connected:
+            print('物联网平台连接成功')
+            break
+        else:
+            print('sleep for 1 s')
+            utime.sleep(1)
+
+def report_light_data(l_data):
+    # 生成上报到物联网平台的属性值字串
+    upload_data = {'params': ujson.dumps({
+        'Brightness': l_data,
+    })
+    }
+    print("uploading data to the cloud:", upload_data)
+    # 上传光强度信息到物联网平台
+    device.postProps(upload_data)
+
+def main():
+    global i_light,last_light,system_reset
+    i_light = 0
+    last_light = 0
+    system_reset = 1
+
+    get_wifi_status()
+    connect_lk(productKey, deviceName, deviceSecret)
+    ap3216c_init()
+    ledInit()
+    while True:
+        ap3216c_light()
+        show_lightness() #光照信息
+        utime.sleep(1.5) #每隔1.5s去刷新光照信息
+
+if __name__ == '__main__':
+    main()
diff --git a/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/README.md b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/README.md
new file mode 100644
index 0000000000..657900b8c6
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/README.md
@@ -0,0 +1,358 @@
+# 车辆定位系统
+&emsp;&emsp;
+下图是本案例除硬件连线外的3步导学，每个步骤中实现的功能请参考图中的说明。
+<div align="center">
+<img src=./../../../images/2_车辆定位系统_步骤概述.jpg width=60%/>
+</div>
+
+## 1、简介
+&emsp;&emsp;
+近年来，全球掀起了一股自动驾驶热潮，无论是传统车企，还是科技企业，甚至很多初创公司都竞相加入这一行业赛道。进入2021年，自动驾驶热度不减，且“吸金”不断，据不完全统计，从今年年初至今，自动驾驶行业投融资事件超过50起，投融资金额近1000亿元，已超过2018年，达到历年最高值。
+
+### 1.1、背景知识
+
+#### 1.1.1、卫星定位系统
+&emsp;&emsp;
+定位系统是以确定空间位置为目标而构成的相互关联的一个集合体或装置（部件）。这个系统可以保证在任意时刻，地球上任意一点都可以同时观测到至少4颗卫星，以保证卫星可以采集到该观测点的经纬度和高度，以便实现导航、定位、授时等功能。这项技术可以用来引导飞机、船舶、车辆以及个人，安全、准确地沿着选定的路线，准时到达目的地。
+&emsp;&emsp;
+目前主流定位系有除美国的GPS，中国的北斗卫星导航系统、欧盟的伽利略卫星导航系统、俄罗斯全球导航卫星系统等。
+
+* GPS
+
+&emsp;&emsp;
+GPS是美国第二代卫星导航系统。按目前的方案，GPS的空间部分使用24颗高度约2.02万千米的卫星组成卫星星座。24颗卫星均为近圆形轨道，运行周期约为11小时58分，分布在6个轨道面上（每轨道面4颗），轨道倾角为55度。卫星的分布使得在全球任何地方、任何时间都可观测到4颗以上的卫星，并能保持良好定位解算精度的几何图形。这就提供了在时间上连续的全球导航能力。
+
+&emsp;&emsp;
+想了解GPS详细信息请参考[文章]((https://baike.baidu.com/item/%E5%85%A8%E7%90%83%E5%AE%9A%E4%BD%8D%E7%B3%BB%E7%BB%9F/1240960?fromtitle=GPS&fromid=214654&fr=aladdin))。
+
+* 北斗卫星导航系统
+
+&emsp;&emsp;
+中国北斗卫星导航系统（英文名称：BeiDou Navigation Satellite System，简称BDS）是中国自行研制的全球卫星导航系统，也是继GPS、GLONASS之后的第三个成熟的卫星导航系统。北斗卫星导航系统（BDS）和美国GPS、俄罗斯GLONASS、欧盟GALILEO，是联合国卫星导航委员会已认定的供应商。
+
+&emsp;&emsp;
+北斗卫星导航系统由空间段、地面段和用户段三部分组成，可在全球范围内全天候、全天时为各类用户提供高精度、高可靠定位、导航、授时服务，并且具备短报文通信能力，已经初步具备区域导航、定位和授时能力，定位精度为分米、厘米级别，测速精度0.2米/秒，授时精度10纳秒。
+
+&emsp;&emsp;
+全球范围内已经有137个国家与北斗卫星导航系统签下了合作协议。随着全球组网的成功，北斗卫星导航系统未来的国际应用空间将会不断扩展。
+
+&emsp;&emsp;
+想了解北斗卫星导航系统详细信息请参考[文章]((https://baike.baidu.com/item/%E5%8C%97%E6%96%97%E5%8D%AB%E6%98%9F%E5%AF%BC%E8%88%AA%E7%B3%BB%E7%BB%9F/10390403?fr=aladdin))
+
+#### 1.1.2、基站定位
+
+&emsp;&emsp;
+除了像GPS这种卫星定位之外，我们身边的设备如：智能手机、智能手表、穿戴设备等能联网的设备都可以用来定位，通过连接运营商(电信、联通、移动)基站来定位的方式称之为基站定位，或者又称之为移动位置服务(LBS--Location Based Service)。
+
+### 1.2、准备
+
+&emsp;&emsp;
+完成本案例需要准备如下硬件：
+* [HaaS EDU K1开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C5AB3B8A4A88800000001&dataId=800C5AB3B8A4A888)            1台
+* [GNSS定位模块 - HT2828Z3G5L](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C7C08112B0A0700000002&dataId=800C7C08112B0A07)   1个
+* 杜邦线若干
+
+如下图实物图所示：
+<div align="center">
+<img src=./../../../images/5_3_车辆定位硬件连接_HaaS_EDU_K1.png width=90%/>
+</div>
+
+<br>
+
+## 2、物联网平台开发
+&emsp;&emsp;
+整个过程包含以下3个步骤：
+
+1. 创建产品（设备模型）
+2. 定义产品功能（物模型）
+3. 创建设备及获取三元组
+
+<br>
+
+&emsp;&emsp;
+对于第一次使用物联网平台的读者，需要开通实例以使用物联网平台的功能。这里可以使用免费的公共实例进行开发。
+
+&emsp;&emsp;
+在[物联网平台](https://iot.console.aliyun.com/lk/summary/new)中，左上角选择“华东2-上海”，点击“公共实例”，即可开通。
+<div align="center">
+<img src=./../../../images/5_3_开通公共实例.png
+ width=100%/>
+</div>
+
+### 2.1、创建产品（设备模型）
+&emsp;&emsp;
+点击上图中的“公共实例”，即可进入[控制台](https://iot.console.aliyun.com/lk/summary/new)进行产品创建。然后，点击“创建产品”按钮，即可进入[新建产品页面](https://iot.console.aliyun.com/product)。
+<div align="center">
+<img src=./../../../images/5_3_公共实例控制台.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+进入[新建产品页面](https://iot.console.aliyun.com/product)后，设定“产品名称”，这里我们命名为“**车辆定位器**”，读者也可以根据自己的喜好来命名。
+
+&emsp;&emsp;
+在“所属品类”中，选择“标准品类”。“标准品类”收录了一些常用的设备模型，其会为我们定义好后续的产品功能（物模型）。我们也可以选择“自定义品类”，来自己定义物模型。在右侧栏中搜索并选择“定位器”。
+
+<div align="center">
+<img src=./../../../images/5_3_创建标准品类产品.png
+ width=100%/>
+</div>
+
+&emsp;&emsp;
+产品的节点类型选择“直连设备”，数据格式选择“ICA标准数据格式”，检验类型和认证方式选择默认设定即可。开发者可根据自己的需求在“产品描述”页面添加针对此产品的描述。
+
+&emsp;&emsp;
+对于 HaaS EDU K1 等搭载 Wi-Fi 的设备而言，联网方式可以选择“Wi-Fi”。
+
+<div align="center">
+    <img src=./../../../images/5_3_创建WIFI产品.png
+    width=40%/>
+</div>
+
+&emsp;&emsp;
+选择之后，点击“确认”按钮，即可完成产品创建。返回“产品”页面之后可以看到产品类表中会出现刚刚创建的“车辆定位器”的产品，如下图所示。
+
+<div align="center">
+<img src=./../../../images/5_3_产品列表车辆定位器.png width=100%/>
+</div>
+<br>
+
+### 2.2、定义产品功能（物模型）
+&emsp;&emsp;
+点击上图中的“查看”按钮，即可看到产品信息，Topic列表，功能定义，数据解析等跟产品相关功能的设定。点开“功能定义”标签页，可以看到设备物模型定义。
+
+<div align="center">
+<img src=./../../../images/5_3_车辆定位器产品详情.png width=100%/>
+</div>
+
+&emsp;&emsp;
+因为在创建产品的过程中选择了标准的产品品类，这里会出现标准品类中自带的物模型设定，即“地理位置”。点击“查看”，我们可以看到该属性的详情。可以看到，该属性的数据类型是一个结构体(struct),其成员描述了设备的精度（浮点）、维度（浮点）、海拔（浮点）、坐标系统（枚举量，1：WGS_84/2:GCJ_02）
+
+<div align="center">
+<img src=./../../../images/5_3_属性详情.png width=100%/>
+</div>
+
+&emsp;&emsp;
+定义好物模型后，记得点击“发布”以使变更生效。
+<div align="center">
+<img src=./../../../images/5_3_发布物模型.png width=100%/>
+</div>
+
+&emsp;&emsp;
+产品及其物模型创建完成后就可以创建这个产品的设备了。
+
+<br>
+
+### 2.3、创建设备及获取三元组
+&emsp;&emsp;
+点击左侧栏中“产品“，回到产品列表。在产品列表页面中，点击“管理设备”，就会进到设备管理页面。
+
+<div align="center">
+<img src=./../../../images/5_3_产品列表管理设备.png width=100%/>
+</div>
+
+&emsp;&emsp;
+在“设备”页面点击“批量添加”按钮，如下图所示。填入需要生成的设备数量。例如图中物联网平台会为我们生成3台设备，以及随机的deviceName。
+<div align="center">
+<img src=./../../../images/5_3_批量添加.png width=100%/>
+</div>
+
+&emsp;&emsp;
+批量生成的设备如下
+<div align="center">
+<img src=./../../../images/5_3_设备列表.png width=100%/>
+</div>
+
+&emsp;&emsp;
+设备添加完成后，点击“前往查看”按钮，就可以看到此设备的详细信息了。
+<div align="center">
+<img src=./../../../images/5_3_设备端详细信息.png width=100%/>
+</div>
+
+<br>
+
+&emsp;&emsp;
+如下图所示，点击“查看”按钮，就可以看到设备的三元组信息，三元组是物联网设备端和物联网云端设备相关联的唯一标识符，在设备端连接云端的时候会使用三元组信息和云端进行鉴权，鉴权通过之后云端会认为设备已激活并上线。
+
+<div align="center">
+<img src=./../../../images/5_3_三元组信息.png width=100%/>
+</div>
+
+<br>
+
+
+## 3、设备端开发
+
+### 3.1、开发环境
+&emsp;&emsp;
+在进行下一步之前请确保HaaS EDU K1开发环境已经搭建完毕。详情请参考[HaaS EDU K1开发环境](../../../startup/HaaS_EDU_K1_startup.md)的说明。
+<br>
+
+### 3.2、创建解决方案
+&emsp;&emsp;
+如下图所示，在Haas Studio中创建项目。先选择左侧的“开发板型号”再从右侧的案例中选择“车辆定位系统”案例点击“立即创建”即可。
+
+<div align="center">
+<img src=./../../../images/HaaS_Studio_创建工程示范.png width=100%/>
+</div>
+<br>
+
+> Python脚本的详细说明请参考脚本内嵌的文字版注释
+>
+&emsp;&emsp;
+之后，在代码中填入对应的信息
+
+1. **填写Wi-Fi名称及密码**
+
+&emsp;&emsp;
+在main.py中，填写可用的Wi-Fi名称及密码。
+
+``` python
+# wifi连接的的ssid和pwd定义
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+```
+
+2. **修改设备端三元组**
+
+&emsp;&emsp;
+在main.py中，填写创建的设备三元组信息。关于设备三元组的获取，请参考[获取设备三元组](./README.md "获取设备三元组")中的步骤。
+
+``` python
+# 三元组信息
+productKey     = "产品key"
+deviceName     = "设备名称"
+deviceSecret   = "设备密钥"
+```
+
+<br>
+
+## 4、运行结果
+### 4.1、本地查看
+&emsp;&emsp;
+推送此脚本到HaaS EDU K1之后，串口会输出获取到的定位信息，同时按照脚本中的逻辑，当定位信息发生变化时，会将更新的定位信息上报至物联网平台。如下面这段串口日志所示。
+```log
+物联网平台连接成功
+sleep for 2s
+[0.0, 'W'] [0.0, 'N'] 0.0
+bytearray(b'$GNGGA,,,,,,0,00,25.5,,,,,,*64\r\n$GNGLL,,,,,,V,M*79\r\n$GNGSA,A,1,,,,,,,,,,,,,25.5,25.5,25.5,1*01\r\n$GNG')
+[0.0, 'W'] [0.0, 'N'] 0.0
+[0.0, 'W'] [0.0, 'N'] 0.0
+bytearray(b'SA,A,1,,,,,,,,,,,,,25.5,25.5,25.5,4*04\r\n$GPGSV,1,1,00,0*65\r\n$BDGSV,1,1,00,0*74\r\n$GNRMC,,V,,,,,,,,,,M')
+[0.0, 'W'] [0.0, 'N'] 0.0
+[0.0, 'W'] [0.0, 'N'] 0.0
+bytearray(b',V*34\r\n$GNVTG,,,,,,,,,M*2D\r\n$GNZDA,,,,,,*56\r\n$GPTXT,01,01,01,ANTENNA OPEN*25\r\n\r\n$GNRMC,,V,,,,,,,,,,M')
+[0.0, 'W'] [0.0, 'N'] 0.0
+[0.0, 'W'] [0.0, 'N'] 0.0
+bytearray(b',V*34\r\n$GNVTG,,,,,,,,,M*2D\r\n$GNZDA,,,,,,*56\r\n$GPTXT,01,01,01,ANTENNA OPEN*25\r\n$GNGGA,,,,,,0,00,25.5,')
+[0.0, 'W'] [0.0, 'N'] 0.0
+[0.0, 'W'] [0.0, 'N'] 0.0
+```
+
+&emsp;&emsp;
+出现此段日志时，说明定位信息上报成功，读者此时可以前往物联网平台查看设备的实时定位数据。
+
+
+### 4.2、在物联网平台上查看设备数据
+&emsp;&emsp;
+当设备启动成功并第一次连接到物联网平台之后，物联网平台上对应的设备状态会从”未激活状态“变为”上线“。点击“物模型数据”标签页，能够看到设备上报到物联网平台的属性值。
+
+<div align="center">
+    <img src=./../../../images/5_3_LP显示定位数据.png width=100%/>
+</div>
+
+&emsp;&emsp;
+点击卡片上的“查看数据”，可以看到完整的历史数据。
+<div align="center">
+    <img src=./../../../images/5_3_LP显示定位数据详情.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此时，如果设备上报新的地理位置信息，则物联网平台上能够实时显示。至此，定位数据上云完成。
+
+<br>
+
+## 5、物联网应用开发（定位数据可视化）
+
+&emsp;&emsp;
+在前面的章节中，我们已经成功将地位信息实时上传到了云端。本节中，我们将介绍如何快速实现将设备的位置实时显示在地图中。
+
+&emsp;&emsp;
+IoT Studio 提供了应用快速开发的能力，可以很方便地与物联网平台进行联动。本节的开发工作也将围绕 IoT Studio展开。
+<br>
+
+### 5.1、新建“普通项目”
+&emsp;&emsp;
+打开[IoT Studio官网](https://studio.iot.aliyun.com/)，在项目管理中新建一个空白项目，如下图所示，将此项目命名为“车辆实时定位系统”。
+<div align="center">
+<img src=./../../../images/5_3_普通项目.png width=100%/>
+<img src=./../../../images/5_3_创建空白项目.png width=100%/>
+</div>
+
+<br>
+
+### 5.2、关联产品
+&emsp;&emsp;
+为了使本项目能够获取到目标设备的定位信息，我们首先需要将该项目和我们在前一节创建的产品“车辆定位器”绑定。
+
+&emsp;&emsp;
+在项目控制台，点击左侧的“产品”，点击“关联物联网平台产品”。此时可以看见我们创建的“车辆定位器”。点击选中，并勾选“关联产品同时关联其下所有设备”，以便该项目可以访问到所有设备的定位信息。
+<div align="center">
+<img src=./../../../images/5_3_关联产品.png width=100%/>
+</div>
+
+### 5.3、创建“Web应用”
+&emsp;&emsp;
+在项目控制台，点击左侧的“主页”，在新项目的首页新建一个Web应用，命名为“车辆实时定位监控”。
+<div align="center">
+<img src=./../../../images/5_3_Web应用.png width=100%/>
+</div>
+
+&emsp;&emsp;
+Web应用创建成功后自动跳转到应用界面设计页面。点击左侧栏中的“组件”按钮图标，就可以看到可用的组件列表。各组件的说明请参考[IoT Studio组件说明](https://help.aliyun.com/document_detail/125196.html)。
+
+&emsp;&emsp;
+为了能够将设备显示在地图上，我们选用“设备地图”组件。鼠标悬停在该组件上以查看详细信息。
+<div align="center">
+<img src=./../../../images/5_3_设备地图.png width=100%/>
+</div>
+
+&emsp;&emsp;
+将“设备地图”组件拖拽至画布，并调整大小。此时，地图上还未能正确显示设备。我们需要点击右侧“编辑设备地图”。
+<div align="center">
+<img src=./../../../images/5_3_界面布局.png width=100%/>
+</div>
+
+&emsp;&emsp;
+点击右侧“编辑设备地图”后，我们可以在右侧“选择设备”中，选择我们刚刚和项目绑定的“车辆定位器”。点击确定。
+<div align="center">
+<img src=./../../../images/5_3_选择产品.png width=100%/>
+</div>
+
+&emsp;&emsp;
+此时，地图上已经出现了定位点，正是我们之前上线的设备。在右侧选择“车辆定位器”，可以看到绑定的所有设备。点击对应设备可以在地图上定位到每个设备的具体位置。至此，“设备地图“配置完成，点击页面右上角”√“保存配置。
+<div align="center">
+<img src=./../../../images/5_3_选择设备.png width=100%/>
+</div>
+<br>
+
+### 5.4、发布上线
+
+<div align="center">
+<img src=./../../../images/5_3_发布和上线.png width=100%/>
+</div>
+
+&emsp;&emsp;
+回到WEB应用页面，可以看到地图上的设备定位已经正常显示，可以进行发布。在发布之前可以点击上图的“预览”查看应用的实际运行效果。实际运行效果如下图所示：
+
+<div align="center">
+<img src=./../../../images/5_3_预览.png width=100%/>
+</div>
+
+<br>
+
+&emsp;&emsp;
+这样我们就完成了一个车辆实时定位系统从设备端定位信息获取、物联网云平台开发及物联网应用开发全链路的开发。
+
+&emsp;&emsp;
+如果想要学习车辆定位系统案例更详细的操作步骤，请参考“[车辆定位系统详解](https://gitee.com/haasedu/haasedu/blob/release_2.0/5-%E6%99%BA%E6%85%A7%E5%9F%8E%E5%B8%82/%E5%9C%BA%E6%99%AF3-%E8%BD%A6%E8%BE%86%E5%AE%9A%E4%BD%8D%E7%B3%BB%E7%BB%9F/README.md)”中的说明。
diff --git a/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/board.json b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/board.json
new file mode 100644
index 0000000000..7d5430e50b
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/board.json
@@ -0,0 +1,203 @@
+{
+    "name": "haasedu",
+    "version": "1.0.0",
+    "io": {
+      "gnss": {
+        "type": "UART",
+        "port": 2,
+        "dataWidth": 8,
+        "baudRate": 9600,
+        "stopBits": 1,
+        "flowControl": "disable",
+        "parity": "none"
+      },
+      "hcho": {
+        "type": "ADC",
+        "port": 0,
+        "sampling": 12000000
+      },
+      "led_r": {
+        "type": "GPIO",
+        "port": 36,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "ap3216c": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 30
+      },
+      "mpu6050": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 105
+      },
+      "si7006": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 64
+      },
+      "spl06": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 119
+      },
+      "qmc5883": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 400000,
+        "mode": "master",
+        "devAddr": 13
+      },
+      "ADC2": {
+        "type": "ADC",
+        "port": 0,
+        "sampling": 12000000
+      },
+      "GPIO2": {
+        "type": "GPIO",
+        "port": 2,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "GPIO3": {
+        "type": "GPIO",
+        "port": 3,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO4": {
+        "type": "GPIO",
+        "port": 4,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO5": {
+        "type": "GPIO",
+        "port": 5,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO6": {
+        "type": "GPIO",
+        "port": 6,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO7": {
+        "type": "GPIO",
+        "port": 7,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO19": {
+        "type": "GPIO",
+        "port": 19,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "GPIO22": {
+        "type": "GPIO",
+        "port": 22,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "KEY_1": {
+        "type": "GPIO",
+        "port": 23,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "KEY_2": {
+        "type": "GPIO",
+        "port": 20,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "KEY_3": {
+        "type": "GPIO",
+        "port": 21,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "KEY_4": {
+        "type": "GPIO",
+        "port": 26,
+        "dir": "irq",
+        "pull": "pullup",
+        "intMode": "rising"
+      },
+      "I2C1": {
+        "type": "I2C",
+        "port": 1,
+        "addrWidth": 7,
+        "freq": 100000,
+        "mode": "master",
+        "devAddr": 60
+      },
+      "led_g": {
+        "type": "GPIO",
+        "port": 35,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "led_b": {
+        "type": "GPIO",
+        "port": 34,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "SPI0": {
+        "type": "SPI",
+        "port": 0,
+        "mode": "master",
+        "freq": 2000000
+      },
+      "oled_spi": {
+        "type": "SPI",
+        "port": 1,
+        "mode": "master",
+        "freq": 26000000
+      },
+      "oled_dc": {
+        "type": "GPIO",
+        "port": 28,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "oled_res": {
+        "type": "GPIO",
+        "port": 30,
+        "dir": "output",
+        "pull": "pullup"
+      },
+      "serial2": {
+        "type": "UART",
+        "port": 2,
+        "dataWidth": 8,
+        "baudRate": 115200,
+        "stopBits": 1,
+        "flowControl": "disable",
+        "parity": "none"
+      }
+    },
+    "debugLevel": "ERROR",
+    "repl": "disable"
+  }
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/gnss.py b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/gnss.py
new file mode 100644
index 0000000000..090dc10238
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/gnss.py
@@ -0,0 +1,29 @@
+from driver import UART
+from micropyGNSS import MicropyGNSS
+
+class Gnss(object):
+
+    def __init__(self, uartObj):
+        self.uartObj = None
+        if not isinstance(uartObj, UART):
+            raise ValueError("parameter is not a GPIO object")
+
+        # 初始化定位模组串口
+        self.uartObj = uartObj
+        self.gnss = MicropyGNSS(location_formatting='dd')
+
+    def getLocation(self):
+        if self.uartObj is None:
+            raise ValueError("invalid UART object")
+        # 创建定位信息解析器
+        sentence = bytearray(100)
+        recvsize = self.uartObj.read(sentence)
+        if(recvsize):
+            print(sentence)
+            sentence = sentence.decode()
+            # 解析地理位置信息
+            for c in sentence:
+                self.gnss.update(c)
+            print(self.gnss.longitude, self.gnss.latitude, self.gnss.altitude)
+
+        return self.gnss
diff --git a/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/main.py b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/main.py
new file mode 100644
index 0000000000..acdb149dc8
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/main.py
@@ -0,0 +1,137 @@
+from aliyunIoT import Device     # aliyunIoT组件是连接阿里云物联网平台的组件
+import utime
+import netmgr as nm
+from driver import UART
+import gnss
+import ujson
+
+uartDev = 0
+gnssDev = 0
+
+# wifi连接的的ssid和pwd定义
+wifiSsid = "请填写您的路由器名称"
+wifiPassword = "请填写您的路由器密码"
+
+# 物联网平台相关的key和serect定义
+productKey     = "产品key"
+deviceName     = "设备名称"
+deviceSecret   = "设备密钥"
+
+# 物联网平台连接状态标识
+iot_connected = False
+
+# 物联网设备实例
+device = None
+
+# 物联网平台连接成功时触发 on_connect
+def on_connect():
+    global on_connected
+    on_connected = True
+
+def gnssInit():
+    global gnssDev,uartDev
+    # 初始化定位模组串口
+    uartDev = UART()
+    uartDev.open('gnss')
+    # 创建定位信息解析器
+    gnssDev = gnss.Gnss(uartDev)
+
+# 等待Wi-Fi成功连接到路由器
+def get_wifi_status():
+    nm.init()
+    wifi_connected = nm.getStatus()
+    print("start to connect " , wifiSsid)
+    nm.connect(wifiSsid, wifiPassword)       # 连接到指定的路由器（路由器名称为wifiSsid, 密码为：wifiPassword）
+
+    while True :
+        if wifi_connected == 5:               # nm.getStatus()返回5代表连线成功
+            break
+        else:
+            wifi_connected = nm.getStatus() # 获取Wi-Fi连接路由器的状态信息
+            utime.sleep(0.5)
+    # utime.sleep(5)
+    print("Wi-Fi connected")
+    print('DeviceIP:' + nm.getInfo()['ip'])  # 打印Wi-Fi的IP地址信息
+
+
+# 物联网平台连接成功时触发 on_connect
+def on_connect(data):
+    global iot_connected
+    iot_connected = True
+
+# 设置props 事件接收函数（当云平台向设备下发属性时）
+def on_props(request):
+    pass
+
+def connect_lk(productKey, deviceName, deviceSecret):
+    global device, iot_connected
+    key_info = {
+        'region': 'cn-shanghai',
+        'productKey': productKey,
+        'deviceName': deviceName,
+        'deviceSecret': deviceSecret,
+        'keepaliveSec': 60
+    }
+    # 将三元组信息设置到iot组件中
+    device = Device()
+
+    # 设定连接到物联网平台的回调函数，如果连接物联网平台成功，则调用on_connect函数
+    device.on(Device.ON_CONNECT, on_connect)
+
+    # 配置收到云端属性控制指令的回调函数，如果收到物联网平台发送的属性控制消息，则调用on_props函数
+    device.on(Device.ON_PROPS, on_props)
+
+    # 启动连接阿里云物联网平台过程
+    device.connect(key_info)
+
+    # 等待设备成功连接到物联网平台
+    while(True):
+        if iot_connected:
+            print('物联网平台连接成功')
+            break
+        else:
+            print('sleep for 1 s')
+            utime.sleep(1)
+
+# 主程序入口
+if __name__ == '__main__':
+    gnssInit()
+
+    # 请替换物联网平台申请到的产品和设备信息,可以参考文章:https://blog.csdn.net/HaaSTech/article/details/114360517
+    get_wifi_status()
+    connect_lk(productKey, deviceName, deviceSecret)
+
+    # 定义经纬度及海拔
+    longitude = 0
+    latitude = 0
+    altitude = 0
+    # 连续从串口种读取信息
+    while True:
+        # 串口读取定位模块语句
+        location = gnssDev.getLocation()
+        if(location):
+            print(location.longitude, location.latitude, location.altitude)
+
+            # 判断定位信息是否发生变化
+            if(longitude != location.longitude[0] or latitude != location.latitude[0] or altitude != location.altitude):
+                longitude = location.longitude[0]
+                latitude = location.latitude[0]
+                altitude = location.altitude
+                print(longitude, latitude, altitude)
+
+                # 如果有变化，则上报地理位置信息至物联网平台
+                loc_data = {
+                    'params': ujson.dumps({
+                        'GeoLocation': {
+                            'Longitude': longitude,
+                            'Latitude': latitude,
+                            'Altitude': altitude,
+                            'CoordinateSystem': 1
+                        }
+                    })
+                }
+                device.postProps(loc_data)
+        utime.sleep(2)
+    device.close()
+    uartDev.close()
+
diff --git a/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/micropyGNSS.py b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/micropyGNSS.py
new file mode 100644
index 0000000000..346e3d6648
--- /dev/null
+++ b/haas_lib_bundles/python/docs/examples/vehicle_location/haaseduk1/code/micropyGNSS.py
@@ -0,0 +1,864 @@
+"""
+# MicropyGPS - a GPS NMEA sentence parser for Micropython/Python 3.X
+# Copyright (c) 2017 Michael Calvin McCoy (calvin.mccoy@protonmail.com)
+# The MIT License (MIT) - see LICENSE file
+"""
+
+"""
+MIT License
+
+Copyright (c) 2017 Calvin McCoy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+# TODO:
+# Time Since First Fix
+# Distance/Time to Target
+# More Helper Functions
+# Dynamically limit sentences types to parse
+
+from math import floor, modf
+
+# Import utime or time for fix time handling
+try:
+    # Assume running on MicroPython
+    import utime
+except ImportError:
+    # Otherwise default to time module for non-embedded implementations
+    # Should still support millisecond resolution.
+    import time
+
+
+class MicropyGNSS(object):
+    """NMEA Sentence Parser. Creates object that stores all relevant GPS data and statistics.
+    Parses sentences one character at a time using update(). """
+
+    # Max Number of Characters a valid sentence can be (based on GGA sentence)
+    SENTENCE_LIMIT = 90
+    __HEMISPHERES = ('N', 'S', 'E', 'W')
+    __NO_FIX = 1
+    __FIX_2D = 2
+    __FIX_3D = 3
+    __DIRECTIONS = ('N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W',
+                    'WNW', 'NW', 'NNW')
+    __MONTHS = ('January', 'February', 'March', 'April', 'May',
+                'June', 'July', 'August', 'September', 'October',
+                'November', 'December')
+
+    def __init__(self, local_offset=0, location_formatting='ddm'):
+        """
+        Setup GPS Object Status Flags, Internal Data Registers, etc
+            local_offset (int): Timzone Difference to UTC
+            location_formatting (str): Style For Presenting Longitude/Latitude:
+                                       Decimal Degree Minute (ddm) - 40° 26.767′ N
+                                       Degrees Minutes Seconds (dms) - 40° 26′ 46″ N
+                                       Decimal Degrees (dd) - 40.446° N
+        """
+
+        #####################
+        # Object Status Flags
+        self.sentence_active = False
+        self.active_segment = 0
+        self.process_crc = False
+        self.gps_segments = []
+        self.crc_xor = 0
+        self.char_count = 0
+        self.fix_time = 0
+
+        #####################
+        # Sentence Statistics
+        self.crc_fails = 0
+        self.clean_sentences = 0
+        self.parsed_sentences = 0
+
+        #####################
+        # Logging Related
+        self.log_handle = None
+        self.log_en = False
+
+        #####################
+        # Data From Sentences
+        # Time
+        self.timestamp = [0, 0, 0]
+        self.date = [0, 0, 0]
+        self.local_offset = local_offset
+
+        # Position/Motion
+        self._latitude = [0, 0.0, 'N']
+        self._longitude = [0, 0.0, 'W']
+        self.coord_format = location_formatting
+        self.speed = [0.0, 0.0, 0.0]
+        self.course = 0.0
+        self.altitude = 0.0
+        self.geoid_height = 0.0
+
+        # GPS Info
+        self.satellites_in_view = 0
+        self.satellites_in_use = 0
+        self.satellites_used = []
+        self.last_sv_sentence = 0
+        self.total_sv_sentences = 0
+        self.satellite_data = dict()
+        self.hdop = 0.0
+        self.pdop = 0.0
+        self.vdop = 0.0
+        self.valid = False
+        self.fix_stat = 0
+        self.fix_type = 1
+
+    ########################################
+    # Coordinates Translation Functions
+    ########################################
+    @property
+    def latitude(self):
+        """Format Latitude Data Correctly"""
+        if self.coord_format == 'dd':
+            decimal_degrees = self._latitude[0] + (self._latitude[1] / 60)
+            return [decimal_degrees, self._latitude[2]]
+        elif self.coord_format == 'dms':
+            minute_parts = modf(self._latitude[1])
+            seconds = round(minute_parts[0] * 60)
+            return [self._latitude[0], int(minute_parts[1]), seconds, self._latitude[2]]
+        else:
+            return self._latitude
+
+    @property
+    def longitude(self):
+        """Format Longitude Data Correctly"""
+        if self.coord_format == 'dd':
+            decimal_degrees = self._longitude[0] + (self._longitude[1] / 60)
+            return [decimal_degrees, self._longitude[2]]
+        elif self.coord_format == 'dms':
+            minute_parts = modf(self._longitude[1])
+            seconds = round(minute_parts[0] * 60)
+            return [self._longitude[0], int(minute_parts[1]), seconds, self._longitude[2]]
+        else:
+            return self._longitude
+
+    ########################################
+    # Logging Related Functions
+    ########################################
+    def start_logging(self, target_file, mode="append"):
+        """
+        Create GPS data log object
+        """
+        # Set Write Mode Overwrite or Append
+        mode_code = 'w' if mode == 'new' else 'a'
+
+        try:
+            self.log_handle = open(target_file, mode_code)
+        except AttributeError:
+            print("Invalid FileName")
+            return False
+
+        self.log_en = True
+        return True
+
+    def stop_logging(self):
+        """
+        Closes the log file handler and disables further logging
+        """
+        try:
+            self.log_handle.close()
+        except AttributeError:
+            print("Invalid Handle")
+            return False
+
+        self.log_en = False
+        return True
+
+    def write_log(self, log_string):
+        """Attempts to write the last valid NMEA sentence character to the active file handler
+        """
+        try:
+            self.log_handle.write(log_string)
+        except TypeError:
+            return False
+        return True
+
+    ########################################
+    # Sentence Parsers
+    ########################################
+    def gprmc(self):
+        """Parse Recommended Minimum Specific GPS/Transit data (RMC)Sentence.
+        Updates UTC timestamp, latitude, longitude, Course, Speed, Date, and fix status
+        """
+
+        # UTC Timestamp
+        try:
+            utc_string = self.gps_segments[1]
+
+            if utc_string:  # Possible timestamp found
+                hours = (int(utc_string[0:2]) + self.local_offset) % 24
+                minutes = int(utc_string[2:4])
+                seconds = float(utc_string[4:])
+                self.timestamp = (hours, minutes, seconds)
+            else:  # No Time stamp yet
+                self.timestamp = (0, 0, 0)
+
+        except ValueError:  # Bad Timestamp value present
+            return False
+
+        # Date stamp
+        try:
+            date_string = self.gps_segments[9]
+
+            # Date string printer function assumes to be year >=2000,
+            # date_string() must be supplied with the correct century argument to display correctly
+            if date_string:  # Possible date stamp found
+                day = int(date_string[0:2])
+                month = int(date_string[2:4])
+                year = int(date_string[4:6])
+                self.date = (day, month, year)
+            else:  # No Date stamp yet
+                self.date = (0, 0, 0)
+
+        except ValueError:  # Bad Date stamp value present
+            return False
+
+        # Check Receiver Data Valid Flag
+        if self.gps_segments[2] == 'A':  # Data from Receiver is Valid/Has Fix
+
+            # Longitude / Latitude
+            try:
+                # Latitude
+                l_string = self.gps_segments[3]
+                lat_degs = int(l_string[0:2])
+                lat_mins = float(l_string[2:])
+                lat_hemi = self.gps_segments[4]
+
+                # Longitude
+                l_string = self.gps_segments[5]
+                lon_degs = int(l_string[0:3])
+                lon_mins = float(l_string[3:])
+                lon_hemi = self.gps_segments[6]
+            except ValueError:
+                return False
+
+            if lat_hemi not in self.__HEMISPHERES:
+                return False
+
+            if lon_hemi not in self.__HEMISPHERES:
+                return False
+
+            # Speed
+            try:
+                spd_knt = float(self.gps_segments[7])
+            except ValueError:
+                return False
+
+            # Course
+            try:
+                if self.gps_segments[8]:
+                    course = float(self.gps_segments[8])
+                else:
+                    course = 0.0
+            except ValueError:
+                return False
+
+            # TODO - Add Magnetic Variation
+
+            # Update Object Data
+            self._latitude = [lat_degs, lat_mins, lat_hemi]
+            self._longitude = [lon_degs, lon_mins, lon_hemi]
+            # Include mph and hm/h
+            self.speed = [spd_knt, spd_knt * 1.151, spd_knt * 1.852]
+            self.course = course
+            self.valid = True
+
+            # Update Last Fix Time
+            self.new_fix_time()
+
+        else:  # Clear Position Data if Sentence is 'Invalid'
+            self._latitude = [0, 0.0, 'N']
+            self._longitude = [0, 0.0, 'W']
+            self.speed = [0.0, 0.0, 0.0]
+            self.course = 0.0
+            self.valid = False
+
+        return True
+
+    def gpgll(self):
+        """Parse Geographic Latitude and Longitude (GLL)Sentence. Updates UTC timestamp, latitude,
+        longitude, and fix status"""
+
+        # UTC Timestamp
+        try:
+            utc_string = self.gps_segments[5]
+
+            if utc_string:  # Possible timestamp found
+                hours = (int(utc_string[0:2]) + self.local_offset) % 24
+                minutes = int(utc_string[2:4])
+                seconds = float(utc_string[4:])
+                self.timestamp = (hours, minutes, seconds)
+            else:  # No Time stamp yet
+                self.timestamp = (0, 0, 0)
+
+        except ValueError:  # Bad Timestamp value present
+            return False
+
+        # Check Receiver Data Valid Flag
+        if self.gps_segments[6] == 'A':  # Data from Receiver is Valid/Has Fix
+
+            # Longitude / Latitude
+            try:
+                # Latitude
+                l_string = self.gps_segments[1]
+                lat_degs = int(l_string[0:2])
+                lat_mins = float(l_string[2:])
+                lat_hemi = self.gps_segments[2]
+
+                # Longitude
+                l_string = self.gps_segments[3]
+                lon_degs = int(l_string[0:3])
+                lon_mins = float(l_string[3:])
+                lon_hemi = self.gps_segments[4]
+            except ValueError:
+                return False
+
+            if lat_hemi not in self.__HEMISPHERES:
+                return False
+
+            if lon_hemi not in self.__HEMISPHERES:
+                return False
+
+            # Update Object Data
+            self._latitude = [lat_degs, lat_mins, lat_hemi]
+            self._longitude = [lon_degs, lon_mins, lon_hemi]
+            self.valid = True
+
+            # Update Last Fix Time
+            self.new_fix_time()
+
+        else:  # Clear Position Data if Sentence is 'Invalid'
+            self._latitude = [0, 0.0, 'N']
+            self._longitude = [0, 0.0, 'W']
+            self.valid = False
+
+        return True
+
+    def gpvtg(self):
+        """Parse Track Made Good and Ground Speed (VTG) Sentence. Updates speed and course"""
+        try:
+            course = float(self.gps_segments[1])
+            spd_knt = float(self.gps_segments[5])
+        except ValueError:
+            return False
+
+        # Include mph and km/h
+        self.speed = (spd_knt, spd_knt * 1.151, spd_knt * 1.852)
+        self.course = course
+        return True
+
+    def gpgga(self):
+        """Parse Global Positioning System Fix Data (GGA) Sentence. Updates UTC timestamp, latitude, longitude,
+        fix status, satellites in use, Horizontal Dilution of Precision (HDOP), altitude, geoid height and fix status"""
+
+        try:
+            # UTC Timestamp
+            utc_string = self.gps_segments[1]
+
+            # Skip timestamp if receiver doesn't have on yet
+            if utc_string:
+                hours = (int(utc_string[0:2]) + self.local_offset) % 24
+                minutes = int(utc_string[2:4])
+                seconds = float(utc_string[4:])
+            else:
+                hours = 0
+                minutes = 0
+                seconds = 0.0
+
+            # Number of Satellites in Use
+            satellites_in_use = int(self.gps_segments[7])
+
+            # Get Fix Status
+            fix_stat = int(self.gps_segments[6])
+
+        except (ValueError, IndexError):
+            return False
+
+        try:
+            # Horizontal Dilution of Precision
+            hdop = float(self.gps_segments[8])
+        except (ValueError, IndexError):
+            hdop = 0.0
+
+        # Process Location and Speed Data if Fix is GOOD
+        if fix_stat:
+
+            # Longitude / Latitude
+            try:
+                # Latitude
+                l_string = self.gps_segments[2]
+                lat_degs = int(l_string[0:2])
+                lat_mins = float(l_string[2:])
+                lat_hemi = self.gps_segments[3]
+
+                # Longitude
+                l_string = self.gps_segments[4]
+                lon_degs = int(l_string[0:3])
+                lon_mins = float(l_string[3:])
+                lon_hemi = self.gps_segments[5]
+            except ValueError:
+                return False
+
+            if lat_hemi not in self.__HEMISPHERES:
+                return False
+
+            if lon_hemi not in self.__HEMISPHERES:
+                return False
+
+            # Altitude / Height Above Geoid
+            try:
+                altitude = float(self.gps_segments[9])
+                geoid_height = float(self.gps_segments[11])
+            except ValueError:
+                altitude = 0
+                geoid_height = 0
+
+            # Update Object Data
+            self._latitude = [lat_degs, lat_mins, lat_hemi]
+            self._longitude = [lon_degs, lon_mins, lon_hemi]
+            self.altitude = altitude
+            self.geoid_height = geoid_height
+
+        # Update Object Data
+        self.timestamp = [hours, minutes, seconds]
+        self.satellites_in_use = satellites_in_use
+        self.hdop = hdop
+        self.fix_stat = fix_stat
+
+        # If Fix is GOOD, update fix timestamp
+        if fix_stat:
+            self.new_fix_time()
+
+        return True
+
+    def gpgsa(self):
+        """Parse GNSS DOP and Active Satellites (GSA) sentence. Updates GPS fix type, list of satellites used in
+        fix calculation, Position Dilution of Precision (PDOP), Horizontal Dilution of Precision (HDOP), Vertical
+        Dilution of Precision, and fix status"""
+
+        # Fix Type (None,2D or 3D)
+        try:
+            fix_type = int(self.gps_segments[2])
+        except ValueError:
+            return False
+
+        # Read All (up to 12) Available PRN Satellite Numbers
+        sats_used = []
+        for sats in range(12):
+            sat_number_str = self.gps_segments[3 + sats]
+            if sat_number_str:
+                try:
+                    sat_number = int(sat_number_str)
+                    sats_used.append(sat_number)
+                except ValueError:
+                    return False
+            else:
+                break
+
+        # PDOP,HDOP,VDOP
+        try:
+            pdop = float(self.gps_segments[15])
+            hdop = float(self.gps_segments[16])
+            vdop = float(self.gps_segments[17])
+        except ValueError:
+            return False
+
+        # Update Object Data
+        self.fix_type = fix_type
+
+        # If Fix is GOOD, update fix timestamp
+        if fix_type > self.__NO_FIX:
+            self.new_fix_time()
+
+        self.satellites_used = sats_used
+        self.hdop = hdop
+        self.vdop = vdop
+        self.pdop = pdop
+
+        return True
+
+    def gpgsv(self):
+        """Parse Satellites in View (GSV) sentence. Updates number of SV Sentences,the number of the last SV sentence
+        parsed, and data on each satellite present in the sentence"""
+        try:
+            num_sv_sentences = int(self.gps_segments[1])
+            current_sv_sentence = int(self.gps_segments[2])
+            sats_in_view = int(self.gps_segments[3])
+        except ValueError:
+            return False
+
+        # Create a blank dict to store all the satellite data from this sentence in:
+        # satellite PRN is key, tuple containing telemetry is value
+        satellite_dict = dict()
+
+        # Calculate  Number of Satelites to pull data for and thus how many segment positions to read
+        if num_sv_sentences == current_sv_sentence:
+            # Last sentence may have 1-4 satellites; 5 - 20 positions
+            sat_segment_limit = (
+                sats_in_view - ((num_sv_sentences - 1) * 4)) * 5
+        else:
+            # Non-last sentences have 4 satellites and thus read up to position 20
+            sat_segment_limit = 20
+
+        # Try to recover data for up to 4 satellites in sentence
+        for sats in range(4, sat_segment_limit, 4):
+
+            # If a PRN is present, grab satellite data
+            if self.gps_segments[sats]:
+                try:
+                    sat_id = int(self.gps_segments[sats])
+                except (ValueError, IndexError):
+                    return False
+
+                try:  # elevation can be null (no value) when not tracking
+                    elevation = int(self.gps_segments[sats+1])
+                except (ValueError, IndexError):
+                    elevation = None
+
+                try:  # azimuth can be null (no value) when not tracking
+                    azimuth = int(self.gps_segments[sats+2])
+                except (ValueError, IndexError):
+                    azimuth = None
+
+                try:  # SNR can be null (no value) when not tracking
+                    snr = int(self.gps_segments[sats+3])
+                except (ValueError, IndexError):
+                    snr = None
+            # If no PRN is found, then the sentence has no more satellites to read
+            else:
+                break
+
+            # Add Satellite Data to Sentence Dict
+            satellite_dict[sat_id] = (elevation, azimuth, snr)
+
+        # Update Object Data
+        self.total_sv_sentences = num_sv_sentences
+        self.last_sv_sentence = current_sv_sentence
+        self.satellites_in_view = sats_in_view
+
+        # For a new set of sentences, we either clear out the existing sat data or
+        # update it as additional SV sentences are parsed
+        if current_sv_sentence == 1:
+            self.satellite_data = satellite_dict
+        else:
+            self.satellite_data.update(satellite_dict)
+
+        return True
+
+    ##########################################
+    # Data Stream Handler Functions
+    ##########################################
+
+    def new_sentence(self):
+        """Adjust Object Flags in Preparation for a New Sentence"""
+        self.gps_segments = ['']
+        self.active_segment = 0
+        self.crc_xor = 0
+        self.sentence_active = True
+        self.process_crc = True
+        self.char_count = 0
+
+    def update(self, new_char):
+        """Process a new input char and updates GPS object if necessary based on special characters ('$', ',', '*')
+        Function builds a list of received string that are validate by CRC prior to parsing by the  appropriate
+        sentence function. Returns sentence type on successful parse, None otherwise"""
+
+        valid_sentence = False
+
+        # Validate new_char is a printable char
+        ascii_char = ord(new_char)
+
+        if 10 <= ascii_char <= 126:
+            self.char_count += 1
+
+            # Write Character to log file if enabled
+            if self.log_en:
+                self.write_log(new_char)
+
+            # Check if a new string is starting ($)
+            if new_char == '$':
+                self.new_sentence()
+                return None
+
+            elif self.sentence_active:
+
+                # Check if sentence is ending (*)
+                if new_char == '*':
+                    self.process_crc = False
+                    self.active_segment += 1
+                    self.gps_segments.append('')
+                    return None
+
+                # Check if a section is ended (,), Create a new substring to feed
+                # characters to
+                elif new_char == ',':
+                    self.active_segment += 1
+                    self.gps_segments.append('')
+
+                # Store All Other printable character and check CRC when ready
+                else:
+                    self.gps_segments[self.active_segment] += new_char
+
+                    # When CRC input is disabled, sentence is nearly complete
+                    if not self.process_crc:
+
+                        if len(self.gps_segments[self.active_segment]) == 2:
+                            try:
+                                final_crc = int(
+                                    self.gps_segments[self.active_segment], 16)
+                                if self.crc_xor == final_crc:
+                                    valid_sentence = True
+                                else:
+                                    self.crc_fails += 1
+                            except ValueError:
+                                pass  # CRC Value was deformed and could not have been correct
+
+                # Update CRC
+                if self.process_crc:
+                    self.crc_xor ^= ascii_char
+
+                # If a Valid Sentence Was received and it's a supported sentence, then parse it!!
+                if valid_sentence:
+                    self.clean_sentences += 1  # Increment clean sentences received
+                    self.sentence_active = False  # Clear Active Processing Flag
+
+                    if self.gps_segments[0] in self.supported_sentences:
+
+                        # parse the Sentence Based on the message type, return True if parse is clean
+                        if self.supported_sentences[self.gps_segments[0]](self):
+
+                            # Let host know that the GPS object was updated by returning parsed sentence type
+                            self.parsed_sentences += 1
+                            return self.gps_segments[0]
+
+                # Check that the sentence buffer isn't filling up with Garage waiting for the sentence to complete
+                if self.char_count > self.SENTENCE_LIMIT:
+                    self.sentence_active = False
+
+        # Tell Host no new sentence was parsed
+        return None
+
+    def new_fix_time(self):
+        """Updates a high resolution counter with current time when fix is updated. Currently only triggered from
+        GGA, GSA and RMC sentences"""
+        try:
+            self.fix_time = utime.ticks_ms()
+        except NameError:
+            self.fix_time = time.time()
+
+    #########################################
+    # User Helper Functions
+    # These functions make working with the GPS object data easier
+    #########################################
+
+    def satellite_data_updated(self):
+        """
+        Checks if the all the GSV sentences in a group have been read, making satellite data complete
+        :return: boolean
+        """
+        if self.total_sv_sentences > 0 and self.total_sv_sentences == self.last_sv_sentence:
+            return True
+        else:
+            return False
+
+    def unset_satellite_data_updated(self):
+        """
+        Mark GSV sentences as read indicating the data has been used and future updates are fresh
+        """
+        self.last_sv_sentence = 0
+
+    def satellites_visible(self):
+        """
+        Returns a list of of the satellite PRNs currently visible to the receiver
+        :return: list
+        """
+        return list(self.satellite_data.keys())
+
+    def time_since_fix(self):
+        """Returns number of millisecond since the last sentence with a valid fix was parsed. Returns 0 if
+        no fix has been found"""
+
+        # Test if a Fix has been found
+        if self.fix_time == 0:
+            return -1
+
+        # Try calculating fix time using utime; if not running MicroPython
+        # time.time() returns a floating point value in secs
+        try:
+            current = utime.ticks_diff(utime.ticks_ms(), self.fix_time)
+        except NameError:
+            current = (time.time() - self.fix_time) * 1000  # ms
+
+        return current
+
+    def compass_direction(self):
+        """
+        Determine a cardinal or inter-cardinal direction based on current course.
+        :return: string
+        """
+        # Calculate the offset for a rotated compass
+        if self.course >= 348.75:
+            offset_course = 360 - self.course
+        else:
+            offset_course = self.course + 11.25
+
+        # Each compass point is separated by 22.5 degrees, divide to find lookup value
+        dir_index = floor(offset_course / 22.5)
+
+        final_dir = self.__DIRECTIONS[dir_index]
+
+        return final_dir
+
+    def latitude_string(self):
+        """
+        Create a readable string of the current latitude data
+        :return: string
+        """
+        if self.coord_format == 'dd':
+            formatted_latitude = self.latitude
+            lat_string = str(
+                formatted_latitude[0]) + '° ' + str(self._latitude[2])
+        elif self.coord_format == 'dms':
+            formatted_latitude = self.latitude
+            lat_string = str(formatted_latitude[0]) + '° ' + str(formatted_latitude[1]) + "' " + str(
+                formatted_latitude[2]) + '" ' + str(formatted_latitude[3])
+        else:
+            lat_string = str(
+                self._latitude[0]) + '° ' + str(self._latitude[1]) + "' " + str(self._latitude[2])
+        return lat_string
+
+    def longitude_string(self):
+        """
+        Create a readable string of the current longitude data
+        :return: string
+        """
+        if self.coord_format == 'dd':
+            formatted_longitude = self.longitude
+            lon_string = str(
+                formatted_longitude[0]) + '° ' + str(self._longitude[2])
+        elif self.coord_format == 'dms':
+            formatted_longitude = self.longitude
+            lon_string = str(formatted_longitude[0]) + '° ' + str(formatted_longitude[1]) + "' " + str(
+                formatted_longitude[2]) + '" ' + str(formatted_longitude[3])
+        else:
+            lon_string = str(
+                self._longitude[0]) + '° ' + str(self._longitude[1]) + "' " + str(self._longitude[2])
+        return lon_string
+
+    def speed_string(self, unit='kph'):
+        """
+        Creates a readable string of the current speed data in one of three units
+        :param unit: string of 'kph','mph, or 'knot'
+        :return:
+        """
+        if unit == 'mph':
+            speed_string = str(self.speed[1]) + ' mph'
+
+        elif unit == 'knot':
+            if self.speed[0] == 1:
+                unit_str = ' knot'
+            else:
+                unit_str = ' knots'
+            speed_string = str(self.speed[0]) + unit_str
+
+        else:
+            speed_string = str(self.speed[2]) + ' km/h'
+
+        return speed_string
+
+    def date_string(self, formatting='s_mdy', century='20'):
+        """
+        Creates a readable string of the current date.
+        Can select between long format: Januray 1st, 2014
+        or two short formats:
+        11/01/2014 (MM/DD/YYYY)
+        01/11/2014 (DD/MM/YYYY)
+        :param formatting: string 's_mdy', 's_dmy', or 'long'
+        :param century: int delineating the century the GPS data is from (19 for 19XX, 20 for 20XX)
+        :return: date_string  string with long or short format date
+        """
+
+        # Long Format Januray 1st, 2014
+        if formatting == 'long':
+            # Retrieve Month string from private set
+            month = self.__MONTHS[self.date[1] - 1]
+
+            # Determine Date Suffix
+            if self.date[0] in (1, 21, 31):
+                suffix = 'st'
+            elif self.date[0] in (2, 22):
+                suffix = 'nd'
+            elif self.date[0] == (3, 23):
+                suffix = 'rd'
+            else:
+                suffix = 'th'
+
+            day = str(self.date[0]) + suffix  # Create Day String
+
+            year = century + str(self.date[2])  # Create Year String
+
+            date_string = month + ' ' + day + ', ' + year  # Put it all together
+
+        else:
+            # Add leading zeros to day string if necessary
+            if self.date[0] < 10:
+                day = '0' + str(self.date[0])
+            else:
+                day = str(self.date[0])
+
+            # Add leading zeros to month string if necessary
+            if self.date[1] < 10:
+                month = '0' + str(self.date[1])
+            else:
+                month = str(self.date[1])
+
+            # Add leading zeros to year string if necessary
+            if self.date[2] < 10:
+                year = '0' + str(self.date[2])
+            else:
+                year = str(self.date[2])
+
+            # Build final string based on desired formatting
+            if formatting == 's_dmy':
+                date_string = day + '/' + month + '/' + year
+
+            else:  # Default date format
+                date_string = month + '/' + day + '/' + year
+
+        return date_string
+
+    # All the currently supported NMEA sentences
+    supported_sentences = {'GPRMC': gprmc, 'GLRMC': gprmc, 'BDGSA': gpgsa,
+                           'GPGGA': gpgga, 'GLGGA': gpgga, 'BDGSV': gpgsv,
+                           'GPVTG': gpvtg, 'GLVTG': gpvtg,
+                           'GPGSA': gpgsa, 'GLGSA': gpgsa,
+                           'GPGSV': gpgsv, 'GLGSV': gpgsv,
+                           'GPGLL': gpgll, 'GLGLL': gpgll,
+                           'GNGGA': gpgga, 'GNRMC': gprmc,
+                           'GNVTG': gpvtg, 'GNGLL': gpgll,
+                           'GNGSA': gpgsa,
+                           }
+
+
+if __name__ == "__main__":
+    pass
diff --git "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python_helloworld_\344\273\243\347\240\201.png" "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python_helloworld_\344\273\243\347\240\201.png"
index fbe8e32d17..a9506ac955 100644
Binary files "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python_helloworld_\344\273\243\347\240\201.png" and "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python_helloworld_\344\273\243\347\240\201.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python_\346\234\254\345\234\260\346\216\250\351\200\201\350\204\232\346\234\254.png" "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python_\346\234\254\345\234\260\346\216\250\351\200\201\350\204\232\346\234\254.png"
index 5edf3ff1e2..152d1fef11 100644
Binary files "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python_\346\234\254\345\234\260\346\216\250\351\200\201\350\204\232\346\234\254.png" and "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python_\346\234\254\345\234\260\346\216\250\351\200\201\350\204\232\346\234\254.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python\345\267\245\347\250\213\346\214\211\351\222\256.png" "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python\345\267\245\347\250\213\346\214\211\351\222\256.png"
index 09b2282b85..9048d415c6 100644
Binary files "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python\345\267\245\347\250\213\346\214\211\351\222\256.png" and "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_Python\345\267\245\347\250\213\346\214\211\351\222\256.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_\345\210\233\345\273\272\351\241\271\347\233\256\345\220\221\345\257\274.png" "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_\345\210\233\345\273\272\351\241\271\347\233\256\345\220\221\345\257\274.png"
index aca80c985a..26a9b4c0ad 100644
Binary files "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_\345\210\233\345\273\272\351\241\271\347\233\256\345\220\221\345\257\274.png" and "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_\345\210\233\345\273\272\351\241\271\347\233\256\345\220\221\345\257\274.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_\345\233\272\344\273\266\347\203\247\345\275\225.png" "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_\345\233\272\344\273\266\347\203\247\345\275\225.png"
index cfd15e5660..794df6bc7a 100644
Binary files "a/haas_lib_bundles/python/docs/images/1_HaaS_Studio_\345\233\272\344\273\266\347\203\247\345\275\225.png" and "b/haas_lib_bundles/python/docs/images/1_HaaS_Studio_\345\233\272\344\273\266\347\203\247\345\275\225.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/1_\345\256\211\350\243\205haas_studio_\346\217\222\344\273\266.png" "b/haas_lib_bundles/python/docs/images/1_\345\256\211\350\243\205haas_studio_\346\217\222\344\273\266.png"
index 2cf1f94a39..0f8de01669 100644
Binary files "a/haas_lib_bundles/python/docs/images/1_\345\256\211\350\243\205haas_studio_\346\217\222\344\273\266.png" and "b/haas_lib_bundles/python/docs/images/1_\345\256\211\350\243\205haas_studio_\346\217\222\344\273\266.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/2_2_HaaS_EDU_K1_\350\265\267\345\244\234\347\201\257\347\241\254\344\273\266\346\216\245\347\272\277\345\233\276.png" "b/haas_lib_bundles/python/docs/images/2_2_HaaS_EDU_K1_\350\265\267\345\244\234\347\201\257\347\241\254\344\273\266\346\216\245\347\272\277\345\233\276.png"
new file mode 100644
index 0000000000..3b993faaa0
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/2_2_HaaS_EDU_K1_\350\265\267\345\244\234\347\201\257\347\241\254\344\273\266\346\216\245\347\272\277\345\233\276.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/2_\347\207\203\346\260\224\346\243\200\346\265\213_HaaS_EDU_K1_MQ2\350\277\236\347\272\277.png" "b/haas_lib_bundles/python/docs/images/2_\347\207\203\346\260\224\346\243\200\346\265\213_HaaS_EDU_K1_MQ2\350\277\236\347\272\277.png"
new file mode 100644
index 0000000000..f95aaecfb4
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/2_\347\207\203\346\260\224\346\243\200\346\265\213_HaaS_EDU_K1_MQ2\350\277\236\347\272\277.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/2_\347\224\262\351\206\233\346\243\200\346\265\213_HaaS_EDU_K1_HCHO_DAC_\350\277\236\347\272\277.jpg" "b/haas_lib_bundles/python/docs/images/2_\347\224\262\351\206\233\346\243\200\346\265\213_HaaS_EDU_K1_HCHO_DAC_\350\277\236\347\272\277.jpg"
new file mode 100644
index 0000000000..89a9ef91a2
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/2_\347\224\262\351\206\233\346\243\200\346\265\213_HaaS_EDU_K1_HCHO_DAC_\350\277\236\347\272\277.jpg" differ
diff --git "a/haas_lib_bundles/python/docs/images/4_HaaS_EDU_K1_\347\201\253\347\204\260\344\274\240\346\204\237\345\231\250\350\277\236\347\272\277\345\233\276.png" "b/haas_lib_bundles/python/docs/images/4_HaaS_EDU_K1_\347\201\253\347\204\260\344\274\240\346\204\237\345\231\250\350\277\236\347\272\277\345\233\276.png"
new file mode 100644
index 0000000000..8fce615e31
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/4_HaaS_EDU_K1_\347\201\253\347\204\260\344\274\240\346\204\237\345\231\250\350\277\236\347\272\277\345\233\276.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2161.jpg" "b/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2161.jpg"
new file mode 100644
index 0000000000..d4e9f72071
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2161.jpg" differ
diff --git "a/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2162.jpg" "b/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2162.jpg"
new file mode 100644
index 0000000000..87c1de8f2f
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2162.jpg" differ
diff --git "a/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2163.jpg" "b/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2163.jpg"
new file mode 100644
index 0000000000..4e4898fcfd
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2163.jpg" differ
diff --git "a/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2164.jpg" "b/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2164.jpg"
new file mode 100644
index 0000000000..41e7f84137
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/5_1_haaseduk1_\350\247\204\345\210\231\345\274\225\346\223\2164.jpg" differ
diff --git "a/haas_lib_bundles/python/docs/images/5_3_\350\275\246\350\276\206\345\256\232\344\275\215\347\241\254\344\273\266\350\277\236\346\216\245_HaaS_EDU_K1.png" "b/haas_lib_bundles/python/docs/images/5_3_\350\275\246\350\276\206\345\256\232\344\275\215\347\241\254\344\273\266\350\277\236\346\216\245_HaaS_EDU_K1.png"
new file mode 100644
index 0000000000..2b602e06e4
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/5_3_\350\275\246\350\276\206\345\256\232\344\275\215\347\241\254\344\273\266\350\277\236\346\216\245_HaaS_EDU_K1.png" differ
diff --git a/haas_lib_bundles/python/docs/images/HaaSPython_2.0_detail.png b/haas_lib_bundles/python/docs/images/HaaSPython_2.0_detail.png
new file mode 100644
index 0000000000..1ab2241d34
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaSPython_2.0_detail.png differ
diff --git a/haas_lib_bundles/python/docs/images/HaaSPython_2.0_overview.png b/haas_lib_bundles/python/docs/images/HaaSPython_2.0_overview.png
new file mode 100644
index 0000000000..697a6a2678
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaSPython_2.0_overview.png differ
diff --git a/haas_lib_bundles/python/docs/images/HaaSPython_2.0_overview_1.png b/haas_lib_bundles/python/docs/images/HaaSPython_2.0_overview_1.png
new file mode 100644
index 0000000000..e21ed54bc0
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaSPython_2.0_overview_1.png differ
diff --git a/haas_lib_bundles/python/docs/images/HaaSPython_2.1_detail.png b/haas_lib_bundles/python/docs/images/HaaSPython_2.1_detail.png
new file mode 100644
index 0000000000..17c9576ca9
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaSPython_2.1_detail.png differ
diff --git a/haas_lib_bundles/python/docs/images/HaaSPython_2.1_overview.png b/haas_lib_bundles/python/docs/images/HaaSPython_2.1_overview.png
new file mode 100644
index 0000000000..3be8ceb602
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaSPython_2.1_overview.png differ
diff --git a/haas_lib_bundles/python/docs/images/HaaSPython_2.1_overview_1.png b/haas_lib_bundles/python/docs/images/HaaSPython_2.1_overview_1.png
new file mode 100644
index 0000000000..d22778445b
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaSPython_2.1_overview_1.png differ
diff --git a/haas_lib_bundles/python/docs/images/HaaSPython_2.2_detail.png b/haas_lib_bundles/python/docs/images/HaaSPython_2.2_detail.png
new file mode 100644
index 0000000000..727cd28398
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaSPython_2.2_detail.png differ
diff --git a/haas_lib_bundles/python/docs/images/HaaSPython_2.2_overview_1.png b/haas_lib_bundles/python/docs/images/HaaSPython_2.2_overview_1.png
new file mode 100644
index 0000000000..392de3d606
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaSPython_2.2_overview_1.png differ
diff --git "a/haas_lib_bundles/python/docs/images/HaaSPython_\345\277\253\351\200\237\345\274\200\345\247\213_overview.png" "b/haas_lib_bundles/python/docs/images/HaaSPython_\345\277\253\351\200\237\345\274\200\345\247\213_overview.png"
new file mode 100644
index 0000000000..1cb886c52d
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/HaaSPython_\345\277\253\351\200\237\345\274\200\345\247\213_overview.png" differ
diff --git a/haas_lib_bundles/python/docs/images/HaaS_Studio_HaaSEDUK1_fw_download.png b/haas_lib_bundles/python/docs/images/HaaS_Studio_HaaSEDUK1_fw_download.png
new file mode 100644
index 0000000000..bf167bf5c1
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaS_Studio_HaaSEDUK1_fw_download.png differ
diff --git a/haas_lib_bundles/python/docs/images/HaaS_Studio_HaaSEDUK1_helloworld.png b/haas_lib_bundles/python/docs/images/HaaS_Studio_HaaSEDUK1_helloworld.png
new file mode 100644
index 0000000000..d30066f556
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaS_Studio_HaaSEDUK1_helloworld.png differ
diff --git a/haas_lib_bundles/python/docs/images/HaaS_Studio_fast_startup.png b/haas_lib_bundles/python/docs/images/HaaS_Studio_fast_startup.png
new file mode 100644
index 0000000000..c52a89b40a
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/HaaS_Studio_fast_startup.png differ
diff --git "a/haas_lib_bundles/python/docs/images/HaaS_Studio_\345\210\233\345\273\272\345\267\245\347\250\213\347\244\272\350\214\203.png" "b/haas_lib_bundles/python/docs/images/HaaS_Studio_\345\210\233\345\273\272\345\267\245\347\250\213\347\244\272\350\214\203.png"
new file mode 100644
index 0000000000..c142a19da9
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/HaaS_Studio_\345\210\233\345\273\272\345\267\245\347\250\213\347\244\272\350\214\203.png" differ
diff --git a/haas_lib_bundles/python/docs/images/haas-studio-firmware-burn.png b/haas_lib_bundles/python/docs/images/haas-studio-firmware-burn.png
index c80b3e1479..1e5785aec3 100644
Binary files a/haas_lib_bundles/python/docs/images/haas-studio-firmware-burn.png and b/haas_lib_bundles/python/docs/images/haas-studio-firmware-burn.png differ
diff --git a/haas_lib_bundles/python/docs/images/haas-studio-startup-page.png b/haas_lib_bundles/python/docs/images/haas-studio-startup-page.png
index 15745e7c3b..10a92c0e56 100644
Binary files a/haas_lib_bundles/python/docs/images/haas-studio-startup-page.png and b/haas_lib_bundles/python/docs/images/haas-studio-startup-page.png differ
diff --git "a/haas_lib_bundles/python/docs/images/haas-studio-\345\210\233\345\273\272\345\267\245\347\250\213-\351\200\211\346\213\251helloworld.png" "b/haas_lib_bundles/python/docs/images/haas-studio-\345\210\233\345\273\272\345\267\245\347\250\213-\351\200\211\346\213\251helloworld.png"
new file mode 100644
index 0000000000..81eab2ae89
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/haas-studio-\345\210\233\345\273\272\345\267\245\347\250\213-\351\200\211\346\213\251helloworld.png" differ
diff --git "a/haas_lib_bundles/python/docs/images/haas-studio-\345\210\233\345\273\272\345\267\245\347\250\213\345\220\221\345\257\274.png" "b/haas_lib_bundles/python/docs/images/haas-studio-\345\210\233\345\273\272\345\267\245\347\250\213\345\220\221\345\257\274.png"
new file mode 100644
index 0000000000..a9ea6c2f64
Binary files /dev/null and "b/haas_lib_bundles/python/docs/images/haas-studio-\345\210\233\345\273\272\345\267\245\347\250\213\345\220\221\345\257\274.png" differ
diff --git a/haas_lib_bundles/python/docs/images/haas_studio_app_ota_get_tocken.png b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_get_tocken.png
new file mode 100644
index 0000000000..5ccb2f6acf
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_get_tocken.png differ
diff --git a/haas_lib_bundles/python/docs/images/haas_studio_app_ota_overview.png b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_overview.png
new file mode 100644
index 0000000000..944cb5d095
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_overview.png differ
diff --git a/haas_lib_bundles/python/docs/images/haas_studio_app_ota_redo.png b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_redo.png
new file mode 100644
index 0000000000..f946be2e0f
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_redo.png differ
diff --git a/haas_lib_bundles/python/docs/images/haas_studio_app_ota_result.png b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_result.png
new file mode 100644
index 0000000000..270223ab7c
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_result.png differ
diff --git a/haas_lib_bundles/python/docs/images/haas_studio_app_ota_step1_2.png b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_step1_2.png
new file mode 100644
index 0000000000..bb6465a795
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_step1_2.png differ
diff --git a/haas_lib_bundles/python/docs/images/haas_studio_app_ota_steps.png b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_steps.png
new file mode 100644
index 0000000000..b4205eba18
Binary files /dev/null and b/haas_lib_bundles/python/docs/images/haas_studio_app_ota_steps.png differ
diff --git a/haas_lib_bundles/python/docs/startup/ESP-C3-32S-Kit_startup.md b/haas_lib_bundles/python/docs/startup/ESP-C3-32S-Kit_startup.md
index 9eb6576f76..2584f60aad 100644
--- a/haas_lib_bundles/python/docs/startup/ESP-C3-32S-Kit_startup.md
+++ b/haas_lib_bundles/python/docs/startup/ESP-C3-32S-Kit_startup.md
@@ -5,36 +5,20 @@ ESP-C3-32S-Kit是开源世界中被开发者普遍使用的开发板，在ESP-C3
 &emsp;&emsp;
 本文则主要介绍如何烧录ESP-C3-32S-Kit HaaS Python标准固件并在此基础上完成helloworld Python程序的运行。
 
-## HaaS Python固件版本列表
-
+## 一、HaaS Python固件下载
 &emsp;&emsp;
-请通过下面固件列表链接下载开发板对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
+请从[HaaS Python版本历史](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/startup)下载ESP-C3-32S-Kit对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
 ```
 ├── HaaSPython-ESP-C3-32S-Kit-{xxx}.bin   # HaaS官方固件，{xxx}为版本号
 ```
-&emsp;&emsp;
-### HaaS Python ESP-C3-32S-Kit标准固件列表
-
-* [HaaSPython-ESP-C3-32S-Kit-v2.1.0](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP-C3-32S-Kit-v2.1.0.zip)
-
-  <summary>版本更新说明（2022-04-29）</summary>
 
-  * 新增ESP-C3-32S-Kit开发板支持
-  * 升级HaaS Studio - 精简IDE开发流程，支持固件一键烧写
-  * 兼容MicroPython v1.17
-  * 支持快速连接阿里云物联网云平台（aliyunIoT），支持设备模式和网关模式
-  * 扩展Driver、KV、HTTP、Modbus等功能
-  * 优化ESP-C3-32S-Kit IDF内存分配机制
 
-## ESP-C3-32S-Kit开发环境准备
-&emsp;&emsp;
-将ESP-C3-32S-Kit开发板用Micro-USB数据线和电脑USB口相连。
+## 二、安装HaaS-Studio开发工具
 
-### HaaS Studio安装
 &emsp;&emsp;
 HaaS Studio目前是以插件的形式安装在VS Code（Visual Studio Code）工具中，所以安装HaaS Studio之前需要先安装VS Code。
 
-#### 安装VS Code
+### 2.1 安装VS Code
 
 &emsp;&emsp;
 读者请到[微软官方网站](https://code.visualstudio.com/)上下载 VS Code 安装包并进行安装，VS Code安装包要求不低于版本 1.57。
@@ -48,7 +32,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 > 推荐 Windows 系统版本为 win10， MacOS 版本不低于 10.15。
 <br>
 
-#### 安装haas-studio插件
+### 2.2 安装haas-studio插件
 
 > 安装完 VS Code之后，windows用户请注意使用管理员权限打开(vscode插件会安装相关工具到C盘，需要管理员权限)
 
@@ -58,28 +42,28 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 安装完 VS Code之后，请按照下图中数字的指示步骤完成haas-studio插件的安装。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_安装haas_studio_插件.png width=80%/>
+<img src=../images/1_安装haas_studio_插件.png width=80%/>
 </div>
 
 &emsp;&emsp;
 插件第一次安装完成后，会提示安装相关工具才能激活插件，请同意安装相关工具。第一次新建或者打开python轻应用工程，也会安装轻应用开发相关工具，同样需要同意安装。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-tool-install.png width=80%/>
+<img src=../images/haas-studio-tool-install.png width=80%/>
 </div>
 
 &emsp;&emsp;
 插件安装完成后，则 VSCode 左下角的状态栏会显示"快速开始"的图标，如下图所示。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-startup-page.png width=80%/>
+<img src=../images/haas-studio-startup-page.png width=80%/>
 </div>
 
 &emsp;&emsp;
 一般情况下，左下角只会显示快速开始图标，如果打开或者新建了某个Python工程，则会在VSCode底部的状态栏展开如下一排按钮，这些按钮的功能如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python工程按钮.png width=40%/>
+<img src=../images/1_HaaS_Studio_Python工程按钮.png width=40%/>
 </div>
 
 &emsp;&emsp;
@@ -87,25 +71,30 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 * 注意高级模式某些平台可能不支持，比如低版本的linux，M1系列MACOS等，如果平台不支持，会自动设置成 disable。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-python-advance.png width=80%/>
+<img src=../images/haas-studio-python-advance.png width=80%/>
 </div>
 
 &emsp;&emsp;
 python高级模式打开之后，这些按钮的功能变成如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-python-advance-enable.png width=40%/>
+<img src=../images/haas-studio-python-advance-enable.png width=40%/>
 </div>
 
-### ESP-C3-32S-Kit串口名称确认
-#### Windows系统
+## 三、固件烧录
+
+&emsp;&emsp;
+进行固件烧录前需要先确认开发板连接到电脑后对应的串口名称。
+
+### 3.1 串口名称确认
+#### 3.1.1 Windows系统
 
 &emsp;&emsp;
 如果您的电脑是Windows系统，请通过控制面板下的设备管理器，查询当前电脑下ESP-C3-32S-Kit插入后新增的端口。下图中显示ESP-C3-32S-Kit连接后新增的串口为“COM7”。
 > 注意：每台PC的串口可能都不一样，如果有多个串口，可以断开PC和ESP-C3-32S-Kit之间的连线，然后将PC和ESP-C3-32S-Kit相连，找到新增的那个串口。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_EDU_K1_WINDOWS_COM.png width=70%/>
+<img src=../images/1_HaaS_EDU_K1_WINDOWS_COM.png width=70%/>
 </div>
 
 &emsp;&emsp;
@@ -114,7 +103,7 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 * [CP2102驱动下载](https://www.silabs.com/documents/public/software/CP210x_Universal_Windows_Driver.zip)
 <br>
 
-#### MAC系统
+#### 3.1.2 MAC系统
 
 &emsp;&emsp;
 如果您的电脑是MAC系统，系统会自带ESP-C3-32S-Kit UART驱动程序，无需单独安装。可以在命令行中通过如下命令查看ESP-C3-32S-Kit接到电脑之前和之后串口列表的差异确认ESP-C3-32S-Kit串口名称。
@@ -134,13 +123,13 @@ zsh: no matches found: /dev/tty.usb*
 > 注意：每台PC的串口可能都不一样，上面只是笔者电脑上面的串口信息。
 <br>
 
-### 固件烧录过程
+### 3.2 使用HaaS Studio进行固件烧录
 &emsp;&emsp;
 烧录此固件需使用HaaS-Studio集成开发环境。
 
 1. 点击“快速开始”按钮后选择“烧录工具”按钮。如下图所示。
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_固件烧录.png width=75%/>
+<img src=../images/1_HaaS_Studio_固件烧录.png width=75%/>
 </div>
 2. 选择好ESP-C3-32S-Kit对应的“串口名字”和固件所在路径（上面“ESP-C3-32S-Kit HaaS固件下载”步骤中解压出来的名为HaaSPython-ESP-C3-32S-Kit-{xxx}.bin的文件）之后点击“开始烧录”按钮，HaaS Studio便会将此固件烧录到开发板中，如下图所示。
 
@@ -182,7 +171,7 @@ Hard resetting via RTS pin...
 &emsp;&emsp;
 经过上面的步骤HaaS Python ESP-C3-32S-Kit固件就烧录到ESP-C3-32S-Kit开发板中去了。
 
-### 固件版本确认
+### 3.3 固件版本确认
 &emsp;&emsp;
 固件烧录完成后，如何确认固件真的有更新到硬件中呢？可以通过如下的方法确认：
 
@@ -193,14 +182,14 @@ Hard resetting via RTS pin...
 > MACOS建议使用picocom串口工具；Windows系统推荐使用Putty串口工具。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_版本号确认.png width=50%/>
+<img src=../images/HaaSPython_版本号确认.png width=50%/>
 </div>
 
 > 打开串口工具后，敲回车后如果未出现">>>"符号，则一般是因为您的开发板正在运行Python脚本。此时，可以同时按下Ctrl+C两个按键，尝试打断当前的python脚本。如果按很多次Ctrl+C之后仍然没有出现">>>"，则大概率是因为开发板运行的程序死机，可以尝试按住“Ctrl+C”再对开发板进行硬件复位。
 
-## ESP-C3-32S-Kit helloworld例程
+## 四、运行helloworld例程
 
-### 创建helloworld工程
+### 4.1 创建helloworld工程
 &emsp;&emsp;
 请遵循如下的步骤完成helloworld Python工程的创建。
 
@@ -208,35 +197,40 @@ Hard resetting via RTS pin...
 如下图所示，点击HaaS Studio的"快速开始"按键会弹出HaaS Studio的欢迎页面，请选择“创建项目”，如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_创建项目向导.png width=60%/>
+<img src=../images/1_HaaS_Studio_创建项目向导.png width=80%/>
 </div>
 
+
 &emsp;&emsp;
 根据创建工程向导，开发者输入/选择相关的信息即可。下面以在ESP-C3-32S-Kit上面创建hellworld示例程序为例演示工程进行，步骤如下:
 > 注意事项： 文件夹不要有中文，空格及其他异常字符。
 
-1. 输入项目名称
-2. 选择工作区所在路径
-3. 选择硬件类型
-4. 选择编程语言
-5. 选择解决方案模板
+1.  选中"ESP32-C3-32S-Kit"开发板，右侧会更新相应的案例列表
+2. 选择helloworld案例，点击创建。
+
 <div align="center">
-<img src=../images/1_HaaS_Studio_ESP-C3-32S-Kit_创建项目向导.png width=80%/>
+<img src=../images/haas-studio-创建工程-选择helloworld.png width=80%/>
 </div>
 
 &emsp;&emsp;
-然后点击“立即创建”按钮，在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
-
+填入项目名称，以及项目工作路径后点击确定。
+&emsp;&emsp;
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+<img src=../images/haas-studio-创建工程向导.png width=40%/>
 </div>
 
+&emsp;&emsp;
+在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
+
+<div align="center">
+<img src=../images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+</div>
 
-### 推送脚本到设备
+### 4.2 推送脚本到设备
 
 &emsp;&emsp;
 &emsp;&emsp;
-点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
+点击HaaS-Studio的“部署运行”按钮（<img src=../images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
 <div align="center">
 <img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
 </div>
@@ -261,7 +255,7 @@ helloworld
 ...
 ```
 
-### 例程Python脚本说明
+### 4.3 例程Python脚本说明
 
 &emsp;&emsp;
 helloworld工程中的main.py脚本内容如下，各行代码的功能请参考下面代码的注释。
@@ -282,7 +276,7 @@ if __name__ == '__main__':
 helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 
 &emsp;&emsp;
-快速入门完成之后，建议您进入我们的[趣味案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
+快速入门完成之后，建议您进入我们的[创意案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
 
 &emsp;&emsp;
 如果您想了解如何从浅到深完成一个完整的物联网应用的开发，建议您进入我们的[学习中心](https://haas.iot.aliyun.com/learning)进行学习。
@@ -293,11 +287,11 @@ helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 &emsp;&emsp;
 如果您想看HaaS Python都提供哪些库和API，请点击左侧导航栏查看。
 
-## ESP-C3-32S-Kit开发板列表
+## 五、ESP-C3-32S-Kit开发板列表
 &emsp;&emsp;
 HaaS Python固件在如下ESP-C3-32S-Kit系列的开发板上都经过了功能验证，开发者可以根据自己的喜好选择合适的开发板。
 
-### 安信可 NodeMCU-ESP-C3-32S-Kit
+### 5.1 安信可 NodeMCU-ESP-C3-32S-Kit
 &emsp;&emsp;
 HaaS Python固件刷入安信可NodeMCU-ESP-C3-32S-Kit开发版之后，开发板端口详细定义及说明请参考下图：
 
diff --git a/haas_lib_bundles/python/docs/startup/ESP-S3-12K-Kit_startup.md b/haas_lib_bundles/python/docs/startup/ESP-S3-12K-Kit_startup.md
index f4dc7808a9..4e6f34aa5e 100644
--- a/haas_lib_bundles/python/docs/startup/ESP-S3-12K-Kit_startup.md
+++ b/haas_lib_bundles/python/docs/startup/ESP-S3-12K-Kit_startup.md
@@ -5,36 +5,20 @@ ESP-S3-12K-Kit是开源世界中被开发者普遍使用的开发板，在ESP-S3
 &emsp;&emsp;
 本文则主要介绍如何烧录ESP-S3-12K-Kit HaaS Python标准固件并在此基础上完成helloworld Python程序的运行。
 
-## HaaS Python固件版本列表
-
+## 一、HaaS Python固件下载
 &emsp;&emsp;
-请通过下面固件列表链接下载开发板对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
+请从[HaaS Python版本历史](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/startup)下载ESP-S3-12K-Kit对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
 ```
 ├── HaaSPython-ESP-S3-12K-Kit-{xxx}.bin   # HaaS官方固件，{xxx}为版本号
 ```
-&emsp;&emsp;
-### HaaS Python ESP-S3-12K-Kit标准固件列表
-
-* [HaaSPython-ESP-S3-12K-Kit-v2.1.0](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP-S3-12K-Kit-v2.1.0.zip)
-
-  <summary>版本更新说明（2022-04-29）</summary>
 
-  * 新增ESP-S3-12K-Kit支持
-  * 升级HaaS Studio - 精简IDE开发流程，支持固件一键烧写
-  * 兼容MicroPython v1.17
-  * 支持快速连接阿里云物联网云平台（aliyunIoT），支持设备模式和网关模式
-  * 扩展Driver、KV、HTTP、Modbus等功能
-  * 优化ESP-S3-12K-Kit IDF内存分配机制
 
-## ESP-S3-12K-Kit开发环境准备
-&emsp;&emsp;
-将ESP-S3-12K-Kit开发板用Micro-USB数据线和电脑USB口相连。
+## 二、安装HaaS-Studio开发工具
 
-### HaaS Studio安装
 &emsp;&emsp;
 HaaS Studio目前是以插件的形式安装在VS Code（Visual Studio Code）工具中，所以安装HaaS Studio之前需要先安装VS Code。
 
-#### 安装VS Code
+### 2.1 安装VS Code
 
 &emsp;&emsp;
 读者请到[微软官方网站](https://code.visualstudio.com/)上下载 VS Code 安装包并进行安装，VS Code安装包要求不低于版本 1.57。
@@ -48,7 +32,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 > 推荐 Windows 系统版本为 win10， MacOS 版本不低于 10.15。
 <br>
 
-#### 安装haas-studio插件
+## 2.2 安装haas-studio插件
 
 > 安装完 VS Code之后，windows用户请注意使用管理员权限打开(vscode插件会安装相关工具到C盘，需要管理员权限)
 
@@ -58,28 +42,28 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 安装完 VS Code之后，请按照下图中数字的指示步骤完成haas-studio插件的安装。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_安装haas_studio_插件.png width=80%/>
+<img src=../images/1_安装haas_studio_插件.png width=80%/>
 </div>
 
 &emsp;&emsp;
 插件第一次安装完成后，会提示安装相关工具才能激活插件，请同意安装相关工具。第一次新建或者打开python轻应用工程，也会安装轻应用开发相关工具，同样需要同意安装。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-tool-install.png width=80%/>
+<img src=../images/haas-studio-tool-install.png width=80%/>
 </div>
 
 &emsp;&emsp;
 插件安装完成后，则 VSCode 左下角的状态栏会显示"快速开始"的图标，如下图所示。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-startup-page.png width=80%/>
+<img src=../images/haas-studio-startup-page.png width=80%/>
 </div>
 
 &emsp;&emsp;
 一般情况下，左下角只会显示快速开始图标，如果打开或者新建了某个Python工程，则会在VSCode底部的状态栏展开如下一排按钮，这些按钮的功能如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python工程按钮.png width=40%/>
+<img src=../images/1_HaaS_Studio_Python工程按钮.png width=40%/>
 </div>
 
 &emsp;&emsp;
@@ -87,25 +71,30 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 * 注意高级模式某些平台可能不支持，比如低版本的linux，M1系列MACOS等，如果平台不支持，会自动设置成 disable。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-python-advance.png width=80%/>
+<img src=../images/haas-studio-python-advance.png width=80%/>
 </div>
 
 &emsp;&emsp;
 python高级模式打开之后，这些按钮的功能变成如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-python-advance-enable.png width=40%/>
+<img src=../images/haas-studio-python-advance-enable.png width=40%/>
 </div>
 
-### ESP-S3-12K-Kit串口名称确认
-#### Windows系统
+## 三、固件烧录
+
+&emsp;&emsp;
+进行固件烧录前需要先确认开发板连接到电脑后对应的串口名称。
+
+### 3.1 串口名称确认
+#### 3.1.1 Windows系统
 
 &emsp;&emsp;
 如果您的电脑是Windows系统，请通过控制面板下的设备管理器，查询当前电脑下ESP-S3-12K-Kit插入后新增的端口。下图中显示ESP-S3-12K-Kit连接后新增的串口为“COM7”。
 > 注意：每台PC的串口可能都不一样，如果有多个串口，可以断开PC和ESP-S3-12K-Kit之间的连线，然后将PC和ESP-S3-12K-Kit相连，找到新增的那个串口。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_EDU_K1_WINDOWS_COM.png width=70%/>
+<img src=../images/1_HaaS_EDU_K1_WINDOWS_COM.png width=70%/>
 </div>
 
 &emsp;&emsp;
@@ -114,7 +103,7 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 * [CP2102驱动下载](https://www.silabs.com/documents/public/software/CP210x_Universal_Windows_Driver.zip)
 <br>
 
-#### MAC系统
+#### 3.1.2 MAC系统
 
 &emsp;&emsp;
 如果您的电脑是MAC系统，系统会自带ESP-S3-12K-Kit UART驱动程序，无需单独安装。可以在命令行中通过如下命令查看ESP-S3-12K-Kit接到电脑之前和之后串口列表的差异确认ESP-S3-12K-Kit串口名称。
@@ -134,13 +123,13 @@ zsh: no matches found: /dev/tty.usb*
 > 注意：每台PC的串口可能都不一样，上面只是笔者电脑上面的串口信息。
 <br>
 
-### 固件烧录过程
+### 3.2 使用HaaS Studio进行固件烧录
 &emsp;&emsp;
 烧录此固件需使用HaaS-Studio集成开发环境。
 
 1. 点击“快速开始”按钮后选择“烧录工具”按钮。如下图所示。
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_固件烧录.png width=75%/>
+<img src=../images/1_HaaS_Studio_固件烧录.png width=75%/>
 </div>
 2. 选择好ESP-S3-12K-Kit对应的“串口名字”和固件所在路径（上面“ESP-S3-12K-Kit HaaS固件下载”步骤中解压出来的名为HaaSPython-ESP-S3-12K-Kit-{xxx}.bin的文件）之后点击“开始烧录”按钮，HaaS Studio便会将此固件烧录到开发板中，如下图所示。
 
@@ -182,7 +171,7 @@ Hard resetting via RTS pin...
 &emsp;&emsp;
 经过上面的步骤HaaS Python ESP-S3-12K-Kit固件就烧录到ESP-S3-12K-Kit开发板中去了。
 
-### 固件版本确认
+### 3.3 固件版本确认
 &emsp;&emsp;
 固件烧录完成后，如何确认固件真的有更新到硬件中呢？可以通过如下的方法确认：
 
@@ -193,14 +182,14 @@ Hard resetting via RTS pin...
 > MACOS建议使用picocom串口工具；Windows系统推荐使用Putty串口工具。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_版本号确认.png width=50%/>
+<img src=../images/HaaSPython_版本号确认.png width=50%/>
 </div>
 
 > 打开串口工具后，敲回车后如果未出现">>>"符号，则一般是因为您的开发板正在运行Python脚本。此时，可以同时按下Ctrl+C两个按键，尝试打断当前的python脚本。如果按很多次Ctrl+C之后仍然没有出现">>>"，则大概率是因为开发板运行的程序死机，可以尝试按住“Ctrl+C”再对开发板进行硬件复位。
 
-## ESP-S3-12K-Kit helloworld例程
+## 四、运行helloworld例程
 
-### 创建helloworld工程
+### 4.1 创建helloworld工程
 &emsp;&emsp;
 请遵循如下的步骤完成helloworld Python工程的创建。
 
@@ -208,35 +197,39 @@ Hard resetting via RTS pin...
 如下图所示，点击HaaS Studio的"快速开始"按键会弹出HaaS Studio的欢迎页面，请选择“创建项目”，如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_创建项目向导.png width=60%/>
+<img src=../images/1_HaaS_Studio_创建项目向导.png width=80%/>
 </div>
 
 &emsp;&emsp;
 根据创建工程向导，开发者输入/选择相关的信息即可。下面以在ESP-S3-12K-Kit上面创建hellworld示例程序为例演示工程进行，步骤如下:
 > 注意事项： 文件夹不要有中文，空格及其他异常字符。
 
-1. 输入项目名称
-2. 选择工作区所在路径
-3. 选择硬件类型
-4. 选择编程语言
-5. 选择解决方案模板
+1. 选中“ESP32-S3-12K-Kit”开发板，右侧会更新相应的案例列表
+2. 选择helloworld案例，点击创建。
+
 <div align="center">
-<img src=../images/1_HaaS_Studio_ESP-S3-12K-Kit_创建项目向导.png width=80%/>
+<img src=../images/haas-studio-创建工程-选择helloworld.png width=80%/>
 </div>
 
 &emsp;&emsp;
-然后点击“立即创建”按钮，在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
-
+填入项目名称，以及项目工作路径后点击确定。
+&emsp;&emsp;
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+<img src=../images/haas-studio-创建工程向导.png width=40%/>
 </div>
 
+&emsp;&emsp;
+在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
+
+<div align="center">
+<img src=../images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+</div>
 
-### 推送脚本到设备
+### 4.2 推送脚本到设备
 
 &emsp;&emsp;
 &emsp;&emsp;
-点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
+点击HaaS-Studio的“部署运行”按钮（<img src=../images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
 <div align="center">
 <img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
 </div>
@@ -261,7 +254,7 @@ helloworld
 ...
 ```
 
-### 例程Python脚本说明
+### 4.3 例程Python脚本说明
 
 &emsp;&emsp;
 helloworld工程中的main.py脚本内容如下，各行代码的功能请参考下面代码的注释。
@@ -282,7 +275,7 @@ if __name__ == '__main__':
 helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 
 &emsp;&emsp;
-快速入门完成之后，建议您进入我们的[趣味案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
+快速入门完成之后，建议您进入我们的[创意案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
 
 &emsp;&emsp;
 如果您想了解如何从浅到深完成一个完整的物联网应用的开发，建议您进入我们的[学习中心](https://haas.iot.aliyun.com/learning)进行学习。
@@ -293,11 +286,11 @@ helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 &emsp;&emsp;
 如果您想看HaaS Python都提供哪些库和API，请点击左侧导航栏查看。
 
-## ESP-S3-12K-Kit开发板列表
+## 五、ESP-C3-32S-Kit开发板列表
 &emsp;&emsp;
 HaaS Python固件在如下ESP-S3-12K-Kit系列的开发板上都经过了功能验证，开发者可以根据自己的喜好选择合适的开发板。
 
-### 安信可 NodeMCU-ESP-S3-32S-Kit
+### 5.1 安信可 NodeMCU-ESP-S3-32S-Kit
 &emsp;&emsp;
 HaaS Python固件刷入安信可NodeMCU-ESP-S3-32S-12K开发版之后，开发板端口详细定义及说明请参考下图：
 
diff --git a/haas_lib_bundles/python/docs/startup/ESP32_startup.md b/haas_lib_bundles/python/docs/startup/ESP32_startup.md
index 594cbbc589..c8cf9e8a2a 100644
--- a/haas_lib_bundles/python/docs/startup/ESP32_startup.md
+++ b/haas_lib_bundles/python/docs/startup/ESP32_startup.md
@@ -5,68 +5,20 @@ ESP32是开源世界中被开发者普遍使用的开发板，在ESP32设备上
 &emsp;&emsp;
 本文则主要介绍如何烧录ESP32 HaaS Python标准固件并在此基础上完成helloworld Python程序的运行。
 
-## HaaS Python固件版本列表
-
+## 一、HaaS Python固件下载
 &emsp;&emsp;
-请通过下面固件列表链接下载开发板对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
+请从[HaaS Python版本历史](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/startup)下载ESP32对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
 ```
 ├── HaaSPython-ESP32-{xxx}.bin   # HaaS官方固件，{xxx}为版本号
 ```
-&emsp;&emsp;
-### HaaS Python ESP32标准固件列表
-
-* [HaaSPython-ESP32-v2.0.0](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-v2.0.0.zip)
-  * 版本更新说明（2022-04-10）
-    * HaaS轻应用标准升级到2.0（AliyunIoT增加文件上传功能，Driver SPI API增加多字节连续读写，AI，UI等能力）
-    * 新增[ESP32乐鑫官方开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C9562896F994200000001&dataId=800C9562896F9942)和[01Studio ESP32开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C55C67883087B00000001&dataId=800C55C67883087B)支持
-    * 新增30+[传感器](https://haas.iot.aliyun.com/solution/hardware)支持
-    * 新增30+[趣味案例](https://haas.iot.aliyun.com/solution)
-    * 新增3个精美UI模板（带UI能力开发板）
-    * 新增9种AI聚合服务（带UI和AI能力开发板）
-
-* [HaaSPython-ESP32-v1.0.2](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-ESP32-v1.0.2.zip)
-
-  <details>
-  <summary>版本更新说明（2022-01-20）</summary>
-
-  * aliyunIoT库功能优化
-  * 案例可运行硬件增加对01 Studio开发板支持
-  </details>
 
-* [HaaSPython-ESP32-v1.0.1](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v1.0.1.zip)
 
-  <details>
-  <summary>版本更新说明（2022-01-13）</summary>
-
-  * 动态生成QSTR功能
-  * UART增加on/any函数
-  * aliyunIoT修复内存泄漏及postProp返回值问题
-  * 修复部分BUG
-  </details>
-
-* [HaaSPython-ESP32-v1.0.0](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v1.0.0.zip)
-
-  <details>
-  <summary>版本更新说明（2021-12-30）</summary>
-
-  * 新增ESP32开发板NodeMCU-32支持
-  * 新增HaaS小程序，方便快速体验数据上云功能
-  * 升级HaaS Studio - 精简IDE开发流程，支持固件一键烧写
-  * 兼容MicroPython v1.17
-  * 支持快速连接阿里云物联网云平台（aliyunIoT），支持设备模式和网关模式
-  * 扩展Driver、KV、http、BLE配网、OTA和Modbus等功能
-  * 优化ESP32 IDF内存分配机制
-  </details>
-
-## ESP32开发环境准备
-&emsp;&emsp;
-将ESP32开发板用Micro-USB数据线和电脑USB口相连。
+## 二、安装HaaS-Studio开发工具
 
-### HaaS Studio安装
 &emsp;&emsp;
 HaaS Studio目前是以插件的形式安装在VS Code（Visual Studio Code）工具中，所以安装HaaS Studio之前需要先安装VS Code。
 
-#### 安装VS Code
+### 2.1 安装VS Code
 
 &emsp;&emsp;
 读者请到[微软官方网站](https://code.visualstudio.com/)上下载 VS Code 安装包并进行安装，VS Code安装包要求不低于版本 1.57。
@@ -80,7 +32,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 > 推荐 Windows 系统版本为 win10， MacOS 版本不低于 10.15。
 <br>
 
-#### 安装haas-studio插件
+### 2.2 安装haas-studio插件
 
 > 安装完 VS Code之后，windows用户请注意使用管理员权限打开(vscode插件会安装相关工具到C盘，需要管理员权限)
 
@@ -90,7 +42,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 安装完 VS Code之后，请按照下图中数字的指示步骤完成haas-studio插件的安装。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_安装haas_studio_插件.png width=80%/>
+<img src=../images/1_安装haas_studio_插件.png width=80%/>
 </div>
 
 &emsp;&emsp;
@@ -104,14 +56,14 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 插件安装完成后，则 VSCode 左下角的状态栏会显示"快速开始"的图标，如下图所示。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-startup-page.png width=80%/>
+<img src=../images/haas-studio-startup-page.png width=80%/>
 </div>
 
 &emsp;&emsp;
 一般情况下，左下角只会显示快速开始图标，如果打开或者新建了某个Python工程，则会在VSCode底部的状态栏展开如下一排按钮，这些按钮的功能如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python工程按钮.png width=40%/>
+<img src=../images/1_HaaS_Studio_Python工程按钮.png width=40%/>
 </div>
 
 &emsp;&emsp;
@@ -129,8 +81,13 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-python-advance-enable.png width=40%/>
 </div>
 
-### ESP32串口名称确认
-#### Windows系统
+## 三、固件烧录
+
+&emsp;&emsp;
+进行固件烧录前需要先确认开发板连接到电脑后对应的串口名称。
+
+### 3.1 串口名称确认
+#### 3.1.1 Windows系统
 
 &emsp;&emsp;
 如果您的电脑是Windows系统，请通过控制面板下的设备管理器，查询当前电脑下ESP32插入后新增的端口。下图中显示ESP32连接后新增的串口为“COM7”。
@@ -146,7 +103,7 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 * [CP2102驱动下载](https://www.silabs.com/documents/public/software/CP210x_Universal_Windows_Driver.zip)
 <br>
 
-#### MAC系统
+#### 3.1.2 MAC系统
 
 &emsp;&emsp;
 如果您的电脑是MAC系统，系统会自带ESP32 UART驱动程序，无需单独安装。可以在命令行中通过如下命令查看ESP32接到电脑之前和之后串口列表的差异确认ESP32串口名称。
@@ -166,13 +123,13 @@ zsh: no matches found: /dev/tty.usb*
 > 注意：每台PC的串口可能都不一样，上面只是笔者电脑上面的串口信息。
 <br>
 
-### 固件烧录过程
+### 3.2 使用HaaS Studio进行固件烧录
 &emsp;&emsp;
 烧录此固件需使用HaaS-Studio集成开发环境。
 
 1. 点击“快速开始”按钮后选择“烧录工具”按钮。如下图所示。
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_固件烧录.png width=75%/>
+<img src=../images/1_HaaS_Studio_固件烧录.png width=75%/>
 </div>
 2. 选择好ESP32对应的“串口名字”和固件所在路径（上面“ESP32 HaaS固件下载”步骤中解压出来的名为HaaSPython-ESP32-{xxx}.bin的文件）之后点击“开始烧录”按钮，HaaS Studio便会将此固件烧录到开发板中，如下图所示。
 
@@ -181,7 +138,7 @@ zsh: no matches found: /dev/tty.usb*
 > 如果“串口名字”下拉框中没有正确的串口号，可以拔插ESP32的USB口后，点击“刷新”按钮刷新串口列表。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-firmware-burn.png width=85%/>
+<img src=../images/haas-studio-firmware-burn.png width=85%/>
 </div>
 
 &emsp;&emsp;
@@ -222,7 +179,7 @@ Hard resetting via RTS pin...
 &emsp;&emsp;
 经过上面的步骤HaaS Python ESP32固件就烧录到ESP32开发板中去了。
 
-### 固件版本确认
+### 3.3 固件版本确认
 &emsp;&emsp;
 固件烧录完成后，如何确认固件真的有更新到硬件中呢？可以通过如下的方法确认：
 
@@ -238,9 +195,9 @@ Hard resetting via RTS pin...
 
 > 打开串口工具后，敲回车后如果未出现">>>"符号，则一般是因为您的开发板正在运行Python脚本。此时，可以同时按下Ctrl+C两个按键，尝试打断当前的python脚本。如果按很多次Ctrl+C之后仍然没有出现">>>"，则大概率是因为开发板运行的程序死机，可以尝试按住“Ctrl+C”再对开发板进行硬件复位。
 
-## ESP32 helloworld例程
+## 四、运行helloworld例程
 
-### 创建helloworld工程
+### 4.1 创建helloworld工程
 &emsp;&emsp;
 请遵循如下的步骤完成helloworld Python工程的创建。
 
@@ -248,37 +205,41 @@ Hard resetting via RTS pin...
 如下图所示，点击HaaS Studio的"快速开始"按键会弹出HaaS Studio的欢迎页面，请选择“创建项目”，如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_创建项目向导.png width=60%/>
+<img src=../images/1_HaaS_Studio_创建项目向导.png width=80%/>
 </div>
 
 &emsp;&emsp;
 根据创建工程向导，开发者输入/选择相关的信息即可。下面以在ESP32上面创建hellworld示例程序为例演示工程进行，步骤如下:
 > 注意事项： 文件夹不要有中文，空格及其他异常字符。
 
-1. 输入项目名称
-2. 选择工作区所在路径
-3. 选择硬件类型
-4. 选择编程语言
-5. 选择解决方案模板
+1. 选中目标ESP32开发板型号，右侧会更新相应的案例列表
+2. 选择helloworld案例，点击创建。
+
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python创建工程_项目名称.png width=40%/>
+<img src=../images/haas-studio-创建工程-选择helloworld.png width=80%/>
 </div>
 
 &emsp;&emsp;
-然后点击“立即创建”按钮，在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
-
+填入项目名称，以及项目工作路径后点击确定。
+&emsp;&emsp;
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+<img src=../images/haas-studio-创建工程向导.png width=40%/>
 </div>
 
+&emsp;&emsp;
+在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
 
-### 推送脚本到设备
+<div align="center">
+<img src=../images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+</div>
+
+### 4.2 推送脚本到设备
 
 &emsp;&emsp;
 &emsp;&emsp;
 点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
 <div align="center">
-<img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
 </div>
 
 &emsp;&emsp;
@@ -301,7 +262,7 @@ helloworld
 ...
 ```
 
-### 例程Python脚本说明
+### 4.3 例程Python脚本说明
 
 &emsp;&emsp;
 helloworld工程中的main.py脚本内容如下，各行代码的功能请参考下面代码的注释。
@@ -322,7 +283,7 @@ if __name__ == '__main__':
 helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 
 &emsp;&emsp;
-快速入门完成之后，建议您进入我们的[趣味案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
+快速入门完成之后，建议您进入我们的[创意案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
 
 &emsp;&emsp;
 如果您想了解如何从浅到深完成一个完整的物联网应用的开发，建议您进入我们的[学习中心](https://haas.iot.aliyun.com/learning)进行学习。
@@ -333,11 +294,11 @@ helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 &emsp;&emsp;
 如果您想看HaaS Python都提供哪些库和API，请点击左侧导航栏查看。
 
-## ESP32开发板列表
+## 五、ESP32开发板列表
 &emsp;&emsp;
 HaaS Python固件在如下ESP32系列的开发板上都经过了功能验证，开发者可以根据自己的洗好选择合适的开发板。
 
-### 乐鑫 ESP32_DevKitC
+### 5.1 乐鑫 ESP32_DevKitC
 &emsp;&emsp;
 HaaS Python固件刷入乐鑫ESP32_DevKitC开发版之后，开发板端口详细定义及说明请参考下图：
 
@@ -345,7 +306,7 @@ HaaS Python固件刷入乐鑫ESP32_DevKitC开发版之后，开发板端口详
 <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/ESP32_DevKitc_GPIO_mapping.png width=150%/>
 </div>
 
-### 安信可 NodeMCU-32S
+### 5.2 安信可 NodeMCU-32S
 &emsp;&emsp;
 HaaS Python固件刷入安信可NODEMCU-32开发版之后，开发板端口详细定义及说明请参考下图：
 
@@ -353,12 +314,11 @@ HaaS Python固件刷入安信可NODEMCU-32开发版之后，开发板端口详
 <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/ESP32_NodeMCU-32S_GPIO_mapping.png width=150%/>
 </div>
 
-### 01Studio pyWiFi-ESP32
+### 5.3 01Studio pyWiFi-ESP32
 &emsp;&emsp;
 HaaS Python固件刷入01Studio pyWiFi-ESP32开发版之后，开发板端口详细定义及说明请参考下图：
 <div align="center">
 <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/ESP32_pyWiFi-ESP32_GPIO_mapping.png width=150%/>
 </div>
 
-
 <br>
diff --git a/haas_lib_bundles/python/docs/startup/HaaS100_startup.md b/haas_lib_bundles/python/docs/startup/HaaS100_startup.md
index 7543afd00a..647e4aeb15 100644
--- a/haas_lib_bundles/python/docs/startup/HaaS100_startup.md
+++ b/haas_lib_bundles/python/docs/startup/HaaS100_startup.md
@@ -3,36 +3,22 @@
 HaaS100是高性价比的软硬件创新积木平台开发版，集成的是阿里云IoT团队自主研发的AliOS Things物联网操作系统。主控芯片HaaS1000是阿里云IoT定制的高性价比物联网芯片，软件支持JS/Python轻应用和C/C++开发。
 本节则主要介绍如何烧录HaaS100 Python标准固件并在此基础上完成helloworld Python程序的运行。
 
-## HaaS100 Python固件下载
+## 一、HaaS100 Python固件下载
 
 &emsp;&emsp;
-HaaS100和HaaS EDU K1共用Python版本固件，请通过下面固件列表链接下载开发板对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
+HaaS100和HaaS EDU K1共用Python版本固件，请从[HaaS Python版本历史](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/startup)下载HaaS EDU K1对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
 ```bash
 ├── HaaSPython-HaaSEDUK1-{xxx}.bin   # HaaS Python官方固件，{xxx}为版本号
 └── littlefs.bin                     # 文件系统
 ```
 
-&emsp;&emsp;
-### HaaS100固件列表
-
-* [HaaSPython-HaaS100-v1.0.2](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-HaaSEDUK1-v1.0.2.zip)
-  * 版本更新说明（2022-01-20）
-    * aliyunIoT稳定性增强
-
-* [HaaSPython-HaaS100-v1.0.1](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaSEDUK1-1.0.1.zip)
-  * 版本更新说明（2022-01-13）
-    * 对齐到HaaS Python 2.0 API标准
 <br>
 
-## HaaS100开发环境准备
-&emsp;&emsp;
-将HaaS100用microUSB数据线和电脑相连。
-
-### HaaS Studio安装
+## 二、安装HaaS-Studio开发工具
 &emsp;&emsp;
 HaaS Studio目前是以插件的形式安装在VS Code（Visual Studio Code）工具中，所以安装HaaS Studio之前需要先安装VS Code。
 
-#### 安装VS Code
+### 2.1 安装VS Code
 
 &emsp;&emsp;
 读者请到[微软官方网站](https://code.visualstudio.com/)上下载 VS Code 安装包并进行安装，VS Code安装包要求不低于版本 1.57。
@@ -46,8 +32,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 > 推荐 Windows 系统版本为 win10， MacOS 版本不低于 10.15。
 <br>
 
-
-#### 安装haas-studio插件
+## 2.2 安装haas-studio插件
 
 > 安装完 VS Code之后，windows用户请注意使用管理员权限打开(vscode插件会安装相关工具到C盘，需要管理员权限)
 
@@ -64,14 +49,14 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 插件第一次安装完成后，会提示安装相关工具才能激活插件，请同意安装相关工具。第一次新建或者打开python轻应用工程，也会安装轻应用开发相关工具，同样需要同意安装。
 
 <div align="center">
-<img src=../images/haas-studio-tool-install.png width=80%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-tool-install.png width=80%/>
 </div>
 
 &emsp;&emsp;
 插件安装完成后，则 VSCode 左下角的状态栏会显示"快速开始"的图标，如下图所示。
 
 <div align="center">
-<img src=../images/haas-studio-startup-page.png width=80%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-startup-page.png width=80%/>
 </div>
 
 &emsp;&emsp;
@@ -86,18 +71,22 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 * 注意高级模式某些平台可能不支持，比如低版本的linux，M1系列MACOS等，如果平台不支持，会自动设置成 disable。
 
 <div align="center">
-<img src=../images/haas-studio-python-advance.png width=80%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-python-advance.png width=80%/>
 </div>
 
 &emsp;&emsp;
 python高级模式打开之后，这些按钮的功能变成如下图所示：
 
 <div align="center">
-<img src=../images/haas-studio-python-advance-enable.png width=40%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-python-advance-enable.png width=40%/>
 </div>
 
-### HaaS100串口名称确认
-#### Windows系统
+
+## 三、HaaS100固件烧录
+
+
+### 3.1 HaaS100串口名称确认
+#### 3.1.1 Windows系统
 
 &emsp;&emsp;
 读者请通过控制面板下的设备管理器，查询当前电脑下HaaS100插入后新增的端口。下图中显示HaaS EDUK1连接后新增的串口为“COM7”。
@@ -110,7 +99,7 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 
 <br>
 
-#### MAC系统
+#### 3.1.2MAC系统
 
 &emsp;&emsp;
 如果您的电脑是MAC系统，系统会自带HaaS100 UART驱动程序，无需单独安装。可以在命令行中通过如下命令查看HaaS100接到电脑之前和之后串口列表的差异确认HaaS100串口名称。
@@ -131,13 +120,9 @@ zsh: no matches found: /dev/tty.usb*
 
 <br>
 
-## 固件烧录过程
+### 3.2 使用HaaS Studio进行固件烧录
 
-&emsp;&emsp;
-烧录此固件需使用HaaS-Studio集成开发环境。
-
-<br>
-1. 点击“快速开始”按钮后选择“烧录工具”按钮。如下图所示。
+1. 点击HaaS-Studio“快速开始”按钮后选择“烧录工具”按钮。如下图所示。
 <div align="center">
 <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_固件烧录.png width=75%/>
 </div>
@@ -151,7 +136,7 @@ zsh: no matches found: /dev/tty.usb*
 > 如果“串口名字”下拉框中没有正确的串口号，可以拔插HaaS100的USB口后，点击“刷新”按钮刷新串口列表。
 
 <div align="center">
-<img src=../images/haas-studio-firmware-burn.png width=85%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-firmware-burn.png width=85%/>
 </div>
 
 &emsp;&emsp;
@@ -203,7 +188,7 @@ Burn "[('/Users/xxx/Downloads/HaaSPython-HaaSEDUK1/HaaSPython-HaaSEDUK1-1.0.1.bi
 &emsp;&emsp;
 经过上面的步骤HaaS Python固件就烧录到HaaS100开发板中去了。
 
-### 固件版本确认
+### 3.3 固件版本确认
 &emsp;&emsp;
 固件烧录完成后，如何确认固件真的有更新到硬件中呢？可以通过如下的方法确认：
 
@@ -224,9 +209,9 @@ Burn "[('/Users/xxx/Downloads/HaaSPython-HaaSEDUK1/HaaSPython-HaaSEDUK1-1.0.1.bi
 
 > MACOS建议使用picocom串口工具；Windows系统推荐使用Putty串口工具。
 
-## HaaS100 helloworld例程
+## 四、运行helloworld例程
 
-### 创建helloworld工程
+### 4.1 创建helloworld工程
 &emsp;&emsp;
 请遵循如下的步骤完成helloworld Python工程的创建。
 
@@ -258,12 +243,12 @@ Burn "[('/Users/xxx/Downloads/HaaSPython-HaaSEDUK1/HaaSPython-HaaSEDUK1-1.0.1.bi
 </div>
 
 
-### 推送脚本到设备
+### 4.2 推送脚本到设备
 
 &emsp;&emsp;
 点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
 <div align="center">
-<img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
 </div>
 
 &emsp;&emsp;
@@ -314,7 +299,7 @@ helloworld
 ...
 ```
 
-### 例程Python脚本说明
+### 4.3 例程Python脚本说明
 
 &emsp;&emsp;
 helloworld工程中的main.py脚本内容如下，各行代码的功能请参考下面代码的注释。
@@ -335,7 +320,7 @@ if __name__ == '__main__':
 helloworld例程运行起来就说明HaaS Python开发环境安装好了。接下来是对公测案例的说明。
 
 &emsp;&emsp;
-快速入门完成之后，建议您进入我们的[趣味案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
+快速入门完成之后，建议您进入我们的[创意案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
 
 &emsp;&emsp;
 如果您想了解如何从浅到深完成一个完整的物联网应用的开发，建议您进入我们的[学习中心](https://haas.iot.aliyun.com/learning)进行学习。
diff --git a/haas_lib_bundles/python/docs/startup/HaaS200_startup.md b/haas_lib_bundles/python/docs/startup/HaaS200_startup.md
index c902f1429c..4eb7ac6feb 100644
--- a/haas_lib_bundles/python/docs/startup/HaaS200_startup.md
+++ b/haas_lib_bundles/python/docs/startup/HaaS200_startup.md
@@ -2,29 +2,23 @@
 &emsp;&emsp;
 HaaS200是高性价比的软硬件创新积木平台开发版，集成的是阿里云IoT团队自主研发的AliOS Things物联网操作系统。软件支持JS/Python轻应用和C/C++开发。本节则主要介绍如何烧录HaaS200 Python标准固件并在此基础上完成helloworld Python程序的运行。
 
-## HaaS200 Python固件
+## 一、HaaS Python固件下载
 
 &emsp;&emsp;
-HaaS200版本固件，请通过下面固件列表链接下载开发板对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
-```bash
+请从[HaaS Python版本历史](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/startup)下载HaaS200对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
+```
+bash
 ├── HaaSPython-HaaS200-{xxx}.bin     # HaaS Python官方固件，{xxx}为版本号
 └── littlefs.bin                     # 文件系统
 ```
 
-&emsp;&emsp;
-### HaaS200固件列表
-[HaaSPython-HaaS200-v2.1.0](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaS200-v2.1.0.zip)
-  * 版本更新说明（2022-04-24）
-    * HaaS轻应用标准升级到2.1
-    * 新增6个[HaaS200趣味案例](https://haas.iot.aliyun.com/solution)
 
-<br>
+## 二、安装HaaS-Studio开发工具
 
-## HaaS200开发环境准备
 &emsp;&emsp;
-将HaaS200用typeC USB数据线和电脑相连。
+HaaS Studio目前是以插件的形式安装在VS Code（Visual Studio Code）工具中，所以安装HaaS Studio之前需要先安装VS Code。
 
-#### 安装VS Code
+### 2.1 安装VS Code
 
 &emsp;&emsp;
 读者请到[微软官方网站](https://code.visualstudio.com/)上下载 VS Code 安装包并进行安装，VS Code安装包要求不低于版本 1.57。
@@ -38,7 +32,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 > 推荐 Windows 系统版本为 win10， MacOS 版本不低于 10.15。
 <br>
 
-#### 安装haas-studio插件
+### 2.2 安装haas-studio插件
 
 > 安装完 VS Code之后，windows用户请注意使用管理员权限打开(vscode插件会安装相关工具到C盘，需要管理员权限)
 
@@ -87,21 +81,26 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 <img src=../images/haas-studio-python-HaaS200_advance-enable.png width=40%/>
 </div>
 
-### HaaS200串口名称确认
-#### Windows系统
+## 三、固件烧录
+
+&emsp;&emsp;
+进行固件烧录前需要先确认开发板连接到电脑后对应的串口名称。
+
+### 3.1 串口名称确认
+#### 3.1.1 Windows系统
 
 &emsp;&emsp;
 读者请通过控制面板下的设备管理器，查询当前电脑下HaaS200插入后新增的端口。下图中显示HaaS200连接后新增的串口为“COM7”。
 > 注意：每台PC的串口可能都不一样，如果有多个串口，可以断开PC和HaaS200之间的连线，然后将PC和HaaS200相连，找到新增的那个串口。
 
-![HaaS200串口示意图](https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_EDU_K1_WINDOWS_COM.png)
+![HaaS200串口示意图](../images/1_HaaS_EDU_K1_WINDOWS_COM.png)
 
 &emsp;&emsp;
 如果连接HaaS200之前和之后，没有新增串口，则需要安装HaaS200的串口驱动，[请点我下载](https://www.silabs.com/documents/public/software/CP210x_Universal_Windows_Driver.zip)。
 
 <br>
 
-#### MAC系统
+#### 3.1.2 MAC系统
 
 &emsp;&emsp;
 如果您的电脑是MAC系统，系统会自带HaaS200 UART驱动程序，无需单独安装。可以在命令行中通过如下命令查看HaaS200接到电脑之前和之后串口列表的差异确认HaaS200串口名称。
@@ -122,15 +121,14 @@ zsh: no matches found: /dev/tty.usb*
 
 <br>
 
-## 固件烧录过程
-
+### 3.2 使用HaaS Studio进行固件烧录
 &emsp;&emsp;
 烧录此固件需使用HaaS-Studio集成开发环境。
 
 <br>
 1. 点击“快速开始”按钮后选择“烧录工具”按钮。如下图所示。
 <div align="center">
-<img src=../images/HaaS200startup_HaaS_Studio_固件烧录.png width=75%/>
+<img src=../images/1_HaaS_Studio_固件烧录.png width=75%/>
 </div>
 2. 选择好HaaS200对应的“串口名字” <br>
 3. 选择固件所在路径（上面“固件下载”步骤中解压出来的名为HaaSPython-HaaS200-{xxx}.bin的文件） <br>
@@ -142,7 +140,7 @@ zsh: no matches found: /dev/tty.usb*
 > 如果“串口名字”下拉框中没有正确的串口号，可以拔插HaaS200的USB口后，点击“刷新”按钮刷新串口列表。
 
 <div align="center">
-<img src=../images/HaaS_Studio_固件烧录_HaaS200_开始烧录.png width=75%/>
+<img src=../images/haas-studio-firmware-burn.png width=85%/>
 </div>
 
 &emsp;&emsp;
@@ -169,13 +167,13 @@ Packet End >>>
 <<< 0x6
 File: ymodem_burn_xz.bin
 Size: 970676Bytes
-11 0x3ff000 
+11 0x3ff000
 
 yxy ota_patch_write_param successes
 
 
 
-Recv flash addr: 0x00214000, len:0x000ecfb4 OK 
+Recv flash addr: 0x00214000, len:0x000ecfb4 OK
 
 ......
 
@@ -198,7 +196,7 @@ Size: 684032Bytes
 Swap AB partition
 
 
-Recv flash addr: 0x00354000, len:0x000a7000 OK 
+Recv flash addr: 0x00354000, len:0x000a7000 OK
 
 ...
 
@@ -228,7 +226,7 @@ sram test successfully
 &emsp;&emsp;
 经过上面的步骤HaaS Python固件就烧录到HaaS200开发板中去了。
 
-### 固件版本确认
+### 3.3 固件版本确认
 &emsp;&emsp;
 固件烧录完成后，如何确认固件真的有更新到硬件中呢？可以通过如下的方法确认：
 
@@ -249,9 +247,9 @@ sram test successfully
 
 > MACOS建议使用picocom串口工具；Windows系统推荐使用Putty串口工具。
 
-## HaaS200 helloworld例程
+## 四、运行helloworld例程
 
-### 创建helloworld工程
+### 4.1 创建helloworld工程
 &emsp;&emsp;
 请遵循如下的步骤完成helloworld Python工程的创建。
 
@@ -259,33 +257,38 @@ sram test successfully
 如下图所示，点击HaaS Studio的"快速开始"按键会弹出HaaS Studio的欢迎页面，请选择“创建项目”，如下图所示：
 
 <div align="center">
-<img src=../images/HaaS200startup_HaaS_Studio_创建项目向导.png width=80%/>
+<img src=../images/1_HaaS_Studio_创建项目向导.png width=80%/>
 </div>
 
 &emsp;&emsp;
 根据创建工程向导，开发者输入/选择相关的信息即可。下面以在HaaS200上面创建hellworld示例程序为例演示工程进行，步骤如下:
 > 注意事项： 文件夹不要有`中文，空格及其他异常`字符。
 
-1. 输入项目名称
-2. 选择工作区所在路径
-3. 选择硬件类型
-4. 选择编程语言
-5. 选择解决方案模板
+1. 选中“HaaS200”开发板，右侧会更新相应的案例列表
+2. 选择helloworld案例，点击创建。
+
 <div align="center">
-<img src=../images/HaaS200_创建工程向导.png width=50%/>
+<img src=../images/haas-studio-创建工程-选择helloworld.png width=80%/>
 </div>
-&emsp;&emsp;
-然后点击“立即创建”按钮，在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
 
+&emsp;&emsp;
+填入项目名称，以及项目工作路径后点击确定。
+&emsp;&emsp;
 <div align="center">
-<img src=../images/HaaS200startup_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+<img src=../images/haas-studio-创建工程向导.png width=40%/>
 </div>
 
+&emsp;&emsp;
+在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
+
+<div align="center">
+<img src=../images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+</div>
 
-### 推送脚本到设备
+### 4.2 推送脚本到设备
 
 &emsp;&emsp;
-点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推送出脚本。
+点击HaaS-Studio的“部署运行”按钮（<img src=../images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推送出脚本。
 <div align="center">
 <img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
 </div>
@@ -335,7 +338,7 @@ helloworld
 ...
 ```
 
-### 例程Python脚本说明
+### 4.3 例程Python脚本说明
 
 &emsp;&emsp;
 helloworld工程中的main.py脚本内容如下，各行代码的功能请参考下面代码的注释。
@@ -353,10 +356,10 @@ if __name__ == '__main__':
 ```
 
 &emsp;&emsp;
-helloworld例程运行起来就说明HaaS Python开发环境安装好了。接下来是对公测案例的说明。
+helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 
 &emsp;&emsp;
-快速入门完成之后，建议您进入我们的[趣味案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
+快速入门完成之后，建议您进入我们的[创意案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
 
 &emsp;&emsp;
 如果您想了解如何从浅到深完成一个完整的物联网应用的开发，建议您进入我们的[学习中心](https://haas.iot.aliyun.com/learning)进行学习。
diff --git a/haas_lib_bundles/python/docs/startup/HaaS506_startup.md b/haas_lib_bundles/python/docs/startup/HaaS506_startup.md
index 7080d5a160..349b56dd04 100644
--- a/haas_lib_bundles/python/docs/startup/HaaS506_startup.md
+++ b/haas_lib_bundles/python/docs/startup/HaaS506_startup.md
@@ -1,7 +1,7 @@
 # HaaS506 快速开始
 &emsp;&emsp;
 HaaS 506开发板是一款经过阿里云HaaS团队认证的高性能、多连接的物联网开发板。本文将从硬件介绍、固件更新、开发环境搭建以及案例验证等多方面为开发者提供详细的快速上手教程。
-请开发者们认证查阅，如有疑问或需技术支持，可用钉钉扫描开发板背面的二维码加入我们的技术支持群，您的提问都将会得到完善的答复。 
+请开发者们认证查阅，如有疑问或需技术支持，可用钉钉扫描开发板背面的二维码加入我们的技术支持群，您的提问都将会得到完善的答复。
 
 ## 一、硬件介绍
 &emsp;&emsp;
@@ -32,31 +32,12 @@ HaaS 506开发板在出厂时已经烧录了最新的固件，但由于固件一
     └── ChangeNotes.txt             # 更新日志
 ```
 
-### HaaS506固件包列表列表
-
-* [HaaS506-v2.01](https://hli.aliyuncs.com/o/config/haas506/HaaS506_v2.01.zip)
-  * 版本更新说明（2022-03-15）
-    * 添加network设置apn，username，password等信息
-    * 解决dataCall中sim卡检测时无论什么情况都判对的bug
-    * 解决sntp多次调用时导致，socket不够的情况
-    * 解决下载代码时，设备返回ide成功与否信息
-    * 添加uos模块支持version version_info方法
-    * 修改spi接口对接readAfterWrite支持bytearray方式
-
-* [HaaS506-v1.17](https://hli.aliyuncs.com/o/config/haas506/haas506.zip)
-
-  <details>
-  <summary>版本更新说明（2021-12-03）</summary>
-
-  * 动态生成QSTR功能
-  * UART增加on/any函数
-  * aliyunIoT修复内存泄漏及postProp返回值问题
-  * 修复部分BUG
-  </details>
+### 2.1 HaaS506固件包列表列表
+HaaS506 HaaS Python固件版本历史列表请参考[链接](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/startup)。建议你使用最新的固件，固件版本查询方法请参考本文中“固件版本确认”小节的说明。
 
 <br>
 
-### 安装USB烧录驱动
+### 2.2 安装USB烧录驱动
 1、下载[USB烧录驱动](https://hli.aliyuncs.com/o/config/usb_driver/8910_module_usb_driver_20191011_signed.7z)并解压，解压后目录结构如下，请选择您的操作系统类型对应的.exe文件进行烧录驱动的安装。
 ```bash
 ├── 20210708
@@ -82,7 +63,7 @@ USB烧录驱动安装完成后，当**连接HaaS506的USB**接口后，Windows
 ├── Release notes.xls
 ```
 
-### 烧录固件
+### 2.3 烧录固件
 
 1、打开UpgradeDownload.exe烧录软件。<br>
 2、点击软件左上角第一个“Load packet”选项选择所要烧录HaaS Python固件（以.pac为后缀的文件）。<br>
@@ -100,7 +81,7 @@ USB烧录驱动安装完成后，当**连接HaaS506的USB**接口后，Windows
 
 ## 三、搭建开发环境
 
-### PC环境准备
+### 3.1 PC环境准备
 &emsp;&emsp;
 用**USB转UART模块**连接HaaS506的**TTL串口**后，将USB转UART模块连接电脑的USB口。
 
@@ -110,11 +91,11 @@ USB烧录驱动安装完成后，当**连接HaaS506的USB**接口后，Windows
 * **HaaS506设备端GND** 接 **USB转UART模块的GND**<br>
 * **3.3V不要连接**
 
-### HaaS Studio安装
+### 3.2 HaaS Studio安装
 &emsp;&emsp;
 HaaS Studio目前是以插件的形式安装在VS Code（Visual Studio Code）工具中，所以安装HaaS Studio之前需要先安装VS Code。
 
-#### 安装VS Code
+#### 3.2.1 安装VS Code
 
 &emsp;&emsp;
 读者请到[微软官方网站](https://code.visualstudio.com/)上下载 VS Code 安装包并进行安装，VS Code安装包要求不低于版本 1.57。
@@ -128,7 +109,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 > 推荐 Windows 系统版本为 win10， MacOS 版本不低于 10.15。
 <br>
 
-#### 安装haas-studio插件
+#### 3.2.2 安装haas-studio插件
 
 > 安装完 VS Code之后，windows用户请注意使用管理员权限打开(vscode插件会安装相关工具到C盘，需要管理员权限)
 
@@ -138,7 +119,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 安装完 VS Code之后，请按照下图中数字的指示步骤完成haas-studio插件的安装。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_安装haas_studio_插件.png width=80%/>
+<img src=../images/1_安装haas_studio_插件.png width=80%/>
 </div>
 
 &emsp;&emsp;
@@ -152,14 +133,14 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 插件安装完成后，则 VSCode 左下角的状态栏会显示"快速开始"的图标，如下图所示。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-startup-page.png width=80%/>
+<img src=../images/haas-studio-startup-page.png width=80%/>
 </div>
 
 &emsp;&emsp;
 一般情况下，左下角只会显示快速开始图标，如果打开或者新建了某个Python工程，则会在VSCode底部的状态栏展开如下一排按钮，这些按钮的功能如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python工程按钮.png width=40%/>
+<img src=../images/1_HaaS_Studio_Python工程按钮.png width=40%/>
 </div>
 
 &emsp;&emsp;
@@ -178,8 +159,13 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 </div>
 
 
-### HaaS506串口名称确认
-#### Windows系统
+## 四、HaaS506固件烧录
+
+&emsp;&emsp;
+进行固件烧录前需要先确认开发板连接到电脑后对应的串口名称。
+
+### 4.1 HaaS506串口名称确认
+#### 4.1.1 Windows系统
 
 &emsp;&emsp;
 读者请通过设备管理器，查询当前电脑插入**USB转串口模块**后新增的端口（注意不是以`Unisoc Usb Serial Port`开头的固件烧录串口）。下图中显示HaaS506连接后新增的串口（笔者电脑中为COM20）。
@@ -193,9 +179,9 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 
 <br>
 
-## 四、HaaS506 HelloWord例程
+## 五、HaaS506 HelloWord例程
 
-### 创建helloworld工程
+### 5.1 创建helloworld工程
 &emsp;&emsp;
 请遵循如下的步骤完成helloworld Python工程的创建。
 
@@ -203,35 +189,39 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 如下图所示，点击HaaS Studio的"快速开始"按键会弹出HaaS Studio的欢迎页面，请选择“创建项目”，如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_创建项目向导.png width=60%/>
+<img src=../images/1_HaaS_Studio_创建项目向导.png width=80%/>
 </div>
 
 &emsp;&emsp;
-根据创建工程向导，开发者输入/选择相关的信息即可。下面以在HaaS EDU K1上面创建hellworld示例程序为例演示工程进行，步骤如下:
+根据创建工程向导，开发者输入/选择相关的信息即可。下面以在HaaS 506上面创建hellworld示例程序为例演示工程进行，步骤如下:
 > 注意事项： 文件夹不要有`中文，空格及其他异常`字符。
 
-1. 输入项目名称
-2. 选择工作区所在路径
-3. 选择硬件类型
-4. 选择编程语言
-5. 选择解决方案模板
+1. 选中“HaaS506”开发板，右侧会更新相应的案例列表
+2. 选择helloworld案例，点击创建。
+
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python创建工程_项目名称_HaaS506.png width=40%/>
+<img src=../images/haas-studio-创建工程-选择helloworld.png width=80%/>
 </div>
 
 &emsp;&emsp;
-然后点击“立即创建”按钮，在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
-
+填入项目名称，以及项目工作路径后点击确定。
+&emsp;&emsp;
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/4_2_HaaS_Studio_Python_helloworld_代码_HaaS506.png width=80%/>
+<img src=../images/haas-studio-创建工程向导.png width=40%/>
 </div>
 
+&emsp;&emsp;
+在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
+
+<div align="center">
+<img src=../images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+</div>
 ### 推送脚本到设备
 
 &emsp;&emsp;
 点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
 <div align="center">
-<img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
 </div>
 
 &emsp;&emsp;
@@ -282,7 +272,7 @@ helloworld
 ...
 ```
 
-### 例程Python脚本说明
+### 5.2 例程Python脚本说明
 
 &emsp;&emsp;
 helloworld工程中的main.py脚本内容如下，各行代码的功能请参考下面代码的注释。
@@ -303,7 +293,7 @@ if __name__ == '__main__':
 helloworld例程运行起来就说明HaaS Python开发环境安装好了。接下来是对公测案例的说明。
 
 &emsp;&emsp;
-快速入门完成之后，建议您进入我们的[趣味案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
+快速入门完成之后，建议您进入我们的[创意案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
 
 &emsp;&emsp;
 如果您想了解如何从浅到深完成一个完整的物联网应用的开发，建议您进入我们的[学习中心](https://haas.iot.aliyun.com/learning)进行学习。
@@ -317,7 +307,7 @@ helloworld例程运行起来就说明HaaS Python开发环境安装好了。接
 
 
 
-### 查看系统日志
+### 六、 查看系统日志
 
 * 用USB转UART模块连接HaaS506的**TTL串口**后，将USB转UART模块连接电脑的USB口。
 
diff --git a/haas_lib_bundles/python/docs/startup/HaaSPython_2.0_detail.md b/haas_lib_bundles/python/docs/startup/HaaSPython_2.0_detail.md
new file mode 100644
index 0000000000..5734d7a626
--- /dev/null
+++ b/haas_lib_bundles/python/docs/startup/HaaSPython_2.0_detail.md
@@ -0,0 +1,1 @@
+![查看详情](../images/HaaSPython_2.0_detail.png)
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/startup/HaaSPython_2.1_detail.md b/haas_lib_bundles/python/docs/startup/HaaSPython_2.1_detail.md
new file mode 100644
index 0000000000..68bd71425e
--- /dev/null
+++ b/haas_lib_bundles/python/docs/startup/HaaSPython_2.1_detail.md
@@ -0,0 +1,1 @@
+![查看详情](../images/HaaSPython_2.1_detail.png)
diff --git a/haas_lib_bundles/python/docs/startup/HaaSPython_2.2_detail.md b/haas_lib_bundles/python/docs/startup/HaaSPython_2.2_detail.md
new file mode 100644
index 0000000000..90205f87d1
--- /dev/null
+++ b/haas_lib_bundles/python/docs/startup/HaaSPython_2.2_detail.md
@@ -0,0 +1,2 @@
+
+![查看详情](../images/HaaSPython_2.2_detail.png)
\ No newline at end of file
diff --git a/haas_lib_bundles/python/docs/startup/HaaS_EDU_K1_startup.md b/haas_lib_bundles/python/docs/startup/HaaS_EDU_K1_startup.md
index f64753aac4..0c3cb75f1b 100644
--- a/haas_lib_bundles/python/docs/startup/HaaS_EDU_K1_startup.md
+++ b/haas_lib_bundles/python/docs/startup/HaaS_EDU_K1_startup.md
@@ -5,58 +5,22 @@ HaaS EDU K1 是一款专用于物联网教育的开发套件，整体配置的
 &emsp;&emsp;
 HaaS EDU K1支持使用C/C++、Python和JavaScript语言进行开发。本节则主要介绍如何烧录HaaS EDU K1 Python标准固件并在此基础上完成helloworld Python程序的运行。
 
-## HaaS EDU K1 Python固件下载
+## 一、HaaS Python固件下载
 
 &emsp;&emsp;
-请通过下面固件列表链接下载开发板对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
+请从[HaaS Python版本历史](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/startup)下载HaaS EDU K1对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
 ```bash
 ├── HaaSPython-HaaSEDUK1-{xxx}.bin   # HaaS Python官方固件，{xxx}为版本号
 └── littlefs.bin                     # 文件系统
 ```
 
-&emsp;&emsp;
-### HaaS EDU K1固件列表
-* [HaaSPython-HaaSEDUK1-v2.0.0](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-HaaSEDUK1-v2.0.0.zip)
-  * 版本更新说明（2022-04-10）
-    * HaaS轻应用标准升级到2.0（AliyunIoT增加文件上传功能，Driver SPI API增加多字节连续读写，AI，UI等能力）
-    * 新增30+[传感器](https://haas.iot.aliyun.com/solution/hardware)支持
-    * 新增30+[趣味案例](https://haas.iot.aliyun.com/solution)
-
-* [HaaSPython-HaaSEDUK1-v1.0.2](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-HaaSEDUK1-v1.0.2.zip)
-
-  <details>
-  <summary>版本更新说明（2022-01-20）</summary>
-
-  * 开源HaaS EDU K1教育案例 [开源链接](https://gitee.com/haasedu/haasedu/blob/master/HaaS_EDU_K1_%E5%9C%BA%E6%99%AF%E6%A1%88%E4%BE%8B%E9%9B%86%E9%94%A6.md)
-  * 新增5个趣味案例
-    * [甲醛浓度检测系统](https://haas.iot.aliyun.com/solution/detail/solution?versionId=800A17B751A65A4800000002&dataId=800A17B751A65A48)
-    * [起夜灯](https://haas.iot.aliyun.com/solution/detail/solution?versionId=800A582C35A56CD500000001&dataId=800A582C35A56CD5)
-    * [燃气检测系统](https://haas.iot.aliyun.com/solution/detail/solution?versionId=800A6E925AC06A9300000001&dataId=800A6E925AC06A93)
-    * [花卉养植系统](https://haas.iot.aliyun.com/solution/detail/solution?versionId=800AC5B00B951C5300000001&dataId=800AC5B00B951C53)
-    * [火焰检测系统](https://haas.iot.aliyun.com/solution/detail/solution?versionId=800AC9C2BDF9CEC100000001&dataId=800AC9C2BDF9CEC1)
-
-  </details>
-
-* [HaaSPython-HaaSEDUK1-v1.0.1](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaSEDUK1-1.0.1.zip)
-
-  <details>
-  <summary>版本更新说明（2022-01-13）</summary>
-
-  * 对齐到HaaS Python 2.0 API标准
-
-  </details>
-
 <br>
 
-## HaaS EDU K1开发环境准备
-&emsp;&emsp;
-将HaaS EDU K1用TypeC数据线和电脑相连。
-
-### HaaS Studio安装
+## 二、安装HaaS-Studio开发工具
 &emsp;&emsp;
 HaaS Studio目前是以插件的形式安装在VS Code（Visual Studio Code）工具中，所以安装HaaS Studio之前需要先安装VS Code。
 
-#### 安装VS Code
+### 2.1 安装VS Code
 
 &emsp;&emsp;
 读者请到[微软官方网站](https://code.visualstudio.com/)上下载 VS Code 安装包并进行安装，VS Code安装包要求不低于版本 1.57。
@@ -70,7 +34,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 > 推荐 Windows 系统版本为 win10， MacOS 版本不低于 10.15。
 <br>
 
-#### 安装haas-studio插件
+### 2.2 安装haas-studio插件
 
 > 安装完 VS Code之后，windows用户请注意使用管理员权限打开(vscode插件会安装相关工具到C盘，需要管理员权限)
 
@@ -80,7 +44,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 安装完 VS Code之后，请按照下图中数字的指示步骤完成haas-studio插件的安装。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_安装haas_studio_插件.png width=80%/>
+<img src=../images/1_安装haas_studio_插件.png width=80%/>
 </div>
 
 &emsp;&emsp;
@@ -94,14 +58,14 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 插件安装完成后，则 VSCode 左下角的状态栏会显示"快速开始"的图标，如下图所示。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-startup-page.png width=80%/>
+<img src=../images/haas-studio-startup-page.png width=80%/>
 </div>
 
 &emsp;&emsp;
 一般情况下，左下角只会显示快速开始图标，如果打开或者新建了某个Python工程，则会在VSCode底部的状态栏展开如下一排按钮，这些按钮的功能如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python工程按钮.png width=40%/>
+<img src=../images/1_HaaS_Studio_Python工程按钮.png width=40%/>
 </div>
 
 &emsp;&emsp;
@@ -119,8 +83,14 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-python-advance-enable.png width=40%/>
 </div>
 
-### HaaS EDU K1串口名称确认
-#### Windows系统
+## 三、HaaS EDU K1固件烧录
+
+&emsp;&emsp;
+进行固件烧录前需要先确认开发板连接到电脑后对应的串口名称。首先需要将HaaS EDU K1用Type-C数据线和电脑相连。
+
+
+### 3.1 串口名称确认
+#### 3.1.1 Windows系统
 
 &emsp;&emsp;
 读者请通过控制面板下的设备管理器，查询当前电脑下HaaS EDU K1插入后新增的端口。下图中显示HaaS EDUK1连接后新增的串口为“COM7”。
@@ -133,7 +103,7 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 
 <br>
 
-#### MAC系统
+#### 3.1.2 MAC系统
 
 &emsp;&emsp;
 如果您的电脑是MAC系统，系统会自带HaaS EDU K1 UART驱动程序，无需单独安装。可以在命令行中通过如下命令查看HaaS EDU K1接到电脑之前和之后串口列表的差异确认HaaS EDU K1串口名称。
@@ -154,15 +124,11 @@ zsh: no matches found: /dev/tty.usb*
 
 <br>
 
-## 固件烧录过程
+### 3.2 使用HaaS Studio进行固件烧录
 
-&emsp;&emsp;
-烧录此固件需使用HaaS-Studio集成开发环境。
-
-<br>
-1. 点击“快速开始”按钮后选择“烧录工具”按钮。如下图所示。
+1. 点击HaaS-Studio“快速开始”按钮后选择“烧录工具”按钮。如下图所示。
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_固件烧录.png width=75%/>
+<img src=../images/1_HaaS_Studio_固件烧录.png width=75%/>
 </div>
 2. 选择好HaaS EDU K1对应的“串口名字” <br>
 3. 选择固件所在路径（上面“固件下载”步骤中解压出来的名为HaaSPython-HaaS-EDU-K1-{xxx}.bin的文件） <br>
@@ -174,7 +140,7 @@ zsh: no matches found: /dev/tty.usb*
 > 如果“串口名字”下拉框中没有正确的串口号，可以拔插HaaS EDU K1的USB口后，点击“刷新”按钮刷新串口列表。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-firmware-burn.png width=85%/>
+<img src=../images/haas-studio-firmware-burn.png width=85%/>
 </div>
 
 &emsp;&emsp;
@@ -226,7 +192,7 @@ Burn "[('/Users/xxx/Downloads/HaaSPython-HaaSEDUK1/HaaSPython-HaaSEDUK1-1.0.1.bi
 &emsp;&emsp;
 经过上面的步骤HaaS Python固件就烧录到HaaS EDU K1开发板中去了。
 
-### 固件版本确认
+### 3.3 固件版本确认
 &emsp;&emsp;
 固件烧录完成后，如何确认固件真的有更新到硬件中呢？可以通过如下的方法确认：
 
@@ -247,9 +213,9 @@ Burn "[('/Users/xxx/Downloads/HaaSPython-HaaSEDUK1/HaaSPython-HaaSEDUK1-1.0.1.bi
 
 > MACOS建议使用picocom串口工具；Windows系统推荐使用Putty串口工具。
 
-## HaaS EDU K1 helloworld例程
+## 四、运行helloworld例程
 
-### 创建helloworld工程
+### 4.1 创建helloworld工程
 &emsp;&emsp;
 请遵循如下的步骤完成helloworld Python工程的创建。
 
@@ -257,36 +223,41 @@ Burn "[('/Users/xxx/Downloads/HaaSPython-HaaSEDUK1/HaaSPython-HaaSEDUK1-1.0.1.bi
 如下图所示，点击HaaS Studio的"快速开始"按键会弹出HaaS Studio的欢迎页面，请选择“创建项目”，如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_创建项目向导.png width=60%/>
+<img src=../images/1_HaaS_Studio_创建项目向导.png width=80%/>
 </div>
 
 &emsp;&emsp;
 根据创建工程向导，开发者输入/选择相关的信息即可。下面以在HaaS EDU K1上面创建hellworld示例程序为例演示工程进行，步骤如下:
 > 注意事项： 文件夹不要有`中文，空格及其他异常`字符。
 
-1. 输入项目名称
-2. 选择工作区所在路径
-3. 选择硬件类型
-4. 选择编程语言
-5. 选择解决方案模板
+1. 选中“HaaS EDU K1”开发板，右侧会更新相应的案例列表
+2. 选择helloworld案例，点击创建。
+
+<div align="center">
+<img src=../images/haas-studio-创建工程-选择helloworld.png width=80%/>
+</div>
+
+&emsp;&emsp;
+填入项目名称，以及项目工作路径后点击确定。
+&emsp;&emsp;
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python创建工程_项目名称_HaaSEDUK1.png width=40%/>
+<img src=../images/haas-studio-创建工程向导.png width=40%/>
 </div>
 
 &emsp;&emsp;
-然后点击“立即创建”按钮，在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
+在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python_helloworld_代码_HaaS_EDU_K1.png width=80%/>
+<img src=../images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
 </div>
 
 
-### 推送脚本到设备
+### 4.2 推送脚本到设备
 
 &emsp;&emsp;
 点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
 <div align="center">
-<img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
 </div>
 
 &emsp;&emsp;
@@ -337,7 +308,7 @@ helloworld
 ...
 ```
 
-### 例程Python脚本说明
+### 4.3 例程Python脚本说明
 
 &emsp;&emsp;
 helloworld工程中的main.py脚本内容如下，各行代码的功能请参考下面代码的注释。
@@ -358,7 +329,7 @@ if __name__ == '__main__':
 helloworld例程运行起来就说明HaaS Python开发环境安装好了。接下来是对公测案例的说明。
 
 &emsp;&emsp;
-快速入门完成之后，建议您进入我们的[趣味案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
+快速入门完成之后，建议您进入我们的[创意案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
 
 &emsp;&emsp;
 如果您想了解如何从浅到深完成一个完整的物联网应用的开发，建议您进入我们的[学习中心](https://haas.iot.aliyun.com/learning)进行学习。
@@ -369,7 +340,7 @@ helloworld例程运行起来就说明HaaS Python开发环境安装好了。接
 &emsp;&emsp;
 如果您想看HaaS Python都提供哪些库和API，请点击左侧导航栏查看。
 
-## HaaS EDU K1扩展接口图
+## 五、HaaS EDU K1扩展接口图
 &emsp;&emsp;
 HaaS Python固件刷入HaaS EDU K1开发版之后，开发板端口详细定义及说明请参考下图：
 
diff --git a/haas_lib_bundles/python/docs/startup/M5StackCore2_startup.md b/haas_lib_bundles/python/docs/startup/M5StackCore2_startup.md
index 3d02aabb16..26fc29f63d 100644
--- a/haas_lib_bundles/python/docs/startup/M5StackCore2_startup.md
+++ b/haas_lib_bundles/python/docs/startup/M5StackCore2_startup.md
@@ -5,44 +5,20 @@ M5StackCore2是开源世界中被开发者普遍使用的开发板，在M5StackC
 &emsp;&emsp;
 本文则主要介绍如何烧录M5Stack HaaS标准固件并在此基础上完成helloworld Python程序的运行。
 
-## M5StackCore2 HaaS固件下载
-
+## 一、HaaS Python固件下载
 &emsp;&emsp;
-请通过下面固件列表链接下载开发板对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
+请从[HaaS Python版本历史](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/startup)下载M5Stack Core2对应的固件压缩包并解压，解压完成后可以看到其目录结构如下：
 ```
 ├── HaaSPython-ESP32-8M-{xxx}.bin   # HaaS官方固件，{xxx}为版本号
 ```
-&emsp;&emsp;
-### HaaS Python M5StackCore2标准固件列表
-* [HaaSPython-ESP32-8M-v2.0.0](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-8M-v2.0.0.zip)
-  * 版本更新说明（2022-04-10）
-    * HaaS轻应用标准升级到2.0（AliyunIoT增加文件上传功能，Driver SPI API增加多字节连续读写，AI，UI等能力）
-    * 新增[ESP32乐鑫官方开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C9562896F994200000001&dataId=800C9562896F9942)和[01Studio ESP32开发板](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C55C67883087B00000001&dataId=800C55C67883087B)支持
-    * 新增30+[传感器](https://haas.iot.aliyun.com/solution/hardware)支持
-    * 新增30+[趣味案例](https://haas.iot.aliyun.com/solution)
-    * 新增3个精美UI模板（带UI能力开发板）
-    * 新增9种AI聚合服务（带UI和AI能力开发板）
-
-* [HaaSPython-ESP32-8M-v1.0.3](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-8M-opentest.zip)
 
-  <details>
-  <summary>版本更新说明（2022-01-13）</summary>
 
-  * ESP32平台新增HaaS AI能力
-  * ESP32平台新增HaaS UI Lite能力
-  * ESP32平台新增Audio案例
+## 二、安装HaaS-Studio开发工具
 
-  </details>
-
-## M5StackCore2开发环境准备
-&emsp;&emsp;
-将M5StackCore2开发板用USB Type-C数据线和电脑USB口相连。
-
-### HaaS Studio安装
 &emsp;&emsp;
 HaaS Studio目前是以插件的形式安装在VS Code（Visual Studio Code）工具中，所以安装HaaS Studio之前需要先安装VS Code。
 
-#### 安装VS Code
+### 2.1 安装VS Code
 
 &emsp;&emsp;
 读者请到[微软官方网站](https://code.visualstudio.com/)上下载 VS Code 安装包并进行安装，VS Code安装包要求不低于版本 1.57。
@@ -56,7 +32,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 > 推荐 Windows 系统版本为 win10， MacOS 版本不低于 10.15。
 <br>
 
-#### 安装haas-studio插件
+### 2.2 安装haas-studio插件
 
 > 安装完 VS Code之后，windows用户请注意使用管理员权限打开(vscode插件会安装相关工具到C盘，需要管理员权限)
 
@@ -66,7 +42,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 安装完 VS Code之后，请按照下图中数字的指示步骤完成haas-studio插件的安装。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_安装haas_studio_插件.png width=80%/>
+<img src=../images/1_安装haas_studio_插件.png width=80%/>
 </div>
 
 &emsp;&emsp;
@@ -80,14 +56,14 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 插件安装完成后，则 VSCode 左下角的状态栏会显示"快速开始"的图标，如下图所示。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-startup-page.png width=80%/>
+<img src=../images/haas-studio-startup-page.png width=80%/>
 </div>
 
 &emsp;&emsp;
 一般情况下，左下角只会显示快速开始图标，如果打开或者新建了某个Python工程，则会在VSCode底部的状态栏展开如下一排按钮，这些按钮的功能如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python工程按钮.png width=40%/>
+<img src=../images/1_HaaS_Studio_Python工程按钮.png width=40%/>
 </div>
 
 &emsp;&emsp;
@@ -105,12 +81,13 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-python-advance-enable.png width=40%/>
 </div>
 
+## 三、固件烧录
 
-### M5StackCore2串口名称确认
 &emsp;&emsp;
-进行下面操作前请务必确认PC和M5StackCore2开发板之间连接用的是USB转Type-C类型的数据线，而非`Type-C的延长线`。`Type-C的延长线会导致电脑没办法正常识别M5StackCore2的串口`。
+进行固件烧录前需要先确认开发板连接到电脑后对应的串口名称。
 
-#### Windows系统
+### 3.1 串口名称确认
+#### 3.1.1 Windows系统
 
 &emsp;&emsp;
 如果您的电脑是Windows系统，请通过控制面板下的设备管理器，查询当前电脑下M5StackCore2插入后新增的端口。下图中显示电脑连接M5StackCore2后新增的串口为“COM7”。
@@ -129,7 +106,7 @@ python高级模式打开之后，这些按钮的功能变成如下图所示：
 
 <br>
 
-#### MAC系统
+#### 3.1.2 MAC系统
 
 &emsp;&emsp;
 使用MAC系统的开发者`务必`下载MACOS的驱动并`严格按照驱动压缩包中的pdf说明文档`中的安装说明进行安装（MAC下驱动加载需要手动开启加载权限）。
@@ -161,13 +138,13 @@ zsh: no matches found: /dev/tty.wchusbserial*
 如果你的电脑在插入M5StackCore2之后出现名称为tty.wchusbserial<xxx>的串口则代表驱动安装成功了。如果电脑只识别到一个名为tty.usbmodem<xxxx>的串口，则代表驱动未安装成功，请寻求M5StackCore2官方旗舰店的客服的协助。
 > 注意：每台PC的串口可能都不一样，上面只是笔者电脑上面的串口信息。
 
-### 固件烧录过程
+### 3.2 使用HaaS Studio进行固件烧录
 &emsp;&emsp;
 烧录此固件需使用HaaS-Studio集成开发环境。
 
 1. 点击“快速开始”按钮后选择“烧录工具”按钮。如下图所示。
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_固件烧录.png width=75%/>
+<img src=../images/1_HaaS_Studio_固件烧录.png width=75%/>
 </div>
 1. 选择好M5StackCore2对应的“串口名字”和固件所在路径（上面“M5StackCore2 HaaS固件下载”步骤中解压出来的名为HaaSPython-ESP32-8M-{xxx}.bin的文件）之后点击“开始烧录”按钮，HaaS Studio便会将此固件烧录到开发板中，如下图所示。
 
@@ -176,7 +153,7 @@ zsh: no matches found: /dev/tty.wchusbserial*
 > 如果“串口名字”下拉框中没有正确的串口号，可以拔插M5StackCore2的USB口后，点击“刷新”按钮刷新串口列表。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/haas-studio-firmware-burn.png width=85%/>
+<img src=../images/haas-studio-firmware-burn.png width=85%/>
 </div>
 
 &emsp;&emsp;
@@ -217,7 +194,7 @@ Hard resetting via RTS pin...
 &emsp;&emsp;
 经过上面的步骤HaaS Python M5StackCore2固件就烧录到M5StackCore2开发板中去了。
 
-### 固件版本确认
+### 3.3 固件版本确认
 &emsp;&emsp;
 固件烧录完成后，如何确认固件真的有更新到硬件中呢？可以通过如下的方法确认：
 
@@ -231,9 +208,11 @@ Hard resetting via RTS pin...
 <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_版本号确认_M5StackCore2.png width=80%/>
 </div>
 
-## M5StackCore2 helloworld例程
+> 打开串口工具后，敲回车后如果未出现">>>"符号，则一般是因为您的开发板正在运行Python脚本。此时，可以同时按下Ctrl+C两个按键，尝试打断当前的python脚本。如果按很多次Ctrl+C之后仍然没有出现">>>"，则大概率是因为开发板运行的程序死机，可以尝试按住“Ctrl+C”再对开发板进行硬件复位。
+
+## 四、运行helloworld例程
 
-### 创建helloworld工程
+### 4.1 创建helloworld工程
 &emsp;&emsp;
 请遵循如下的步骤完成helloworld Python工程的创建。
 
@@ -241,31 +220,41 @@ Hard resetting via RTS pin...
 如下图所示，点击HaaS Studio的"快速开始"按键会弹出HaaS Studio的欢迎页面，请选择“创建项目”，如下图所示：
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_创建项目向导.png width=60%/>
+<img src=../images/1_HaaS_Studio_创建项目向导.png width=80%/>
 </div>
 
+
 &emsp;&emsp;
 根据创建工程向导，开发者输入/选择相关的信息即可。下面以在M5StackCore2上面创建hellworld示例程序为例演示工程进行，步骤如下:
 > 注意事项： 文件夹不要有中文，空格及其他异常字符。
 
-1. 输入项目名称
-2. 选择工作区所在路径
-3. 选择硬件类型
-4. 选择编程语言
-5. 选择解决方案模板
+1.1. 选中“M5Stack-Core2”开发板，右侧会更新相应的案例列表
+1. 选择helloworld案例，点击创建。
+
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python创建工程_项目名称_m5stackcore2.png width=40%/>
+<img src=../images/haas-studio-创建工程-选择helloworld.png width=80%/>
 </div>
 
 &emsp;&emsp;
-然后点击“立即创建”按钮，在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
+填入项目名称，以及项目工作路径后点击确定。
+&emsp;&emsp;
+<div align="center">
+<img src=../images/haas-studio-创建工程向导.png width=40%/>
+</div>
+
+&emsp;&emsp;
+在随后的步骤中确认输入的信息无误，点击“确认”，等待工程创建完成后，VS Code会自动打开新创建的工程。就可以在左侧的文件浏览页面中看到刚刚创建的helloworld工程。
+
+<div align="center">
+<img src=../images/1_HaaS_Studio_Python_helloworld_代码.png width=80%/>
+</div>
 
-### 推送脚本到设备
+### 4.2 推送脚本到设备
 
 &emsp;&emsp;
 点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
 <div align="center">
-<img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
 </div>
 
 &emsp;&emsp;
@@ -289,7 +278,7 @@ helloworld
 ...
 ```
 
-### 例程Python脚本说明
+### 4.3 例程Python脚本说明
 
 &emsp;&emsp;
 helloworld工程中的main.py脚本内容如下，各行代码的功能请参考下面代码的注释。
@@ -310,7 +299,7 @@ if __name__ == '__main__':
 helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 
 &emsp;&emsp;
-快速入门完成之后，建议您进入我们的[趣味案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
+快速入门完成之后，建议您进入我们的[创意案例专区](https://haas.iot.aliyun.com/solution)，快速体验更多有意思的案例。
 
 &emsp;&emsp;
 如果您想了解如何从浅到深完成一个完整的物联网应用的开发，建议您进入我们的[学习中心](https://haas.iot.aliyun.com/learning)进行学习。
@@ -322,7 +311,7 @@ helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 如果您想看HaaS Python都提供哪些库和API，请点击左侧导航栏查看。
 <br>
 
-## M5StackCore2扩展接口图
+## 五、M5StackCore2扩展接口图
 &emsp;&emsp;
 HaaS Python固件刷入M5StackCore2开发版之后，开发板端口详细定义及说明请参考下图：
 <div align="center">
diff --git a/haas_lib_bundles/python/docs/startup/VersionHistory.md b/haas_lib_bundles/python/docs/startup/VersionHistory.md
new file mode 100644
index 0000000000..90c5f69b6d
--- /dev/null
+++ b/haas_lib_bundles/python/docs/startup/VersionHistory.md
@@ -0,0 +1,24 @@
+# HaaS Python版本历史
+
+&emsp;&emsp;
+HaaS Python是阿里云IoT HaaS团队推出的HaaS物联网设备云端一体开发框架的重要组成部分。
+
+&emsp;&emsp;
+HaaS Python的目标是帮助中小开发者聚焦业务，实现设备安全上云，加速设备创新迭代，真正做到“Python也可以轻松开发智能设备”。
+
+&emsp;&emsp;
+本文主要介绍HaaS Python的固件版本信息。
+
+## HaaS Python版本列表
+
+
+|版本号|版本说明|固件下载链接|详细说明|
+|:-:|-|-|:-:|
+|v2.2<br>2022-05-30|HaaS Studio进阶版上线<br>新增6个传感器支持<br>新增15个创意案例<br>HaaS EDU K1支持彩色触摸屏<br>HaaS毕设计划启动<br>HaaS开源百校科技助力校园大使招募中<br>HaaS星案例征集火热进行中<br>HaaS合作伙伴计划全面启动|[HaaS EDU K1]()<br>[HaaS200]()<br>[HaaS506]()<br>[乐鑫 ESP32_DevKitC]()<br>[安信可 NodeMCU-32S]()<br>[01Studio pyWiFi-ESP32]()<br>[安信可 NodeMCU-ESP-S3-32S-Kit]()<br>[安信可 NodeMCU-ESP-C3-32S-Kit]()<br>[明栈 M5StackCore2]()<br>|<div align="center"><img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_2.0_overview_1.png width=150%/></div><br>[查看详情](https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_2.0_detail.png)|
+|v2.1<br>2022-04-30|HaaS Python标准升级到2.1<br>新增HaaS Python在线热更新功能<br>新增行为识别API<br>新增8款传感器（含工业类）<br>|[HaaS EDU K1](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaSEDUK1-v2.1.0.zip)<br>[HaaS200]()<br>[HaaS506]()<br>[乐鑫 ESP32_DevKitC](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v2.1.0.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v2.1.0.zip)<br>[01Studio pyWiFi-ESP32](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v2.1.0.zip)<br>[安信可 NodeMCU-ESP-S3-32S-Kit]()<br>[安信可 NodeMCU-ESP-C3-32S-Kit]()<br>[明栈 M5StackCore2](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-8M-v2.1.0.zip)<br>|<div align="center"><img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_2.1_overview_1.png width=100%/></div><br>[查看详情](https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_2.1_detail.png)|
+|v2.0<br>2022-05-30|HaaS Python标准升级到2.0<br>（新增AI，UI等能力、AliyunIoT增加文件上传功能，<br>Driver SPI API增加多字节连续读写）<br>新增ESP32乐鑫官方开发板和01Studio ESP32开发板支持<br>新增30+传感器支持<br>新增30+创意案例<br>新增3个精美UI模板（带UI能力开发板）<br>新增9种AI聚合服务（带UI和AI能力开发板）|[HaaS EDU K1](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-HaaSEDUK1-v2.0.0.zip)<br>[HaaS200](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaS200-v2.1.0.zip)<br>[HaaS506](https://hli.aliyuncs.com/o/config/haas506/HaaS506_v2.01.zip)<br>[乐鑫 ESP32_DevKitC](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-v2.0.0.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-v2.0.0.zip)<br>[01Studio pyWiFi-ESP32](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-v2.0.0.zip)<br>[明栈 M5StackCore2](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-8M-v2.0.0.zip)<br>|<div align="center"><img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_2.0_overview_1.png width=150%/></div><br>[查看详情](https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_2.0_detail.png)|
+|v1.0.2<br>2022-01-20|aliyunIoT库功能优化<br>新增开源HaaS EDU K1教育案例<br>新增5个创意案例|[HaaS EDU K1](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-HaaSEDUK1-v1.0.2.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-ESP32-v1.0.2.zip)|-|
+|v1.0.1<br>2022-01-13|动态生成QSTR功能<br>UART增加on/any函数<br>aliyunIoT修复内存泄漏及postProp返回值问题<br>修复部分BUG|[HaaS EDU K1](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaSEDUK1-1.0.1.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v1.0.1.zip)|-|
+|v1.0.2<br>2022-01-20|aliyunIoT库功能优化<br>新增开源HaaS EDU K1教育案例<br>新增5个创意案例|[HaaS EDU K1](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-HaaSEDUK1-v1.0.2.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-ESP32-v1.0.2.zip)|-|
+|v1.0.0<br>2021-12-30|新增ESP32开发板NodeMCU-32支持<br>新增HaaS小程序，方便快速体验数据上云功能<br>升级HaaS Studio - 精简IDE开发流程，支持固件一键烧写<br>兼容MicroPython v1.17<br>扩展BLE配网、OTA和Modbus等功能<br>优化ESP32 IDF内存分配机制|[安信可 NodeMCU-32S](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v1.0.1.zip)|-|
+|v0.2.0<br>2021-06-15|兼容MicroPython v1.17<br>支持快速连接阿里云物联网云平台（aliyunIoT）<br>扩展Driver、KV、http等功能|不推荐使用|-|
diff --git a/haas_lib_bundles/python/docs/startup/startup.md b/haas_lib_bundles/python/docs/startup/startup.md
new file mode 100644
index 0000000000..1f67e228bb
--- /dev/null
+++ b/haas_lib_bundles/python/docs/startup/startup.md
@@ -0,0 +1,102 @@
+# HaaS Python快速开始
+
+&emsp;&emsp;
+HaaS Python是阿里云IoT HaaS团队推出的HaaS物联网设备云端一体开发框架的重要组成部分。
+
+&emsp;&emsp;
+HaaS Python的目标是帮助中小开发者聚焦业务，实现设备安全上云，加速设备创新迭代，真正做到“Python也可以轻松开发智能设备”。
+
+## HaaS Python版本历史
+
+|版本号|版本说明|固件下载链接|详细说明|
+|:-:|-|-|:-:|
+|v2.2<br>2022-05-30|HaaS Studio进阶版上线<br>新增6个传感器支持<br>新增15个创意案例<br>HaaS EDU K1支持彩色触摸屏<br>HaaS毕设计划启动<br>HaaS开源百校科技助力校园大使招募中<br>HaaS星案例征集火热进行中<br>HaaS合作伙伴计划全面启动|[HaaS EDU K1](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaSEDUK1-v2.2.0.zip)<br>[HaaS200](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaS200-v2.2.0.zip)<br><br>[乐鑫 ESP32_DevKitC](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v2.2.0.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v2.2.0.zip)<br>[01Studio pyWiFi-ESP32](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v2.2.0.zip)<br>[安信可 NodeMCU-ESP-S3-32S-Kit](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP-S3-12K-Kit-v2.2.0.zip)<br>[安信可 NodeMCU-ESP-C3-32S-Kit](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP-C3-32S-Kit-v2.2.0.zip)<br>[明栈 M5StackCore2](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-8M-v2.2.0.zip)<br>| <div align="center"> <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_2.2_overview_1.png width=30%/></div> <br>[查看详情](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/HaaSPython_2.2_detail)|
+|v2.1<br>2022-04-30|HaaS Python标准升级到2.1<br>新增HaaS Python在线热更新功能<br>新增行为识别API<br>新增8款传感器（含工业类）<br>|[HaaS EDU K1](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaSEDUK1-v2.1.0.zip)<br>[HaaS200](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaS200-v2.1.0.zip)<br>[HaaS506](https://hli.aliyuncs.com/o/config/haas506/HaaS506_v2.01.zip)<br>[乐鑫 ESP32_DevKitC](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v2.1.0.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v2.1.0.zip)<br>[01Studio pyWiFi-ESP32](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v2.1.0.zip)<br>[安信可 NodeMCU-ESP-S3-32S-Kit]()<br>[安信可 NodeMCU-ESP-C3-32S-Kit]()<br>[明栈 M5StackCore2](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-8M-v2.1.0.zip)<br>|<div align="center"><img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_2.1_overview_1.png width=30%/></div><br>[查看详情](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/HaaSPython_2.1_detail)|
+
+<details>
+<summary> 更多历史版本 </summary>
+
+|版本号|版本说明|固件连接|详细说明|
+|:-:|-|-|:-:|
+|v2.0<br>2022-05-30|HaaS Python标准升级到2.0<br>（新增AI，UI等能力、AliyunIoT增加文件上传功能，<br>Driver SPI API增加多字节连续读写）<br>新增ESP32乐鑫官方开发板和01Studio ESP32开发板支持<br>新增30+传感器支持<br>新增30+创意案例<br>新增3个精美UI模板（带UI能力开发板）<br>新增9种AI聚合服务（带UI和AI能力开发板）|[HaaS EDU K1](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-HaaSEDUK1-v2.0.0.zip)<br>[HaaS200](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaS200-v2.1.0.zip)<br>[HaaS506](https://hli.aliyuncs.com/o/config/haas506/HaaS506_v2.01.zip)<br>[乐鑫 ESP32_DevKitC](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-v2.0.0.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-v2.0.0.zip)<br>[01Studio pyWiFi-ESP32](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-v2.0.0.zip)<br>[明栈 M5StackCore2](https://hli.aliyuncs.com/o/config/HaaSPython/HaaSPython-ESP32-8M-v2.0.0.zip)<br>|<div align="center"><img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/HaaSPython_2.0_overview_1.png width=200%/></div><br>[查看详情](https://haas.iot.aliyun.com/haasapi/index.html?#/Python/docs/zh-CN/startup/HaaSPython_2.0_detail)|
+|v1.0.2<br>2022-01-20|aliyunIoT库功能优化<br>新增开源HaaS EDU K1教育案例<br>新增5个创意案例|[HaaS EDU K1](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-HaaSEDUK1-v1.0.2.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-ESP32-v1.0.2.zip)|-|
+|v1.0.1<br>2022-01-13|动态生成QSTR功能<br>UART增加on/any函数<br>aliyunIoT修复内存泄漏及postProp返回值问题<br>修复部分BUG|[HaaS EDU K1](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-HaaSEDUK1-1.0.1.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v1.0.1.zip)|-|
+|v1.0.2<br>2022-01-20|aliyunIoT库功能优化<br>新增开源HaaS EDU K1教育案例<br>新增5个创意案例|[HaaS EDU K1](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-HaaSEDUK1-v1.0.2.zip)<br>[安信可 NodeMCU-32S](https://hli.aliyuncs.com/p/config/HaaS_Python/HaaSPython-ESP32-v1.0.2.zip)|-|
+|v1.0.0<br>2021-12-30|新增ESP32开发板NodeMCU-32支持<br>新增HaaS小程序，方便快速体验数据上云功能<br>升级HaaS Studio - 精简IDE开发流程，支持固件一键烧写<br>兼容MicroPython v1.17<br>扩展BLE配网、OTA和Modbus等功能<br>优化ESP32 IDF内存分配机制|[安信可 NodeMCU-32S](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-ESP32-v1.0.1.zip)|-|
+|v0.2.0<br>2021-06-15|兼容MicroPython v1.17<br>支持快速连接阿里云物联网云平台（aliyunIoT）<br>扩展Driver、KV、http等功能|不推荐使用|-|
+
+</details>
+
+&emsp;&emsp;
+接下来看看如何<font size = 5, color=red>三步快速开启你的HaaS Python之旅</font>吧。
+
+<div align="center">
+<img src=../images/HaaSPython_快速开始_overview.png width=70%/>
+</div>
+
+## 一、选择你的开发板
+
+&emsp;&emsp;
+目前HaaS Python支持如下几种开发板，如果你手上还没有如下开发板，可以从下表按照你的需求进行开发板的选择。
+
+|硬件系列|开发板介绍|开发板特点|开发板快速开始|
+|-|-|-|-|
+|HaaS EDU K1|[HaaS EDU K1](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C5AB3B8A4A88800000001&dataId=800C5AB3B8A4A888)|蓝牙/Wi-Fi<br>内置OLED与多款传感器<br>物联网学习首选|[链接](https://haas.iot.aliyun.com/haasapi/index.html?spm=a2cpu.b17074837.0.0.66e960b1YtzRuv#/Python/docs/zh-CN/startup/HaaS_EDU_K1_startup)|
+|HaaS506|[煜瑛 HaaS506](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800CF06E76DC612F00000001&dataId=800CF06E76DC612F)|4G CAT.1|[链接](https://haas.iot.aliyun.com/haasapi/index.html?spm=a2cpu.b17074837.0.0.66e960b1YtzRuv#/Python/docs/zh-CN/startup/HaaS506_startup)|
+|HaaS200|[翼数 HaaS200](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C8F815768381600000001&dataId=800C8F8157683816)|蓝牙/Wi-Fi|[链接](https://haas.iot.aliyun.com/haasapi/index.html?spm=a2cpu.b17074837.0.0.66e960b1YtzRuv#/Python/docs/zh-CN/startup/HaaS200_startup)|
+|ESP32开发板|[乐鑫 ESP32_DevKitC](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C9562896F994200000001&dataId=800C9562896F9942)<br>[安信可 NodeMCU-32S](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C0A5C37AADCDB00000001&dataId=800C0A5C37AADCDB)<br>[01Studio pyWiFi-ESP32](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C55C67883087B00000001&dataId=800C55C67883087B)|蓝牙/Wi-Fi|[链接](https://haas.iot.aliyun.com/haasapi/index.html?spm=a2cpu.b17074837.0.0.66e960b1YtzRuv#/Python/docs/zh-CN/startup/ESP32_startup)|
+|ESP32-S3开发板|[安信可 NodeMCU-ESP-S3-32S-Kit](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C860464C2A53800000001&dataId=800C860464C2A538)|本地AI能力<br>蓝牙/Wi-Fi<br>|[链接](https://haas.iot.aliyun.com/haasapi/index.html?spm=a2cpu.b17074837.0.0.66e960b1YtzRuv#/Python/docs/zh-CN/startup/ESP-S3-12K-Kit_startup)|
+|ESP32-C3开发板|[安信可 NodeMCU-ESP-C3-32S-Kit](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800CC0B0F588AC3100000001&dataId=800CC0B0F588AC31)|RISC-V <br> 蓝牙/Wi-Fi|[链接](https://haas.iot.aliyun.com/haasapi/index.html?spm=a2cpu.b17074837.0.0.66e960b1YtzRuv#/Python/docs/zh-CN/startup/ESP-C3-32S-Kit_startup)|
+|M5StackCore2|[明栈 M5StackCore2](https://haas.iot.aliyun.com/solution/detail/hardware?versionId=800C84FAF561DF6A00000001&dataId=800C84FAF561DF6A)|ESP32芯片<br>带触摸屏<br>支持摄像头与云端一体AI|[链接](https://haas.iot.aliyun.com/haasapi/index.html?spm=a2cpu.b17074837.0.0.66e960b1YtzRuv#/Python/docs/zh-CN/startup/M5StackCore2_startup)|
+
+## 二、安装HaaS-Studio开发工具
+
+&emsp;&emsp;
+下载 VS Code 安装包并进行安装，安装完 VS Code之后，请按照下图中数字的指示步骤完成haas-studio插件的安装。
+
+<div align="center">
+<img src=../images/1_安装haas_studio_插件.png width=80%/>
+</div>
+
+HaaS Studio安装完毕后，在“快速开始”可以看到其全部功能，如下图所示。
+
+<div align="center">
+<img src=../images/HaaS_Studio_fast_startup.png width=80%/>
+</div>
+
+
+</div>
+
+## 三、运行Hello World程序
+### 3.1 下载HaaS Python固件并烧录
+
+&emsp;&emsp;
+请通过本文前面”HaaS Python版本历史“章节中的“固件下载链接”下载适用于你手头开发板的固件，推荐使用最新版本的固件。
+
+&emsp;&emsp;
+固件下载完成后，通过HaaS Studio对固件进行烧录。下图是HaaS EDU K1烧录的过程。
+
+<div align="center">
+<img src=../images/HaaS_Studio_HaaSEDUK1_fw_download.png width=80%/>
+</div>
+
+> 不同开发板详细固件烧录流程请参考上文“开发板快速开始”链接中“固件烧录”章节的说明。
+
+### 3.2 创建并运行第一个HaaS Python程序
+
+&emsp;&emsp;
+HaaS Python固件烧录完成后，在HaaS Studio的的“快速开始”页面点击“创建项目”后选择你的开发板中“Hello World”程序（下图是以HaaS EDU K1为例），点击“立即创建”即可创建一个本地工程。
+
+<div align="center">
+<img src=../images/HaaS_Studio_HaaSEDUK1_helloworld.png width=80%/>
+</div>
+
+&emsp;&emsp;
+待工程创建完毕后点击“部署运行”按钮，将程序推送到开发板中即可体验Hello World程序。
+
+> 不同开发板部署运行的详细流程请参考上文“开发板快速开始”链接中“Hello World例程”章节的说明。
+
+&emsp;&emsp;
+体验完Hello World例程后，建议你进入[HaaS Python创意案例专区](https://haas.iot.aliyun.com/solution)，找一个和你创意接近的案例或你感兴趣的案例，学学怎样用HaaS Python完成一个云端一体全链路物联网应用开发过程。
+
+


Test patch:
diff --git a/haas_lib_bundles/python/docs/startup/ESP32_opentest.md b/haas_lib_bundles/python/docs/startup/ESP32_opentest.md
index 066953a9f5..dce384239b 100644
--- a/haas_lib_bundles/python/docs/startup/ESP32_opentest.md
+++ b/haas_lib_bundles/python/docs/startup/ESP32_opentest.md
@@ -97,7 +97,7 @@ zsh: no matches found: /dev/tty.usb*
 ### ESP32 NodeMCU固件列表
 * [ESP32-NodeMCU最新固件](https://hli.aliyuncs.com/o/config/HaaS_Python/HaaSPython-esp32-nodemcu32s.zip)
 
-  * NodeMCU-32S最新固件v0.1.7版本更新说明（2020-12-20）
+  * NodeMCU-32S最新固件v0.1.7版本更新说明（2021-12-20）
     * 更换vfatfs到 littlefs，节省20K内存
     * 优化系统内存管理策略，缓解内存不足问题
     * 增加statvfs接口
@@ -206,10 +206,7 @@ Hard resetting via RTS pin...
 
 &emsp;&emsp;
 &emsp;&emsp;
-点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
-<div align="center">
-<img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
-</div>
+点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS-Studio会将脚本推送到开发板上。
 
 &emsp;&emsp;
 脚本推送完成后，VS Code的命令行窗口会有如下提示：
@@ -217,9 +214,22 @@ Hard resetting via RTS pin...
 upload success
 ```
 
+&emsp;&emsp;
+如果`推送不成功`请点击下面`"推送失败的解决方案"`按钮查看解决方法。
+<details>
+<summary>推送失败的解决方案</summary>
+&emsp;&emsp;
+一般情况下，推送失败是因为电脑上外接了多个USB转串口的设备导致的。此时，VS Code的命令行中会列出系统的串口列表，需要您在命令行中敲入ESP32串口名称（前面“ESP32串口名称确认”步骤中有说明）对应的序号之后敲回车。如下图所示：
+
+<div align="center">
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_选择串口序号.png width=150%/>
+</div>
+
 &emsp;&emsp;
 如果选择了串口仍然推送失败，请联系HaaS小二解决推送问题。
 
+</details>
+
 <br>
 
 &emsp;&emsp;
@@ -257,7 +267,7 @@ helloworld例程运行起来就说明HaaS Python开发环境安装好了。接
 &emsp;&emsp;
 ESP32快速开始完成之后，公测用户可以开始如下几部分的测试：
 * 一分钟上云体验
-* 趣味案例
+* 创意案例
 * 教育仓库案例
 * HaaS API文档
 
@@ -270,9 +280,9 @@ ESP32快速开始完成之后，公测用户可以开始如下几部分的测试
 <img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/一分钟上云案例入口.png width=80%/>
 </div>
 
-## 趣味案例
+## 创意案例
 &emsp;&emsp;
-如上图所示，“趣味案例”页面下面的案例都是独立的，每一个都可以单独体验，建议按照下面的顺序依此体验。
+如上图所示，“创意案例”页面下面的案例都是独立的，每一个都可以单独体验，建议按照下面的顺序依此体验。
 * 火焰检测系统
 * 花卉养植系统
 * 起夜灯
diff --git a/haas_lib_bundles/python/docs/startup/M5StackCore2_opentest.md b/haas_lib_bundles/python/docs/startup/M5StackCore2_opentest.md
index 867687e01d..748a33596f 100644
--- a/haas_lib_bundles/python/docs/startup/M5StackCore2_opentest.md
+++ b/haas_lib_bundles/python/docs/startup/M5StackCore2_opentest.md
@@ -44,7 +44,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 安装完 VS Code之后，请按照下图中数字的指示步骤完成haas-studio插件的安装。
 
 <div align="center">
-<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_安装haas_studio_插件.png width=80%/>
+<img src=../images/1_安装haas_studio_插件.png width=80%/>
 </div>
 
 &emsp;&emsp;
@@ -79,7 +79,7 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 如果电脑在连接M5StackCore2之前和之后，没有新增串口，则需要安装M5StackCore2的串口驱动：[驱动下载链接](https://docs.m5stack.com/en/download)。
 
 <div align="center">
-<img src=../images/M5StackCore2驱动下载页_Windows.png width=70%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/M5StackCore2驱动下载页_Windows.png width=70%/>
 </div>
 
 <br>
@@ -89,13 +89,13 @@ VS Code安装包下载网站： https://code.visualstudio.com/
 &emsp;&emsp;
 使用MAC系统的开发者`务必`下载MACOS的驱动并`严格按照驱动压缩包中的pdf说明文档`中的安装说明进行安装（MAC下驱动加载需要手动开启加载权限）。
 <div align="center">
-<img src=../images/M5StackCore2驱动下载页_MACOS.png width=70%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/M5StackCore2驱动下载页_MACOS.png width=70%/>
 </div>
 
 > 笔者下的v1.7版本的驱动解压后说明文档名称为“CH34X_DRV_INSTALL_INSTRUCTIONS.pdf”如下图所示：
 
 <div align="center">
-<img src=../images/M5StackCore2驱动下载页_MACOS_说明文档.png width=70%/>
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/M5StackCore2驱动下载页_MACOS_说明文档.png width=70%/>
 </div>
 
 <br>
@@ -218,19 +218,30 @@ Hard resetting via RTS pin...
 ### 推送脚本到设备
 
 &emsp;&emsp;
-点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS Studio工具上面会弹出如下的选择框，请按照如下的步骤逐步选择完成后，HaaS-Studio开始推出送固件。
-<div align="center">
-<img src=../images/1_HaaS_Studio_Python_本地推送脚本.png width=60%/>
-</div>
+点击HaaS-Studio的“部署运行”按钮（<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_部署运行.png width=5%/>），HaaS-Studio会将脚本推送到开发板上。
 
 &emsp;&emsp;
 脚本推送完成后，VS Code的命令行窗口会有如下提示：
 ```
 upload success
 ```
+
+&emsp;&emsp;
+如果`推送不成功`请点击下面"推送失败的解决方案"按钮查看解决方法。
+<details>
+<summary>推送失败的解决方案</summary>
+&emsp;&emsp;
+一般情况下，推送失败是因为电脑上外接了多个USB转串口的设备导致的。此时，VS Code的命令行中会列出系统的串口列表，需要您在命令行中敲入M5StackCore2串口名称（前面“M5StackCore2串口名称确认”步骤中有说明）对应的序号之后敲回车。如下图所示：
+
+<div align="center">
+<img src=https://hli.aliyuncs.com/haas-static/haasapi/Python/docs/zh-CN/images/1_HaaS_Studio_选择串口序号.png width=150%/>
+</div>
+
 &emsp;&emsp;
 如果选择了串口仍然推送失败，请联系HaaS小二解决推送问题。
 
+</details>
+
 <br>
 &emsp;&emsp;
 推送此脚本到M5StackCore2之后，HaaS-Studio同时会自动打开串口工具，并自动执行main.py脚本，此时可以在看到设备周期性的打印如下日志。
@@ -268,21 +279,22 @@ helloworld例程运行起来就说明HaaS Python开发环境安装好了。
 M5StackCore2快速开始完成之后，公测用户可以开始如下几部分的测试。
 
 ## Audio案例
-Audio趣味案例测试入口：https://haas.iot.aliyun.com/solution
+Audio创意案例测试入口：https://haas.iot.aliyun.com/solution
 * [播报音箱](https://haas.iot.aliyun.com/solution/detail/solution?versionId=800AF99C5AC00ACE00000001&dataId=800AF99C5AC00ACE)
 
 ## HaaS AI案例
 &emsp;&emsp;
-HaaS AI趣味案例测试入口：https://haas.iot.aliyun.com/solution
+HaaS AI创意案例测试入口：https://haas.iot.aliyun.com/solution
 
 &emsp;&emsp;
-主要有下图中的两个案例：
+主要有下图中的三个案例：
 * [水果识别系统](https://haas.iot.aliyun.com/solution/detail/solution?versionId=800A962AB944E4C400000001&dataId=800A962AB944E4C4)
 * [人员入侵检测系统](https://haas.iot.aliyun.com/solution/detail/solution?versionId=800A42D45EC1E0D100000001&dataId=800A42D45EC1E0D1)
+* [车牌识别](https://haas.iot.aliyun.com/solution/detail/solution?versionId=800AD0DC054E0B5B00000001&dataId=800AD0DC054E0B5B)
 
 ## HaaS UI案例
 &emsp;&emsp;
-HaaS AI趣味案例测试入口：https://haas.iot.aliyun.com/solution
+HaaS AI创意案例测试入口：https://haas.iot.aliyun.com/solution
 
 &emsp;&emsp;
 主要有下图中的三个案例：
@@ -314,4 +326,4 @@ HaaS API文档测试入口：https://haas.iot.aliyun.com/
 
 > 再次感谢您能参与HaaS Python的公测！
 
-<br>
\ No newline at end of file
+<br>