Merge pull request #21 from SummerGGift/master

【完善】：micropython 说明文档

docs/Development_manual_document_section/02-Basic_Knowledge.md

@@ -4,7 +4,7 @@
 
 在 MicroPython 上运行 python 文件有以下要求：
 
-- 系统内使用了 rt-thread 的文件系统。
+- 系统内使用了 `rt-thread` 的文件系统。
 - 开启 `msh` 功能。
 
 符合以上两点，就可以使用 `msh` 命令行中的 `python` 命令加上 `*.py` 文件名来执行一个 python 文件了。
@@ -13,19 +13,19 @@
 
 ### board
 
-  开发板，通常这个术语用来表示以一个特定的 MCU 为核心的开发板 。它也可以被用来表示移植 MicroPython 到一个特定的开发板上，也可以表示像 Unix 移植这样没有开发板的移植。
+  开发板，通常这个术语用来表示以一个特定的 `MCU` 为核心的开发板 。它也可以被用来表示移植 MicroPython 到一个特定的开发板上，也可以表示像 `Unix` 移植这样没有开发板的移植。
 
 ### CPython
 
-  CPython 是 Python 编程语言的一种实现，是最被人们所熟知和使用的一种。然而它只是许多种实现中的一种（其中包括 Jython、IronPython、PyPy、 MicroPython 等）。由于没有正式的 Python 语言规范，只有 CPython 文档，在 Python 语言本身和 Cpython 这种实现之间画出一条界限并不容易。这同时也给其他方式的实现留下了更多的自由。比如 MicroPython 做了许多和 Cpython 不一样的事情，同时仍然成为 Python 语言的一种实现。
+  `CPython` 是 Python 编程语言的一种实现，是最被人们所熟知和使用的一种。然而它只是许多种实现中的一种（其中包括 `Jython、IronPython、PyPy、 MicroPython` 等）。由于没有正式的 Python 语言规范，只有 `CPython` 文档，在 Python 语言本身和 `Cpython` 这种实现之间画出一条界限并不容易。这同时也给其他方式的实现留下了更多的自由。比如 MicroPython 做了许多和 `Cpython` 不一样的事情，同时仍然成为 Python 语言的一种实现。
 
 ### GPIO
 
-  通用输入/输出。控制电子信号最简单的方法。通过 GPIO 用户可以配置硬件信号引脚为输入或者输出，并设置或者获取其数字信号值（逻辑  '0' 或 '1'）。 MicroPython 使用抽象类  [`machine.Pin`](04-Hardware_Control_Module/02-machine-Pin.md)  来访问 GPIO。
+  通用输入/输出。控制电子信号最简单的方法。通过 `GPIO` 用户可以配置硬件信号引脚为输入或者输出，并设置或者获取其数字信号值（逻辑  '0' 或 '1'）。 MicroPython 使用抽象类  [`machine.Pin`](04-Hardware_Control_Module/02-machine-Pin.md)  来访问 `GPIO`。
 
 ### interned string
 
-  由其唯一的标识而不是其地址引用的字符串。因此，可以用他们的标识符而不是通过内容快速地比较内部字符串。interned 字符串的缺点是插入操作需要时间（与现有 interned 字符串的数量成正比，也就是说会随着时间的推移耗时越来越久），而用于插入 interned 字符串的空间是不可回收的。当某个 interned 字符串被应用需求（作为关键字参数）或者对系统有益（可以减少查找的时间）时，就会被 MicroPython 的编译器和运行环境自动生成。由于上面的缺点，大多数字符串和输入/输出操作都不会产生 interned 字符串。
+  由其唯一的标识而不是其地址引用的字符串。因此，可以用他们的标识符而不是通过内容快速地比较内部字符串。`interned` 字符串的缺点是插入操作需要时间（与现有 `interned` 字符串的数量成正比，也就是说会随着时间的推移耗时越来越久），而用于插入 `interned` 字符串的空间是不可回收的。当某个 `interned` 字符串被应用需求（作为关键字参数）或者对系统有益（可以减少查找的时间）时，就会被 MicroPython 的编译器和运行环境自动生成。由于上面的缺点，大多数字符串和输入/输出操作都不会产生 `interned` 字符串。
 
 ### MCU
 
@@ -33,12 +33,12 @@
 
 ### micropython-lib
 
-  MicroPython 通常是单个的可执行/二进制文件，只有很少的内置模块。没有广泛的标准库可以用来和 Cpython 相比。与 Cpython 不同的是 MicroPython 有一个相关但是独立的项目 [`micropython-lib`](https://github.com/micropython/micropython-lib)，它提供了来自 CPython 标准库的许多模块的实现。然而这些模块大部分需要类似于 POSIX 的环境，只能在 MicroPython 的 Unix 移植上工作。安装方法与 Cpython 也不同，需要使用手动复制或者使用 upip 来安装。由于 RT-Thread 操作系统提供了很好的 POSIX 标准支持，所以 [`micropython-lib`](https://github.com/micropython/micropython-lib) 中很多模块可以在 RT-Thread MicroPython 上运行。
+  MicroPython 通常是单个的可执行/二进制文件，只有很少的内置模块。没有广泛的标准库可以用来和  `Cpython` 相比。与 `Cpython` 不同的是 MicroPython 有一个相关但是独立的项目 [`micropython-lib`](https://github.com/micropython/micropython-lib)，它提供了来自 `CPython` 标准库的许多模块的实现。然而这些模块大部分需要类似于 `POSIX` 的环境，只能在 MicroPython 的 `Unix` 移植上工作。安装方法与 `Cpython` 也不同，需要使用手动复制或者使用 `upip` 来安装。由于 `RT-Thread` 操作系统提供了很好的 `POSIX` 标准支持，所以 [`micropython-lib`](https://github.com/micropython/micropython-lib) 中很多模块可以在 `RT-Thread MicroPython` 上运行。
 
 ### stream
 
-  也被称为文件类对象，一种对底层数据提供顺序读写访问的对象。stream 对象实现了对应的接口，包括` read()`, `write()`, `readinto()`, `seek()`, `flush()`, `close()`  等方法。在 MicroPython 中，流是一个重要的概念，许多输入/输出对象都实现了流接口，因此可以在不同的上下文中一致地使用。更多关于 MicroPython 流的信息，可以参考  [uio](03-Basic_Module/05-uio.md) 。
+  也被称为文件类对象，一种对底层数据提供顺序读写访问的对象。`stream` 对象实现了对应的接口，包括` read()`, `write()`, `readinto()`, `seek()`, `flush()`, `close()`  等方法。在 MicroPython 中，流是一个重要的概念，许多输入/输出对象都实现了流接口，因此可以在不同的上下文中一致地使用。更多关于 MicroPython 流的信息，可以参考  [uio](03-Basic_Module/05-uio.md) 。
 
 ### upip
 
-  字面意思是微型的 pip 工具。由 CPython 启发而开发的 MicroPython 包管理程序，但它要小的多，功能也更少。upip 可以在 MicroPython 的 Unix 移植上运行。由于 RT-Thread 操作系统提供了很好的 POSIX 标准支持，所以 upip 也可以运行在 RT-Thread MicroPython 上。使用 upip 工具可以在线下载 MicroPython 的扩展模块，并且自动下载其依赖的模块，为用户扩展 MicroPython 功能提供了很大的便利。 
+  字面意思是微型的 `pip` 工具。由 `CPython` 启发而开发的 MicroPython 包管理程序，但它要小的多，功能也更少。`upip` 可以在 MicroPython 的 `Unix` 移植上运行。由于 `RT-Thread` 操作系统提供了很好的 `POSIX` 标准支持，所以 `upip` 也可以运行在 `RT-Thread MicroPython` 上。使用 `upip` 工具可以在线下载 MicroPython 的扩展模块，并且自动下载其依赖的模块，为用户扩展 MicroPython 功能提供了很大的便利。 

docs/Development_manual_document_section/03-Basic_Module/01-rtthread.md

@@ -2,7 +2,7 @@
 
 
 !!! abstract "简介"
-     **rtthread** 模块提供了与 rt-thread 操作系统相关的功能，如查看栈使用情况等。
+     **rtthread** 模块提供了与 RT-Thread 操作系统相关的功能，如查看栈使用情况等。
 
 
 ## 函数

docs/Development_manual_document_section/03-Basic_Module/02-utime.md

@@ -3,10 +3,10 @@
 !!! abstract "简介"
     **utime** 模块提供获取当前时间和日期、测量时间间隔和延迟的功能。
 
-**初始时刻**: Unix 使用 POSIX 系统标准，从 1970-01-01 00:00:00 UTC开始。
-嵌入式程序从 2000-01-01 00:00:00 UTC 开始。
+**初始时刻**: `Unix` 使用 `POSIX` 系统标准，从 1970-01-01 00:00:00 `UTC` 开始。
+嵌入式程序从 2000-01-01 00:00:00 `UTC` 开始。
 
-**保持实际日历日期/时间**:需要一个实时时钟 (RTC)。在底层系统 (包括一些 RTOS 中)，RTC 已经包含在其中。设置时间是通过 OS/RTOS 而不是 MicroPython 完成，查询日期/时间也需要通过系统 API。对于裸板系统时钟依赖于 ``machine.RTC()`` 对象。设置时间通过 ``machine.RTC().datetime(tuple)`` 函数，并通过下面方式维持:
+**保持实际日历日期/时间**:需要一个实时时钟 `(RTC)`。在底层系统 (包括一些 `RTOS` 中)，`RTC` 已经包含在其中。设置时间是通过 `OS/RTOS` 而不是 MicroPython 完成，查询日期/时间也需要通过系统 `API`。对于裸板系统时钟依赖于 ``machine.RTC()`` 对象。设置时间通过 ``machine.RTC().datetime(tuple)`` 函数，并通过下面方式维持:
 
 * 后备电池 (可能是选件、扩展板等)。
 * 使用网络时间协议 (需要用户设置)。
@@ -83,10 +83,10 @@ while pin.value() == 0:
 ```
 
 ### **utime.time**()
-  返回从开始时间的秒数（整数），假设 RTC 已经按照前面方法设置好。如果 RTC 没有设置，函数将返回参考点开始计算的秒数 (对于 RTC 没有后备电池的板子，上电或复位后的情况)。如果你开发便携版的 MicroPython 应用程序，你不要依赖函数来提供超过秒级的精度。如果需要高精度，使用 `ticks_ms()` 和 `ticks_us()` 函数。如果需要日历时间，使用不带参数的 `localtime()` 是更好选择。
+  返回从开始时间的秒数（整数），假设 `RTC` 已经按照前面方法设置好。如果 `RTC` 没有设置，函数将返回参考点开始计算的秒数 (对于 `RTC` 没有后备电池的板子，上电或复位后的情况)。如果你开发便携版的 MicroPython 应用程序，你不要依赖函数来提供超过秒级的精度。如果需要高精度，使用 `ticks_ms()` 和 `ticks_us()` 函数。如果需要日历时间，使用不带参数的 `localtime()` 是更好选择。
 
 !!! tip "与 CPython 的区别"
-    在 CPython 中，这个函数用浮点数返回从 Unix 开始时间（1970-01-01 00:00 UTC）的秒数，通常是毫秒级的精度。在 MicroPython 中，只有 Unix 版才使用相同开始时间，如果允许浮点精度，将返回亚秒精度。嵌入式硬件通常没有用浮点数表示长时间访问和亚秒精度，所以返回值是整数。一些嵌入式系统硬件不支持 RTC 电池供电方式，所以返回的秒数是从最后上电、或相对某个时间、以及特定硬件时间 (如复位)。
+    在 `CPython` 中，这个函数用浮点数返回从 `Unix` 开始时间（1970-01-01 00:00 `UTC`）的秒数，通常是毫秒级的精度。在 MicroPython 中，只有 `Unix` 版才使用相同开始时间，如果允许浮点精度，将返回亚秒精度。嵌入式硬件通常没有用浮点数表示长时间访问和亚秒精度，所以返回值是整数。一些嵌入式系统硬件不支持 `RTC` 电池供电方式，所以返回的秒数是从最后上电、或相对某个时间、以及特定硬件时间 (如复位)。
 
 ##   示例 
 

docs/Development_manual_document_section/04-Hardware_Control_Module/01-machine.md

@@ -1,39 +1,70 @@
 # **machine** – 与硬件相关的功能
-`machine` 模块包含与特定开发板上的硬件相关的特定函数。 在这个模块中的大多数功能允许实现直接和不受限制地访问和控制系统上的硬件块（如CPU，定时器，总线等）。如果使用不当，会导致故障，死机，崩溃，在极端的情况下，硬件会损坏。
 
-更多内容可参考 [machine](http://docs.micropython.org/en/latest/pyboard/library/machine.html) 。
+!!! abstract "简介"
+    **machine** 模块包含与特定开发板上的硬件相关的特定函数。 在这个模块中的大多数功能允许实现直接和不受限制地访问和控制系统上的硬件块（如CPU，定时器，总线等）。如果使用不当，会导致故障，死机，崩溃，在极端的情况下，硬件会损坏。
 
-`复位功能`
+## 函数
 
-- machine.reset()  
-  重置设备的方式类似类似按下 rst 按钮。
+### 复位相关函数
 
-- machine.reset_cause()  
-  Get the reset cause. See constants for the possible return values.
+#### **machine.info**()  
+  显示关于系统介绍和内存占用等信息。
 
-`中断功能`
+#### **machine.rest**()  
+  重启设备，类似于按下复位按钮。
 
-- machine.disable_irq()  
-  Disable interrupt requests. Returns the previous IRQ state which should be considered an opaque value. This return value should be passed to the enable_irq function to restore interrupts to their original state, before disable_irq was called.
+#### **machine.reset_cause**()  
+  获得复位的原因，查看可能的返回值的常量。
 
-- machine.enable_irq(state)  
-  Re-enable interrupt requests. The state parameter should be the value that was returned from the most recent call to the disable_irq function.
+### 中断相关函数
 
-`有效的相关功能`
+#### **machine.disable_irq**()  
+  禁用中断请求。返回先前的 `IRQ` 状态，该状态应该被认为是一个未知的值。这个返回值应该在 `disable_irq` 函数被调用之前被传给 `enable_irq` 函数来重置中断到初始状态。
 
-- machine.freq()  
-  Returns CPU frequency in hertz.
+#### **machine.enable_irq**(state)  
+  重新使能中断请求。状态参数应该是从最近一次禁用功能的调用中返回的值。
 
-- machine.idle()  
-  Gates the clock to the CPU, useful to reduce power consumption at any time during short or long periods. Peripherals continue working and execution resumes as soon as any interrupt is triggered (on many ports this includes system timer interrupt occurring at regular intervals on the order of millisecond).
+### 功耗相关函数
 
-- machine.sleep()  
-  Stops the CPU and disables all peripherals except for WLAN. Execution is resumed from the point where the sleep was requested. For wake up to actually happen, wake sources should be configured first.
+#### **machine.freq**()  
+  返回 `CPU` 的运行频率。
 
-- machine.deepsleep()  
-  Stops the CPU and all peripherals (including networking interfaces, if any). Execution is resumed from the main script, just as with a reset. The reset cause can be checked to know that we are coming from machine.DEEPSLEEP. For wake up to actually happen, wake sources should be configured first, like Pin change or RTC timeout.
+#### **machine.idle**()  
+  阻断给 `CPU` 的时钟信号，在较短或者较长的周期里减少功耗。当中断发生时，外设将继续工作。
 
-`example`:
+#### **machine.sleep**()  
+  停止 `CPU` 并禁止除了 `WLAN` 之外的所有外设。系统会从睡眠请求的地方重新恢复工作。为了确保唤醒一定会发生，应当首先配置中断源。
+
+#### **machine.deepsleep**()  
+  停止 `CPU` 和所有外设（包括网络接口）。执行从主函数中恢复，就像被复位一样。复位的原因可以检查 `machine.DEEPSLEEP` 参数获得。为了确保唤醒一定会发生，应该首先配置中断源，比如一个引脚的变换或者 `RTC` 的超时。
+
+## 常数
+
+### **machine.IDLE**
+### **machine.SLEEP**
+### **machine.DEEPSLEEP**
+`IRQ` 的唤醒值。
+
+### **machine.PWRON_RESET **
+### **machine.HARD_RESET **
+### **machine.WDT_RESET **
+### **machine.DEEPSLEEP_RESET **
+### **machine.SOFT_RESET**
+复位的原因。
+
+### **machine.WLAN_WAKE**
+### **machine.PIN_WAKE**
+### **machine.RTC_WAKE**
+唤醒的原因。
+
+## 类
+
+### [class Pin](02-machine-Pin.md) - 控制 I/O 引脚  
+### [class I2C](03-machine-I2C.md) - I2C 协议  
+### [class SPI](04-machine-SPI.md) - SPI 协议  
+### [class UART](05-machine-UART.md) - 串口
+
+## 示例 
 
 ```
 >>> import machine
@@ -66,4 +97,6 @@ GC:
 >>> machine.enable_irq()        # enable interrupt
 >>> machine.disable_irq()       # disable interrupt, WARNING: this operation is dangerous
 >>> machine.reset()        # hard reset, like push RESET button
-```
+```
+
+更多内容可参考 [machine](http://docs.micropython.org/en/latest/pyboard/library/machine.html) 。

docs/Development_manual_document_section/04-Hardware_Control_Module/02-machine-Pin.md

@@ -1,7 +1,60 @@
 # machine.Pin  
-  更多内容可参考 [machine.Pin](http://docs.micropython.org/en/latest/pyboard/library/machine.Pin.html)  。
 
-`example`:
+!!! abstract "简介"
+    **machine.Pin** 类是 machine 模块下面的一个硬件类，用于对引脚的配置和控制，提供对 `Pin` 设备的操作方法。
+
+`Pin` 对象用于控制输入/输出引脚（也称为 `GPIO`）。`Pin` 对象通常与一个物理引脚相关联，他可以驱动输出电压和读取输入电压。Pin 类中有设置引脚模式（输入/输出）的方法，也有获取和设置数字逻辑（0 或 1）的方法。
+
+一个 `Pin` 对象是通过一个标识符来构造的，它明确地指定了一个特定的输入输出。标识符的形式和物理引脚的映射是特定于一次移植的。标识符可以是整数，字符串或者是一个带有端口和引脚号码的元组。在 RT-Thread MicroPython 中，引脚标识符是一个由代号和引脚号组成的元组，如 `Pin(("X1", 33), Pin.OUT_PP)` 中的` ("X1", 33)`。
+
+## 构造函数
+
+在 RT-Thread MicroPython 中 `Pin` 对象的构造函数如下：
+
+### **class machine.Pin**( id, mode = -1, pull = -1，value)
+- **id** ：由用户自定义的引脚名和 `Pin`  设备引脚号组成，如("X1", 33)，'X1' 为用户自定义的引脚名，'33' 为 `RT-Thread Pin` 设备驱动在本次移植中的引脚号。
+
+- **mode** ： 指定引脚模式，可以是以下几种：
+    - **Pin.IN** ：输入模式
+    - **Pin.OUT** ：输出模式
+    - **Pin.OPEN_DRAIN** ：开漏模式
+
+- **pull** ： 如果指定的引脚连接了上拉下拉电阻，那么可以配置成下面的状态：
+    - **None** ：没有上拉或者下拉电阻。
+    - **Pin.PULL_UP** ：使能上拉电阻。
+    - **Pin.PULL_DOWN** ：使能下拉电阻。
+
+- **value** ： `value` 的值只对输出模式和开漏输出模式有效，用来设置初始输出值。
+
+## 方法
+
+### **Pin.init**(mode=-1, pull=-1, *, value, drive, alt)
+根据输入的参数重新初始化引脚。只有那些被指定的参数才会被设置，其余引脚的状态将保持不变，详细的参数可以参考上面的构造函数。
+
+### **Pin.value**([x])
+如果没有给定参数 `x` ,这个方法可以获得引脚的值。  
+如果给定参数 `x` ，如 0 或 1，那么设置引脚的值为 逻辑 '0' 或 逻辑 '1'。
+
+### **Pin.name**()
+返回引脚对象在构造时用户自定义的引脚名。
+
+## 常量
+
+下面的常量用来配置 `Pin` 对象。  
+
+### 选择引脚模式：
+#### **Pin.IN**
+#### **Pin.OUT** 
+#### **Pin.OPEN_DRAIN**
+
+### 选择上/下拉模式：
+#### **Pin.PULL_UP** 
+#### **Pin.PULL_DOWN**
+#### **None**  
+使用值 `None` 代表不进行上下拉。
+
+## 示例 
+
 ```
 >>> from machine import Pin
 >>> 
@@ -11,4 +64,6 @@
 >>> 
 >>> p_in = Pin(("X2", 32), Pin.IN, Pin.PULL_UP)
 >>> p_in.value()                # get value, 0 or 1
-```
+```
+
+  更多内容可参考 [machine.Pin](http://docs.micropython.org/en/latest/pyboard/library/machine.Pin.html)  。

docs/Development_manual_document_section/04-Hardware_Control_Module/03-machine-I2C.md

@@ -1,7 +1,84 @@
 # machine.I2C  
-  更多内容可参考 [machine.I2C](http://docs.micropython.org/en/latest/pyboard/library/machine.I2C.html) 。
 
-`software I2C example ` :
+!!! abstract "简介"
+     **machine.I2C** 类是 `machine` 模块下面的一个硬件类，用于对 `I2C` 的配置和控制，提供对 `I2C` 设备的操作方法。
+
+- `I2C` 是一种用于设备间通信的两线协议。在物理层上，它由两根线组成：`SCL`  和 `SDA` ，即时钟和数据线。
+- `I2C` 对象被创建到一个特定的总线上，它们可以在创建时被初始化，也可以之后再来初始化。
+- 打印 `I2C` 对象会打印出配置时的信息。
+
+## 构造函数
+
+在 RT-Thread MicroPython 中 `I2C` 对象的构造函数如下：
+
+### **class machine.I2C**(id= -1,  scl, sda, freq=400000)
+使用下面的参数构造并返回一个新的 `I2C` 对象：
+
+- **id** ：标识特定的 `I2C`  外设。如果填入 id = -1，即选择软件模拟的方式实现 `I2C`，这时可以使用任意引脚来模拟 `I2C` 总线 ，这样在初始化时就必须指定 `scl` 和 `sda` 。  
+软件 I2C 的初始化方式可参考 [软件 I2C 示例](#i2c_2)。  
+硬件 I2C 的初始化方式可参考 [硬件 I2C 示例](#i2c_3)。
+
+- **scl** : 应该是一个 `Pin` 对象，指定为一个用于 `scl` 的 `Pin` 对象。
+- **sda** : 应该是一个 `Pin` 对象，指定为一个用于 `sda` 的 `Pin` 对象。
+- **freq** ：应该是为 `scl` 设置的最大频率。
+
+## 方法
+
+### **I2C.init**(scl, sda, freq=400000)
+初始化 `I2C` 总线，参数介绍可以参考构造函数中的参数。
+
+### **I2C.deinit**()
+关闭 `I2C` 总线。
+
+### **I2C.scan**()
+扫描所有 0x08 和 0x77 之间的 `I2C` 地址，然后返回一个有响应地址的列表。如果一个设备在总线上收到了他的地址，就会通过拉低 `SDA` 的方式来响应。
+
+## I2C 基础方法
+下面的方法实现了基本的 `I2C` 总线操作，可以组合成任何的 `I2C` 通信操作，如果需要对总线进行更多的控制，可以可以使用他们，否则可以使用后面介绍的标准使用方法。
+
+### **I2C.start**()
+在总线上产生一个启动信号。（`SCL` 为高时，`SDA` 转换为低）
+
+### **I2C.stop**()
+在总线上产生一个停止信号。（`SCL` 为高时，`SDA` 转换为高）
+
+### **I2C.readinto**(buf, nack=True)
+从总线上读取字节并将他们存储到 `buf` 中，读取的字节数时 `buf` 的长度。在收到最后一个字节以外的所有内容后，将在总线上发送 `ACK`。在收到最后一个字节之后，如果 `NACK` 是正确的，那么就会发送一个 `NACK`，否则将会发送 `ACK`。
+
+###  **I2C.write**(buf)
+将 `buf` 中的数据接入到总线，检查每个字节之后是否收到 `ACK`，并在收到 `NACK` 时停止传输剩余的字节。这个函数返回接收到的 `ACK` 的数量。
+
+## I2C 标准总线操作
+下面的方法实现了标准 `I2C` 主设备对一个给定从设备的读写操作。
+
+### **I2C.readfrom**(addr, nbytes, stop=True)
+从 `addr` 指定的从设备中读取 n 个字节，如果 `stop = True`，那么在传输结束时会产生一个停止信号。函数会返回一个存储着读到数据的字节对象。
+
+### **I2C.readfrom_into**(addr, buf, stop=True)
+从 `addr` 指定的从设备中读取数据存储到 `buf` 中，读取的字节数将是 `buf` 的长度，如果 `stop = True`，那么在传输结束时会产生一个停止信号。  
+这个方法没有返回值。
+
+### **I2C.writeto**(addr, buf, stop=True)
+将 `buf` 中的数据写入到 `addr` 指定的的从设备中，如果在写的过程中收到了 `NACK` 信号，那么就不会发送剩余的字节。如果 `stop = True`，那么在传输结束时会产生一个停止信号，即使收到一个 `NACK`。这个函数返回接收到的 `ACK` 的数量。
+
+## 内存操作
+
+一些 `I2C` 设备充当一个内存设备，可以读取和写入。在这种情况下，有两个与 `I2C` 相关的地址，从机地址和内存地址。下面的方法是与这些设备进行通信的便利函数。
+
+### **I2C.readfrom_mem**(addr, memaddr, nbytes, *, addrsize=8)
+从 `addr` 指定的从设备中 `memaddr` 地址开始读取 n 个字节。`addrsize` 参数指定地址的长度。返回一个存储读取数据的字节对象。
+
+### **I2C.readfrom_mem_into**(addr, memaddr, buf, *, addrsize=8)
+从 `addr` 指定的从设备中 `memaddr` 地址读取数据到 `buf` 中，，读取的字节数是 `buf` 的长度。  
+这个方法没有返回值。
+
+### **I2C.writeto_mem**(addr, memaddr, buf, *, addrsize=8)
+将 `buf` 里的数据写入 `addr` 指定的从机的 `memaddr` 地址中。 
+这个方法没有返回值。
+
+## 示例 
+
+### `软件模拟 I2C ` 
 ```
 >>> from machine import Pin, I2C
 >>> clk = Pin(("clk", 43), Pin.OUT_OD)   # Select the 43 pin device as the clock
@@ -19,10 +96,16 @@ b'\x12'                               # starting at memory-address 8 in the slav
                                       # starting at address 2 in the slave
 ```
 
-`hardware I2C example ` :
+### `硬件 I2C ` 
+
+需要先开启 `I2C` 设备驱动，查找设备可以在 `msh` 中输入`list_device` 命令。  
+在构造函数的第一个参数传入 '0'，系统就会搜索名为 'i2c0' 的设备，找到之后使用这个设备来构建 `I2C` 对象：
+
 ```
 >>> from machine import Pin, I2C
 >>> i2c = I2C(0)           # create I2C peripheral at frequency of 100kHz
 >>> i2c.scan()                        # scan for slaves, returning a list of 7-bit addresses
 [81]                                  # Decimal representation
-```
+```
+
+  更多内容可参考 [machine.I2C](http://docs.micropython.org/en/latest/pyboard/library/machine.I2C.html) 。

docs/Development_manual_document_section/04-Hardware_Control_Module/04-machine-SPI.md

@@ -1,13 +1,75 @@
-# machine.SPI  
-  更多内容可参考 [machine.SPI](http://docs.micropython.org/en/latest/pyboard/library/machine.SPI.html) 。
+# machine.SPI
 
-`software SPI example ` :
+!!! abstract "简介"
+    **machine.SPI** 类是 machine 模块下面的一个硬件类，用于对 SPI 的配置和控制，提供对 SPI 设备的操作方法。
+
+- `SPI` 是一个由主机驱动的同步串行协议。在物理层，总线有三根：`SCK`、`MOSI`、`MISO`。多个设备可以共享同一总线，每个设备都由一个单独的信号 `SS` 来选中，也称片选信号。
+- 主机通过片选信号选定一个设备进行通信。`SS` 信号的管理应该由用户代码负责。（通过 [machine.Pin](02-machine-Pin.md)）
+
+## 构造函数
+
+在 RT-Thread MicroPython 中 `SPI` 对象的构造函数如下：
+
+### **class machine.SPI**(id, ...)
+在给定总线上构造一个 `SPI` 对象，`id` 取决于特定的移植。
+
+如果想要使用软件 `SPI` , 即使用引脚模拟 `SPI` 总线，那么初始化的第一个参数需要设置为 `-1` ，可参考 [软件 SPI 示例](#spi) 。
+
+使用硬件 `SPI` 在初始化时只需传入 `SPI` 设备的编号即可，如 '50' 表示 `SPI5` 总线上的第 0 个设备。初始化方式可参考 [硬件 SPI 示例](#spi_1)。
+
+如果没有额外的参数，`SPI` 对象会被创建，但是不会被初始化，如果给出额外的参数，那么总线将被初始化，初始化参数可以参考下面的 `SPI.init` 方法。
+
+## 方法
+
+### **SPI.init**(baudrate=1000000, *, polarity=0, phase=0, bits=8, firstbit=SPI.MSB, sck=None, mosi=None, miso=None)
+
+用给定的参数初始化`SPI`总线：
+
+- **baudrate** ：`SCK` 时钟频率。
+- **polarity** ：极性可以是 '0' 或 '1'，是时钟空闲时所处的电平。
+- **phase** ：相位可以是 '0' 或 '1'，分别在第一个或者第二个时钟边缘采集数据。
+- **bits** ：每次传输的数据长度，一般是 8 位。
+- **firstbit** ：传输数据从高位开始还是从低位开始，可以是 `SPI.MSB` 或者 `SPI.LSB`。
+- **sck** ：用于 `sck` 的 `machine.Pin` 对象。
+- **mosi** ：用于 `mosi` 的 `machine.Pin` 对象。
+- **miso** ：用于`miso` 的 `machine.Pin` 对象。
+
+### **SPI.deinit**()
+关闭 `SPI` 总线。
+
+### **SPI.read**(nbytes, write=0x00)
+读出 n 字节的同时不断的写入 `write` 给定的单字节。返回一个存放着读出数据的字节对象。
+
+### **SPI.readinto**(buf, write=0x00)
+读出 n 字节到 `buf` 的同时不断地写入 `write` 给定的单字节。  
+这个方法返回读入的字节数。
+
+### **SPI.write**(buf)
+写入 `buf` 中包含的字节。返回`None`。
+
+### **SPI.write_readinto**(write_buf, read_buf)
+在读出数据到 `readbuf` 时，从 `writebuf` 中写入数据。缓冲区可以是相同的或不同，但是两个缓冲区必须具有相同的长度。返回 `None`。
+
+## 常量
+
+### **SPI.MASTER**
+用于初始化 `SPI` 总线为主机。
+
+### **SPI.MSB**
+设置从高位开始传输数据。
+
+### **SPI.LSB**
+设置从低位开始传输数据。
+
+## 示例
+
+### `软件模拟 SPI ` 
 ```
 >>> from machine import Pin, SPI
 >>> clk = Pin(("clk", 43), Pin.OUT_PP)
 >>> mosi = Pin(("mosi", 44), Pin.OUT_PP)
 >>> miso = Pin(("miso", 45), Pin.IN)
->>> spi = SPI(-1,500000,polarity = 0,phase = 0,bits = 8,firstbit = 0,sck = clk,mosi = mosi,miso = miso)
+>>> spi = SPI(-1, 500000, polarity = 0, phase = 0, bits = 8, firstbit = 0, sck = clk, mosi = mosi, miso = miso)
 >>> print(spi)
 SoftSPI(baudrate=500000, polarity=0, phase=0, sck=clk, mosi=mosi, miso=miso)
 >>> spi.write("hello rt-thread!")
@@ -15,7 +77,11 @@ SoftSPI(baudrate=500000, polarity=0, phase=0, sck=clk, mosi=mosi, miso=miso)
 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 ```
 
-`hardware SPI example ` :
+### `硬件 SPI ` 
+
+需要先开启 `SPI` 设备驱动，查找设备可以在 `msh` 中输入`list_device` 命令。  
+在构造函数的第一个参数传入  '50'，系统就会搜索名为 'spi50' 的设备，找到之后使用这个设备来构建 `SPI` 对象：
+
 ```
 >>> from machine import SPI
 >>> spi = SPI(50)
@@ -29,4 +95,6 @@ b'\xff\xff\xff\xff\xff'
 >>> buf
 bytearray(b'\xef')
 >>> spi.init(100000,0,0,8,1)     # Resetting SPI parameter
-```
+```
+
+  更多内容可参考 [machine.SPI](http://docs.micropython.org/en/latest/pyboard/library/machine.SPI.html) 。

docs/Development_manual_document_section/04-Hardware_Control_Module/05-machine-UART.md

@@ -0,0 +1,64 @@
+# machine.UART 
+
+!!! abstract "简介"
+    **machine.UART** 类是 machine 模块下面的一个硬件类，用于对 UART 的配置和控制，提供对 UART 设备的操作方法。
+
+`UART` 实现了标准的 `uart/usart` 双工串行通信协议，在物理层上，他由两根数据线组成：`RX` 和 `TX`。通信单元是一个字符，它可以是 8 或 9 位宽。
+
+## 构造函数
+
+在 RT-Thread MicroPython 中 `UART` 对象的构造函数如下：
+
+### **class machine.UART**(id, ...)
+在给定总线上构造一个 `UART` 对象，`id` 取决于特定的移植。  
+初始化参数可以参考下面的 `UART.init` 方法。 
+
+使用硬件 UART 在初始化时只需传入 `UART` 设备的编号即可，如传入 '1' 表示 'uart1' 设备。   
+初始化方式可参考 [示例](#_3)。
+
+## 方法
+
+### **UART.init**(baudrate = 9600, bits=8, parity=None, stop=1)
+- **baudrate** ：`SCK` 时钟频率。
+- **bits** ：每次发送数据的长度。
+- **parity** ：校验方式。
+- **stop** ：停止位的长度。
+
+### **UART.deinit**()
+关闭串口总线。
+
+### **UART.any**()
+如果有可用的字符，那么返回真。
+
+### **UART.read**([nbytes])
+读取字符，如果指定读 n 个字节，那么最多读取 n 个字节，否则就会读取尽可能多的数据。
+返回值：一个包含读入数据的字节对象。如果如果超时则返回 `None`。
+
+### **UART.readinto**(buf[, nbytes])
+读取字符到 `buf` 中，如果指定读 n 个字节，那么最多读取 n 个字节，否则就读取尽可能多的数据。另外读取数据的长度不超过 `buf` 的长度。
+返回值：读取和存储到 `buf` 中的字节数。如果超时则返回 `None`。
+
+### **UART.readline**()
+读一行数据，以换行符结尾。
+返回值：读入的行数，如果超时则返回 `None`。
+
+### **UART.write**(buf)
+将 `buf` 中的数据写入总线。
+返回值：写入的字节数，如果超时则返回 `None`。
+
+## 示例
+
+在构造函数的第一个参数传入 '1'，系统就会搜索名为 'uart1' 的设备，找到之后使用这个设备来构建 `UART` 对象：
+
+```python
+from machine import UART
+uart = UART(1, 9600)                         # init with given baudrate
+uart.init(9600, bits=8, parity=None, stop=1) # init with given parameters
+uart.read(10)       # read 10 characters, returns a bytes object
+uart.read()         # read all available characters
+uart.readline()     # read a line
+uart.readinto(buf)  # read and store into the given buffer
+uart.write('abc')   # write the 3 characters
+```
+
+  更多内容可参考 [machine.UART](http://docs.micropython.org/en/latest/pyboard/library/machine.UART.html) 。

docs/Development_manual_document_section/05-System_Module/01-uos.md

@@ -1,5 +1,7 @@
-# **uos** – 基本的操作系统服务
-`uos` 模块包含了对文件系统的访问操作，是对应 CPython 模块的一个子集。
+# **uos** – 基本的"操作系统"服务
+
+!!! abstract "简介"
+    `uos` 模块包含了对文件系统的访问操作，是对应 CPython 模块的一个子集。
 
 更多内容可参考 [uos](http://docs.micropython.org/en/latest/pyboard/library/uos.html) 。