Merge pull request #3438 from Cathy-lulu/update-readme

update readme

Author: BernardXiong

README.md

@@ -9,76 +9,154 @@
 [![GitHub pull-requests](https://img.shields.io/github/issues-pr/RT-Thread/rt-thread.svg)](https://github.com/RT-Thread/rt-thread/pulls)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat)](https://github.com/RT-Thread/rt-thread/pulls)
 
-RT-Thread is an open source IoT operating system from China, which has strong scalability: from a tiny kernel running on a tiny core, for example ARM Cortex-M0, or Cortex-M3/4/7, to a rich feature system running on MIPS32, ARM Cortex-A8, ARM Cortex-A9 DualCore etc.
+# Introduction
 
-## Overview ##
+RT-Thread was born in 2006, it is an open source, neutral, and community-based real-time operating system (RTOS). 
 
-RT-Thread RTOS like a traditional real-time operating system. The kernel has real-time multi-task scheduling, semaphore, mutex, mail box, message queue, signal etc. However, it has three different things:
+RT-Thread is mainly written in C language, easy to understand and easy to port(can be quickly port to a wide range of mainstream MCUs and module chips). It applies object-oriented programming methods to real-time system design, making the code elegant, structured, modular, and very tailorable. 
 
-* Device Driver;
-* Component;
-* Dynamic Module
 
-The device driver is more like a driver framework, UART, IIC, SPI, SDIO, USB device/host, EMAC, MTD NAND etc. The developer can easily add low level driver and board configuration, then combined with the upper framework, he/she can use lots of features.
+RT-Thread has Standard version and Nano version. For resource-constrained microcontroller (MCU) systems, the NANO kernel version that requires only 3KB Flash and 1.2KB RAM memory resources can be tailored  with easy-to-use tools; And 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 packages, thus achieving complex functions like Android's graphical interface and touch sliding effects, smart voice interaction effects, and so on.
 
-The Component is a software concept upon RT-Thread kernel, for example a shell (finsh/msh shell), virtual file system (FAT, YAFFS, UFFS, ROM/RAM file system etc), TCP/IP protocol stack (lwIP), POSIX (thread) interface etc. One component must be a directory under RT-Thread/Components and one component can be descripted by a SConscript file (then be compiled and linked into the system).
 
-The Dynamic Module, formerly named as User Applicaion (UA) is a dynamic loaded module or library, it can be compiled standalone without Kernel. Each Dynamic Module has its own object list to manage thread/semaphore/kernel object which was created or initialized inside this UA. More information about UA, please visit another [git repo](https://github.com/RT-Thread/rtthread-apps).
+## RT-Thread Architecture
 
-## Board Support Package ##
+RT-Thread has not only a real-time kernel, but also rich components. Its architecture is as follows:
 
-RT-Thread RTOS can support many architectures:
 
-* ARM Cortex-M0
-* ARM Cortex-M3/M4/7
-* ARM Cortex-R4
-* ARM Cortex-A8/A9
-* ARM920T/ARM926 etc
-* MIPS32
-* x86
-* Andes
-* C-Sky
-* RISC-V
-* PowerPC
+![architecture](./documentation/figures/architecture.png)
 
-## License ##
 
-RT-Thread is Open Source software under the Apache License 2.0 since RT-Thread v3.1.1. License and copyright information can be found within the code.
 
-    /*
-     * Copyright (c) 2006-2018, RT-Thread Development Team
-     *
-     * SPDX-License-Identifier: Apache-2.0
-     */
+It includes:
 
-Since 9th of September 2018, PRs submitted by the community may be merged into the main line only after signing the Contributor License Agreement(CLA).
+- 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 porting.
 
-## Usage ##
+- 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 inside the components 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 180 software packages. 
 
-RT-Thread RTOS uses [scons](http://www.scons.org) as building system. Therefore, please install scons and Python 2.7 firstly. 
-So far, the RT-Thread scons building system support the command line compile or generate some IDE's project. There are some option varaibles in the scons building script (rtconfig.py):
+## RT-Thread Features
 
-* ```CROSS_TOOL``` the compiler which you want to use, gcc/keil/iar. 
-* ```EXEC_PATH``` the path of compiler. 
+- Designed for resource-constrained devices, the minimum kernel requires only 1.2KB of RAM and 3 KB of Flash.                                                                                                              
 
-In SConstruct file:
+- Has rich components and a prosperous and fast growing package ecosystem.                                                              
 
-```RTT_ROOT``` This variable is the root directory of RT-Thread RTOS. If you build the porting in the bsp directory, you can use the default setting. Also, you can set the root directory in ```RTT_ROOT``` environment variable and not modify SConstruct files.
+- Elegant code style, easy to use, read and master.                                                                                                                                                                             
 
-When you set these variables correctly, you can use command:
+- High Scalability. RT-Thread has high-quality scalable software architecture, loose coupling, modularity, is easy to tailor and expand.                                                                                                                                                                           
 
-    scons
+- Supports high-performance applications.                                                                                                                    
 
-under BSP directory to simplely compile RT-Thread RTOS.
+- Supports cross-platform and a wide range of chips.                                                                                                          
 
-If you want to generate the IDE's project file, you can use command:
+## Code Catalogue
 
-    scons --target=mdk/mdk4/mdk5/iar/cb -s
+   RT-Thread source code catalog is shown as follow:
 
-to generate the project file.
+| Name          | Description                                             |
+| ------------- | ------------------------------------------------------- |
+| BSP          | Board Support Package based on the porting of various development boards |
+| components    | RT-Thread's individual component codes, such as finsh, gui, etc.， |
+| documentation | Related documents, like coding regulation, etc.,        |
+| examples      | Related sample code                                     |
+| include       | Head file of RT-Thread kernel                           |
+| libcpu        | Porting code for all types of chips. |
+| src           | The source file for the RT-Thread kernel. |
+| tools         | The script file for the RT-Thread command build tool. |
+
+RT-Thread has now been ported for nearly 90 development boards, most BSPs support MDK, IAR development environment and GCC compiler, and have provided default MDK and IAR project, which allows users to add their own application code directly based on the project. Each BSP has a similar directory structure, and most BSPs provide a README.md file, which is a markdown-format file that contains the basic introduction of BSP, and introduces how to simply start using BSP.
+
+Env is a development tool developed by RT-Thread which provides a build environment, graphical system configuration, and package management capabilities for project based on the RT-Thread operating system. Its built-in `menuconfig` provides an easy-to-use configuration tailoring tool. It can tailor the kernels, components and software packages freely, so that the system can be constructed by building blocks.
+
+
+- [Download Env Tool](https://www.rt-thread.io/download.html?download=Env)
+- [User manual of Env](https://github.com/RT-Thread/rtthread-manual-doc/blob/master/env/env.md)
+
+# Resources
+
+## Supported Architectures
+
+RT-Thread supports 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
+- RT-Thread Studio
+
+Use Python-based [scons](http://www.scons.org/) for command-line builds.
+
+RT-Thread Studio Demonstration:
+
+![studio](./documentation/figures/studio.gif)                                                 
+
+
+## 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)](https://github.com/RT-Thread/rtthread-manual-doc/blob/master/documentation/quick_start_qemu/quick_start_qemu.md)
+
+- [Getting Started of QEMU (Ubuntu)](https://github.com/RT-Thread/rtthread-manual-doc/blob/master/documentation/quick_start_qemu/quick_start_qemu_linux.md)
+
+## Documentation
+
+[RT-Thread Programming Guide](https://github.com/RT-Thread/rtthread-manual-doc) | [RT-Thread Supported Chips & Boards](https://www.rt-thread.io/board.html) |
+[RT-Thread Software Package](https://github.com/RT-Thread/packages) | [RT-Thread Studio](https://www.rt-thread.io/studio.html) 
+
+## Sample
+
+[Kernel Sample](https://github.com/RT-Thread-packages/kernel-sample) | [Device Sample Code](https://github.com/RT-Thread-packages/peripheral-sample) | [File System Sample Code](https://github.com/RT-Thread-packages/filesystem-sample ) | [Network Sample Code](https://github.com/RT-Thread-packages/network-sample ) | 
+
+[Based on the STM32L475 IoT Board SDK](https://github.com/RT-Thread/IoT_Board) | [Based on the W601 IoT Board SDK](https://github.com/RT-Thread/W601_IoT_Board)
+
+# License
+
+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.
+
+# Community
+
+
+RT-Thread is very grateful for the support from all community developers, and if you have any ideas, suggestions or questions in the process of using RT-Thread, RT-Thread can be reached by the following means, and we are also updating RT-Thread in real time on these channels. At the same time, 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.
+
+[Website](https://www.rt-thread.io) | [Twitter](https://twitter.com/rt_thread) | [Youtube]( https://www.youtube.com/channel/UCdDHtIfSYPq4002r27ffqPw?view_as=subscriber) | [Gitter](  https://gitter.im/RT-Thread) | [Facebook](https://www.facebook.com/RT-Thread-IoT-OS-110395723808463/?modal=admin_todo_tour) | [Medium](https://medium.com/@rt_thread)
+
+# 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](https://github.com/RT-Thread/rtthread-manual-doc/blob/master/documentation/contribution_guide/contribution_guide.md).
 
-NOTE: RT-Thread scons building system will tailor the system according to your rtconfig.h configuration header file. For example, if you disable the lwIP in the rtconfig.h by commenting the ```#define RT_USING_LWIP```, the generated project file should have no lwIP related files.
 
-## Contribution ##
 
-Please refer the contributors in the github. Thank all of RT-Thread Developers.