move documentation repo to rt-thread repo

documentation/README.md

@@ -0,0 +1,136 @@
+# RT-Thread
+
+RT-Thread (Real-Time Thread) is an open source embedded real-time operating system and released under Apache License v2.0. It has a strong scalability: from a nano kernel running on a tiny MCU, for example ARM Cortex-M0, or Cortex-M3/4/7, to a rich feature system running on MIPS32, ARM Cortex-A, even the emerging open source RISC-V architecture is supported. RT-Thread can run either on single-core systems or on symmetric multi-core processors(SMP) systems.
+
+## Introduction
+
+RT-Thread has not noly a real-time kernel, but also rich components. Its architecture is as follows:
+
+![RT-Thread system framework](figures/02Software_framework_diagram.png)
+
+- **Kernel**: It includes preemptive multi-task real-time scheduler, and infrastructure such as semaphore, mutex, mailbox, message queue, signal, event, memory management, timer management, interrupt management, etc. It also includes libcpu/BSP (file related to chip transplantation/board support package).
+- **components**: It is a software unit on the RT-Thread kernel layer, such as command line (FinSH), device driver framework (Device Drivers), network framework, virtual file system (FAT, YAFFS, UFFS, ROM/RAM file system, etc.), TCP/IP network protocol stack (lwIP), libc/POSIX standard layer and so on. Generally, a software component is placed in a folder in the RT-Thread/components directory, and each software component is described by a *SConscript* file and added to the RT-Thread construction system. When a software component is opened in the system configuration, it will be compiled and linked to the final RT-Thread firmware.
+- **Packages**: It is a middleware running on RT-Thread IoT operating system platform and facing different application fields. Packages consist of description information, source code or library files. These packages can be provided by RT-Thread, third-party developers and enterprises, and the license agreement of the packages is provided by the author of the packages. These software packages have strong reusability and high modularity, which greatly facilitates application developers to build their desired application systems in the shortest time. For more package information, visit the [RT-Thread package repository](https://github.com/RT-Thread-packages).
+
+## Licence
+
+RT-Thread  is an open source software and has been licensed under Apache License Version 2.0 since v3.1.1. License information and copyright information can generally be seen at the beginning of the code:
+
+```
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+```
+
+To avoid possible future license conflicts, developers need to sign a Contributor License Agreement (CLA) when submitting PR to RT-Thread.
+
+> Note: Because the BSP also contains the code provided by the chip manufacturer, this part of the code follows the license provided by the chip manufacturer, such as STM32 HAL, NXP, Atmel, etc. Relevant codes are usually only used in the chips of the corresponding manufacturers.
+
+## Supported Architectures
+
+RT-Thread RTOS can support many architectures,and has covered the major architectures in current applications. Architecture and chip manufacturer involved:
+
+- **ARM Cortex-M0/M0+**：manufacturers like ST
+- **ARM Cortex-M3**：manufacturers like ST、Winner Micro、MindMotion, ect.
+- **ARM Cortex-M4**：manufacturers like ST、Nuvton、NXP、GigaDevice、Realtek、Ambiq Micro, ect.
+- **ARM Cortex-M7**：manufacturers like ST、NXP
+- **ARM Cortex-M23**：manufacturers like GigaDevice
+- **ARM Cortex-R4**
+- **ARM Cortex-A8/A9**：manufacturers like NXP
+- **ARM7**：manufacturers like Samsung
+- **ARM9**：manufacturers like Allwinner、Xilinx 、GOKE
+- **ARM11**：manufacturers like Fullhan
+- **MIPS32**：manufacturers like loongson、Ingenic
+- **RISC-V**：manufacturers like Hifive、Kendryte
+- **ARC**：manufacturers like SYNOPSYS
+- **DSP**：manufacturers like TI
+- **C-Sky**
+- **x86**
+
+## Supported IDE and Compiler
+
+The main IDE/compilers supported by RT-Thread are:
+
+- MDK KEIL
+- IAR
+- GCC
+
+Use Python-based [scons](http://www.scons.org) for command-line builds.
+
+# Source Code and Tools
+
+**Get the source code**: The source code of RT-Thread is hosted on Github, and click on the link to get the source code.
+
+- [Download RT-Thread source code](https://github.com/RT-Thread/rt-thread)
+
+**Get the Env Tool**: To better help developers, the RT-Thread team also provides Env tools (or Env scripts for Linux/MacOS). On Windows, Env tool is a development assistant tool launched by RT-Thread. It provides compiling and building environment, graphical system configuration and software package management functions for project projects based on RT-Thread operating system. Its built-in menuconfig provides a simple and easy-to-use configuration tailoring tool, which can tailor the kernel, components and software packages freely, so that the system can be built in the way of building blocks.
+
+- [Download Env Tool]()
+- [User manual of Env](env/env.md)
+
+# Getting Started
+
+RT-Thread BSP can be compiled directly and downloaded to the corresponding development board for use. In addition, RT-Thread also provides qemu-vexpress-a9 BSP, which can be used without hardware platform. See the getting started guide below for details.
+
+- [Getting Started of QEMU (Windows)](quick-start/quick_start_qemu/quick_start_qemu.md)
+- [Getting Started of QEMU (Ubuntu)](quick-start/quick_start_qemu/quick_start_qemu_linux.md)
+
+# Help
+
+Any questions can be asked in the [issue section of rtthread-manual-doc](https://github.com/RT-Thread/rtthread-manual-doc/issues). By creating a new issue to describe your questions, community members will answer them.
+
+# Contribution
+
+If you are interested in RT-Thread and want to join in the development of RT-Thread and become a code contributor,please refer to the [Code Contribution Guide](documentation/contribution_guide/contribution_guide.md).
+
+# Manual Catalogue
+
+- [RT-Thread Introduction](introduction/introduction.md)
+- [Start Guide: Simulate STM32F103 on KEIL simulator](quick-start/quick-start.md)
+
+**Kernel**
+
+- [Kernel Basics](basic/basic.md)
+- [Thread Management](thread/thread.md)
+- [Clock&Timer Management](timer/timer.md)
+- [Inter-thread Synchronization](thread-sync/thread-sync.md)
+- [Inter-thread Communication](thread-comm/thread-comm.md)
+- [Memory Management](memory/memory.md)
+- [Interrupt Management](interrupt/interrupt.md)
+- [Kernel Porting](kernel-porting/kernel-porting.md)
+
+**Tool**
+
+- [User Manual of Env](env/env.md)
+- [SCons](scons/scons.md)
+
+**Device**
+
+- [I/O Device Framework](device/device.md)
+- [PIN Device](device/pin/pin.md)
+- [UART Device](device/uart/uart.md)
+- [ADC Device](device/adc/adc.md)
+- [I2C Bus Device](device/i2c/i2c.md)
+- [SPI Device](device/spi/spi.md)
+- [PWM Device](device/pwm/pwm.md)
+- [RTC Device](device/rtc/rtc.md)
+- [HWTIMER Device](device/hwtimer/hwtimer.md)
+- [WATCHDOG Device](device/watchdog/watchdog.md)
+- [WLAN Device](device/wlan/wlan.md)
+- [Sensor Device](device/sensor/sensor.md)
+
+**Components**
+
+- [FinSH Console](finsh/finsh.md)
+- [Virtual File System](filesystem/README.md)
+- [utest Framework](utest/utest.md)
+- [Dynamic Module: dlmodule](dlmodule/README.md)
+- [Socket Abstraction Layer: SAL](sal/sal.md)
+- [AT Commands](at/at.md)
+- [POSIX Interface](posix/README.md)
+- [Ulog Log](ulog/ulog.md)
+- [Power Management: PM](pm/pm.md)
+- [Network Framework](network/network.md)
+

documentation/contribution_guide/contribution_guide.md

@@ -0,0 +1,171 @@
+# Contribution Guide
+
+We sincerely thank you for your contribution, and welcome to submit the code through GitHub's fork and Pull Request processes.
+
+First, explain the word Pull Request. Pull request means to send a request. The purpose of the developer initiating Pull Request is to request the repository maintainer to adopt the code submitted by the developer.
+
+When you want to correct mistakes in other people's repositories, follow the following procedure:
+
+- To fork someone else's repository is equivalent to copying someone else's information. Because you can't guarantee that your modification is correct and beneficial to the project, you can't modify it directly in someone else's repository, but first fork it into your own git repository.
+- Clone code to your own PC local, create a new branch, modify bugs or add new features, and then launch pull request to the original repository, so that the original repository manager can see the changes you submitted.
+- The original repository manager reviews this submission and, if correct, merge it into his own project. Merge means merging, merging the part of code you modified into the original repository to add code or replace the original code. So far, the whole Pull Request process is over.
+
+## Coding Style
+
+Refer to the `coding_style_en.txt` file in the rt_thread project documentation directory for the RT-Thread code programming style.
+
+## Preparation
+
+Install Git: You need to add Git's directory to the system environment variable.
+
+## Contribution Process
+
+Now take RT-Thread repository as an example to illustrate the process of contributing code:
+
+### Fork
+
+Fork the RT-Thread/rt-thread repository into your git repository.
+
+![fork rt-thread repository](figures/cloneformgit.png)
+
+### Clone
+
+In your repository, copy the repository links after your fork:
+
+![clone rt-thread from your repo](figures/cloneformgit2.png)
+
+You can use the `git clone` command to copy the repository to your PC:
+
+```
+git clone [url]
+```
+
+![git clone](figures/git_clone.png)
+
+### Create a New Branch
+
+It is recommended that you create your own development branch based on the master branch, and use following  commands to create a new branch:
+
+```
+git checkout -b YourBranchName
+```
+
+For example, create a branch named "dev": `git checkout -b dev`.
+
+### Developing
+
+Modify bugs and submit new functional code. For example, suppose the developer adds a USB driver:
+
+![Add a USB driver](figures/add_usb_driver.png)
+
+### Temporarily Store Modified Files
+
+Add all changes to the temporary area:
+
+```
+git add .
+```
+
+If you only want to add some specified files to the temporary area, use other commands of `git add`.
+
+### Commit
+
+Submit this modification to the local repository:
+
+```
+git commit -m "Describe your submission here"
+```
+
+> Note: If there are multiple commits in the local development branch, in order to ensure that the RT-Thread repository commit is clean, please tidy up the local commits. More than five commits are not accepted by Pull Request.。
+
+### Push to Your Remote Repository
+
+Push the modified content to the branch of your remote repository. It is recommended that the branch name of the remote repository be consistent with the local branch name.Use the following command to push:
+
+```
+git push origin YourBranchName
+```
+
+### Create a Pull Request
+
+Enter the RT-Thread repository under your Github account and click `New pull request -> Create pull request`. Make sure you choose the right branch.
+
+![Create a Pull Request](figures/pull_request_step2.png)
+
+Step 1: Fill in the title of this Pull Request
+
+Step 2: Modify the description information of this Pull Request (modify it in `Write` and preview it with `Preview`):
+
+- Modify PR Description: Replace the content in the red box below with the description of this pull request according to the requirements in the red box below.
+
+- Check PR Options: Fill in [x] in the OK Options check box to confirm. Note that there are no spaces on both sides of [x].
+
+![Modify PR Description and Check PR Options](figures/pr_description.png)
+
+Step 3：Create pull request.
+
+### Sign CLA
+
+The first contribution to RT-Thread requires signing the *Contributor License Agreement*.
+
+![Sign CLA](figures/cla.png)
+
+Make sure that CLA shows successful signing and CI compilation, as shown in the following figure:
+
+![CLA successful](figures/checkok.png)
+
+Note: Do not submit commmit using a non-GitHub account, or commit using a different account, which can lead to CLA signing failure.
+
+### Review Pull Request
+
+Once the request is successful, the RT-Thread maintainer can see the code you submitted. The code will be reviewed and comments will be filled in on GitHub. Please check the PR status in time and update the code according to the comments.
+
+### Merge Pull Request
+
+If the Pull Request code is okay, the code will be merged into the RT-Thread repository. This time Pull Request succeeded.
+
+So far, we have completed a code contribution process.
+
+## Keep in Sync with RT-Thread Repository
+
+The content of the RT-Thread GitHub repository is always updated. To develop based on the latest RT-Thread code, you need to update the local repository.
+
+After clone, the local master branch content is consistent with the master branch content of the RT-Thread repository. But when the RT-Thread repository is updated, your local code is different from the RT-Thread code.
+
+The local master is synchronized with the RT-Thread repository of your own GitHub account. If there is no content modification for the master branch (please create a new branch for development), then you can keep the local code synchronized with the RT-Thread repository according to the following steps:
+
+- To view the existing remote repository, there is usually only one default origin, which is your own remote repository:
+
+```c
+$ git remote -v
+origin  https://github.com/YOUR_USERNAME/YOUR_FORK.git (fetch)
+origin  https://github.com/YOUR_USERNAME/YOUR_FORK.git (push)
+```
+
+* Add the RT-Thread remote repository and name it `rtt`,  or you can customize the name by yourself:
+
+```c
+$ git remote add rtt https://github.com/RT-Thread/rt-thread.git
+```
+
+* View all remote repositories tracked locally:
+
+```c
+$ git remote -v
+origin    https://github.com/YOUR_USERNAME/YOUR_FORK.git (fetch)
+origin    https://github.com/YOUR_USERNAME/YOUR_FORK.git (push)
+rtt       https://github.com/RT-Thread/rt-thread.git (fetch)
+rtt       https://github.com/RT-Thread/rt-thread.git (push)
+```
+
+* Pull the code from the master branch of RT-Thread remote repository and merge it into the local master branch:
+
+```c
+git pull rtt master
+```
+
+## Reference
+
+* Refer to the [*GitHub - Contributing to a Project*](https://git-scm.com/book/en/v2/GitHub-Contributing-to-a-Project)  section of the official Git document for details.
+
+

documentation/device/rtc/rtc.md

@@ -0,0 +1,198 @@
+# RTC Device
+
+## Introduction of RTC
+
+The RTC (Real-Time Clock) provides accurate real-time clock time, which can be used to generate information such as year, month, day, hour, minute, and second. At present, most real-time clock chips use a higher precision crystal oscillator as a clock source. In order to work when the main power supply is powered down, some clock chips will be powered by a battery to keep the time information valid.
+
+The RT-Thread RTC device provides the basic services for the operating system's time system. In the face of more and more IoT scenarios, RTC has become the standard configuration of the product, and even in the secure transmission process such as SSL, RTC has become an indispensable part.
+
+
+## Access RTC Devices
+
+The application accesses the RTC hardware through the RTC device management interface, and the relevant interfaces are as follows:
+
+| **Function** | Description                |
+| ------------- | ---------------------------------- |
+| set_date()  | Set date, year, month, day |
+| set_time()     | Set time, hour, minute, second |
+| time()   | Obtain current time |
+
+### Set Date
+
+Set the current date value of the RTC device by the following functions:
+
+```c
+rt_err_t set_date(rt_uint32_t year, rt_uint32_t month, rt_uint32_t day)
+```
+
+| **Parameter** | **Description**                |
+| -------- | ---------------------------------- |
+|year      |The year to be set to take effect|
+|month     |The month to be set to take effect|
+|day       | The date to be set to take effect  |
+| **return** | ——                                 |
+| RT_EOK   | Set-up succeeded |
+| -RT_ERROR | Set-up failed, no rtc device found |
+| other error code | Set-up failed  |
+
+An example of use is as follows:
+
+```c
+/* Set the date to December 3, 2018 */
+set_date(2018, 12, 3);
+```
+
+### Set Time
+
+Set the current time value of the RTC device by the following function:
+
+```c
+rt_err_t set_time(rt_uint32_t hour, rt_uint32_t minute, rt_uint32_t second)
+```
+
+| **Parameter** | **Description**              |
+| ---------- | ------------------------------- |
+|hour         |The hour to be set to take effect|
+|minute        |The minute to be set to take effect|
+|second        |The second to be set to take effect|
+| **return** | ——                             |
+| RT_EOK   | Set-up succeeded |
+| -RT_ERROR | Set-up failed, no rtc device found |
+| other error code | Set-up failed   |
+
+An example of use is as follows:
+
+```c
+/* Set the time to 11:15:50 */
+set_time(11, 15, 50);
+```
+
+### Obtain Current Time
+
+Obtain time using the time API in the C standard library:
+
+```c
+time_t time(time_t *t)
+```
+
+| **Parameter** | **Description**              |
+| ---------- | ------------------------------- |
+|t          |Time data pointer      |
+| **return** | ——                             |
+| Current time value |  |
+
+Examples of use are as follows:
+
+```c
+time_t now;     /* Save the current time value obtained */
+/* Obtain Time */
+now = time(RT_NULL);
+/* Printout time information */
+rt_kprintf("%s\n", ctime(&now));
+```
+
+>Currently only one RTC device is allowed in the system and the name is `"rtc"`.
+
+## Functional Configuration
+
+### Enable Soft RTC (Software Emulation RTC)
+
+You can use the function of enabling RTC software emulation, which is ideal for products that do not require high time precision and have no hardware RTC. The configuration options of menuconfig are as follows:
+
+```c
+RT-Thread Components →
+    Device Drivers:
+        -*- Using RTC device drivers                                 /* Use RTC device driver */
+        [ ]   Using software simulation RTC device                   /* Use software simulation RTC device */
+```
+
+### Enable NTP Time Automatic Synchronization
+
+If the RT-Thread is connected to the Internet, you can enable automatic NTP time synchronization to synchronize local time periodically.
+
+First open the NTP function in menuconfig as follows:
+
+```c
+RT-Thread online packages →
+    IoT - internet of things →
+        netutils: Networking utilities for RT-Thread:
+             [*]   Enable NTP(Network Time Protocol) client
+```
+
+After the NTP is turned on, the RTC's automatic synchronization function will be automatically turned on, and the synchronization period and the delay time of the first synchronization can also be set:
+
+```c
+RT-Thread Components →
+    Device Drivers:
+        -*- Using RTC device drivers                                 /* Use RTC device driver */
+        [ ]   Using software simulation RTC device                   /* Use software simulation RTC device */
+        [*]   Using NTP auto sync RTC time                           /* Automatically synchronize RTC time with NTP */
+       (30)    NTP first sync delay time(second) for network connect /* The delay for performing NTP time synchronization for the first time. The purpose of the delay is to reserve a certain amount of time for the network connection and try to increase the success rate of the first NTP time synchronization. The default time is 30S； */
+       (3600)  NTP auto sync period(second)                          /* NTP The synchronization period is automatically synchronized in seconds, and the default period is one hour (ie 3600S). */
+```
+
+## FinSH Command
+
+Enter `date` to view the current time.
+
+```c
+msh />date
+Fri Feb 16 01:11:56 2018
+msh />
+```
+
+Also use the `date` command, after the command, enter `year` `month` `date` `hour ` ` minute ` ` second ` (between spaces, 24H system), and set the current time to 2018-02-16 01:15:30. The approximate effect is as follows:
+
+```c
+msh />date 2018 02 16 01 15 30
+msh />
+```
+
+## RTC Device Usage Examples
+
+For the specific usage of the RTC device, refer to the following example code. First, set the year, month, date, hour, minute and second information, and then delay the data for 3 seconds to get the current time information.
+
+```c
+/*
+ * Program listing: This is an RTC device usage routine
+ * The routine exports the rtc_sample command to the control terminal
+ * Command call format：rtc_sample
+ * Program function: Set the date and time of the RTC device. After a delay, obtain the current time and print the display.
+*/
+
+#include <rtthread.h>
+#include <rtdevice.h>
+
+static int rtc_sample(int argc, char *argv[])
+{
+    rt_err_t ret = RT_EOK;
+    time_t now;
+
+    /* Set date */
+    ret = set_date(2018, 12, 3);
+    if (ret != RT_EOK)
+    {
+        rt_kprintf("set RTC date failed\n");
+        return ret;
+    }
+
+    /* Set time */
+    ret = set_time(11, 15, 50);
+    if (ret != RT_EOK)
+    {
+        rt_kprintf("set RTC time failed\n");
+        return ret;
+    }
+
+    /* Delay 3 seconds */
+    rt_thread_mdelay(3000);
+
+    /* Obtain Time */
+    now = time(RT_NULL);
+    rt_kprintf("%s\n", ctime(&now));
+
+    return ret;
+}
+/* Export to the msh command list */
+MSH_CMD_EXPORT(rtc_sample, rtc sample);
+```

documentation/introduction/introduction.md

@@ -0,0 +1,37 @@
+# RT-Thread Introduction 
+
+As a beginner of RTOS, you might be new to RT-Thread. However, with a better understanding of it overtime, you will gradually discover the charm of RT-Thread and its advantages over other RTOSs of the same type. RT-Thread is an Embedded Real-time Operating System (RTOS) . After nearly 12 years of experiences accumulated, along with the rise of the Internet of Things, it is evolving into a powerful, component-rich IoT operating system.  
+
+## RT-Thread Overview 
+
+RT-Thread, short for Real Time-Thread, as its name implies, is an embedded real-time multi-threaded operating system. One of its basic properties is to support multi-tasking. Allowing multiple tasks to run at the same time does not mean that the processor actually performed multiple tasks at the same time. In fact, a processor core can only run one task at a time. Every task is executed quickly, and through the task scheduler  (the scheduler determines the sequence according to priority),  the tasks are switched rapidly which gives the illusion that multiple tasks are running at the same time. In the RT-Thread system, the task is implemented by threads. The thread scheduler in RT-Thread is the task scheduler mentioned above.
+
+RT-Thread is mainly written in C language, easy to understand and easy to port. It applies object-oriented programming methods to real-time system design, making the code elegant, structured, modular, and very tailorable. For resource-constrained Microcontroller Unit (MCU) systems, NANO  version (NANO is a minimum kernel officially released by RT-Thread in July 2017) that requires only 3KB of Flash and 1.2KB of RAM memory resources can be tailored with easy-to-use tools; for resource-rich IoT devices, RT-Thread can use the on-line software package management tool, together with system configuration tools, to achieve intuitive and rapid modular cutting, seamlessly import rich Software f0  eature packs, thus achieving complex functions like Android's graphical interface and touch sliding effects, smart voice interaction effects, and so on.
+
+Compared with the Linux operating system, RT-Thread is small in size, low in cost, low in power consumption and fast in startup. In addition, RT-Thread has high instantaneity and low occupation, which is very suitable for various resource constraints (such as cost, power consumption, etc.). Although the 32-bit MCU is its main operating platform, other CPUs, ones with MMU, ones based on ARM9, ARM11 and even the Cortex-A series CPUs are suitable for RT-Thread in specific applications.
+
+## License Agreement
+
+The RT-Thread system is a completely open source system, the 3.1.0 version and its earlier versions follow the GPL V2 + open source license agreement. Versions from the 3.1.0 version onwards follow the Apache License 2.0 open source license agreement. The RT-Thread system can be used free of charge in commercial products and does not require opening private code to the public.
+
+## RT-Thread Frame
+
+In recent years, the concept of Internet of Things (IoT) has become widely known , and the Internet of Things market has developed rapidly. The networking of embedded devices is the trend of the times. Terminal networking has greatly increased the complexity of software. The traditional RTOS kernel can hardly meet the needs of the market. In this case, the concept of the Internet of Things Operating System (IoT OS) came into being. **IoT operating system refers to the software platform that is based on operating system kernel (like RTOS, Linux, etc.) and includes relatively complete middleware components such as file system, graphics library, etc. It is low in consumption and high in secure, abides by the Communication Protocol and has cloud-connect abilities.** RT-Thread is an IoT OS. 
+
+One of the main differences between RT-Thread and many other RTOS such as FreeRTOS and uC/OS is that it is not only a real-time kernel, but also has a rich middle-tier component, as shown in the following figure.
+
+![RT-Thread Software Framework](figures/02Software_framework_diagram.png)
+
+It includes: 
+
+- Kernel layer: RT-Thread kernel, the core part of RT-Thread, includes the implementation of objects in the kernel system, such as multi-threading and its scheduling, semaphore, mailbox, message queue, memory management, timer, etc.; libcpu/BSP (Chip Migration Related Files/Board Support Package) is closely related to hardware and consists of peripheral drivers and CPU transport. 
+- Components and Service Layer: Components are based on upper-level software on top of the RT-Thread kernel, such as virtual file systems, FinSH command-line interfaces, network frameworks, device frameworks, and more. Its modular design allows for high internal cohesion within the assembly and low coupling between components.
+- RT-Thread software package: A general-purpose software component running on the RT-Thread IoT operating system platform for different application areas, consisting of description information, source code or library files. RT-Thread provides an open package platform with officially available or developer-supplied packages that provide developers with a choice of reusable packages that are an important part of the RT-Thread ecosystem. The package ecosystem is critical to the choice of an operating system because these packages are highly reusable and modular, making it easy for application developers to build the system they want in the shortest amount of time.  RT-Thread supports more than 60 software packages, listed below: 
+
+1. Internet of Things related software packages: Paho MQTT, WebClient, mongoose, WebTerminal, etc.
+2. Scripting language related software packages: JerryScript and MicroPython are currently supported.
+3. Multimedia related software packages: Openmv, mupdf.
+4. Tools packages: CmBacktrace, EasyFlash, EasyLogger, SystemView.
+5. System related software packages: RTGUI, Persimmon UI, lwext4, partition, SQLite, etc.
+6. Peripheral library and driver software packages: RealTek RTL8710BN SDK.
+7. Others.