更新 rti 2.0 版本

rti 2.0版本

.gitignore

@@ -1,52 +0,0 @@
-# Prerequisites
-*.d
-
-# Object files
-*.o
-*.ko
-*.obj
-*.elf
-
-# Linker output
-*.ilk
-*.map
-*.exp
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Libraries
-*.lib
-*.a
-*.la
-*.lo
-
-# Shared objects (inc. Windows DLLs)
-*.dll
-*.so
-*.so.*
-*.dylib
-
-# Executables
-*.exe
-*.out
-*.app
-*.i*86
-*.x86_64
-*.hex
-
-# Debug files
-*.dSYM/
-*.su
-*.idb
-*.pdb
-
-# Kernel Module Compile Results
-*.mod*
-*.cmd
-.tmp_versions/
-modules.order
-Module.symvers
-Mkfile.old
-dkms.conf

LICENSE

@@ -1,504 +0,0 @@
-                  GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-(This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.)
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-                  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-                            NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    {description}
-    Copyright (C) {year} {fullname}
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
-    USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random
-  Hacker.
-
-  {signature of Ty Coon}, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!

README.md

@@ -1,273 +1,49 @@
-# RTI
+# RT-Insight 软件包
 
-## 介绍
+## 简介
 
-RT-Thread Insight 是一个应用在 RT-Thread 上，用于展示系统内部运行信息的组件 。
+RT_Insight 是基于 RT-Thread 内核的**系统事件洞察组件**，核心功能是通过注册 RT-Thread 系统钩子函数，实时记录线程调度、ISR 进出、内核对象操作（信号量 / 互斥锁 / 队列等）、定时器回调等关键事件，并结合 DWT（数据观察点与跟踪单元）提供纳秒级高精度时间戳，最终通过 RT-Tunnel 组件传输事件数据，助力嵌入式开发者快速定位系统卡顿、线程竞争、定时器异常等问题。
 
-它能够记录系统内部的中断、线程以及软件定时器的运行情况，并将记录的数据经过编码之后暂存到缓冲区中。然后等待 usb 、以太网、串口或其他方式读取并发送到PC端上。
+## 主要特性
 
-### 目录结构
+- 全场景事件覆盖
 
-| 名称 | 说明 |
-| ---- | ---- |
-| docs  | 文档目录 |
-| inc  | 头文件目录 |
-| src  | 源代码目录 |
+  ：注册 RT-Thread 全量核心钩子，自动记录以下事件：
 
-### 许可证
+  - 线程调度（线程切换、挂起 / 恢复）；
+  - ISR 生命周期（中断进入 / 退出，自动获取 IRQ ID）；
+  - 内核对象操作（信号量 / 互斥锁 / 事件 / 邮箱 / 队列的获取 / 释放 / 尝试获取）；
+  - 定时器回调（定时器进入 / 退出）。
 
+- **高精度时间戳**：基于 DWT cycle counter 实现纳秒级时间戳，事件时间精度可达 CPU 时钟周期级（需配置正确的 `BOARD_SYSTICK_FREQ_IN_HZ`）。
 
+- **事件安全缓存**：内置 `TEMP_BUFFER_SIZE`（默认 64）临时缓冲区，当 RT-Tunnel 忙时自动缓存事件，避免数据丢失，后续自动重试写入。
 
-### 依赖
+- **依赖 RT-Tunnel 传输**：事件数据通过 RT-Tunnel 组件传输（隧道 ID 固定为 `0x52544953`，即 "RTIS"），兼容 RT-Tunnel 的线程安全传输机制。
 
-- RT-Thread 3.0+
+- **Shell 快速初始化**：提供 `RT_Insight_Init` 命令，通过 RT-Thread Shell 一键初始化组件，无需手动调用接口。
 
-## 获取方式
+- **清晰错误日志**：初始化失败（如 RT-Tunnel 获取失败、隧道配置错误）时输出明确日志，便于问题定位。
 
-使用 rti package 需要在 RT-Thread 的包管理器中选择它，具体路径如下：
 
-```
- RT-Thread online packages  --->
-     system packages  --->
-         [*] a rti package for rt-thread  --->
-             rti version (v1.0.0)  --->
-         (RT-Thread RTI) App name 
-         (4096) RTI buffer size 
-         (0x20000000) RAM base
-         (2)   Event ID offset
-         (I#15=systick) System description 0
-         () System description 1
-```
 
-这些配置项的具体作用见下表：
+## 核心配置
 
-| 配置               | 作用                                                         |
-| ------------------ | ------------------------------------------------------------ |
-| App name           | 配置APP的名称                                                |
-| RTI buffer size    | 配置RTI 缓冲区大小                                           |
-| RAM base           | 配置 RAM 的基地址                                            |
-| Event ID offset    | 配置事件ID的偏移位数，值越大占用的内存越少。默认值：2        |
-| System description | 配置系统描述符 作用是给中断事件起一个别名，默认中断标号15为systick |
+- CPU_freq：设置设置为 MCU 实际的主频，确保时间戳计算准确。
 
-配置完成后让 RT-Thread 的包管理器自动更新，或者使用 pkgs --update 命令更新包到 BSP 中。
 
-## 使用示例 ##
 
-例如：使用 rdb shell 和 rti 配合：
+## 快速上手
 
-打开 rti package 后，还要打开 rdb package ，具体路径如下：
-```
- Privated Packages of RealThread  --->
-        [*] rdb:RT-Thread Debug Bridge                                                         
-               rdb version (v1.0.1)  --->
-```
+### 初始化流程
 
-rdb package 版本要选择  v1.0.1，并且下载到本地之后要手动将分支切换到远端最新代码然后重新生成工程
+RT_Insight 需在 RT-Tunnel 初始化后启动，推荐初始化顺序：
 
-首先在 env 输入命令 `rdb shell` 进入rdb shell 模式，然后输入 rti_start_record 开始录制，输入 rti_stop_record 结束录制
+1. **初始化 RT-Tunnel**：确保 `RT_Tunnel_Init` 先执行（通常自动初始化）；
+2. **初始化 RT_Insight**：调用 `RT_Insight_Init` 分配隧道并初始化insight功能；
 
-录制的数据文件默认存放在  ” D:\RT-Thread_RTI.SVDat “
 
-利用 SystemView 上位机加载录制的数据文件即可分析系统的运行状态。
-### 工作机制 ###
 
-![工作流程图](doc/image/工作流程图.png)
-
-
-## API 说明 ##
-
-### API 列表 ###
-
-| API                               | 作用                      |
-| --------------------------------- | ------------------------- |
-| rti_start                         | 启动 RTI                  |
-| rti_stop                          | 关闭 RTI                  |
-| rti_trace_disable                 | 屏蔽 RTI 监视事件开始     |
-| rti_trace_enable                  | 屏蔽 RTI 监视事件结束     |
-| rti_buffer_used                   | 查看 RTI 缓冲区已使用大小 |
-| rti_data_get                      | 从 RTI 的缓冲区读出数据   |
-| rti_data_new_data_notify_set_hook | 设置 RTI 新数据通知函数   |
-
-### API 详解 ###
-
-rti_start()
-
-**函数原型** 
-
-```
-void rti_start(void);
-```
-
-这个函数的作用是启动 RTI
-
-**函数参数** 无
-
-**函数返回** 无
-
-
-
-rti_stop()
-
-**函数原型** 
-
-```
-void rti_stop(void);
-```
-
-这个函数的作用是关闭 RTI
-
-**函数参数** 无
-
-**函数返回** 无
-
-
-
-rti_trace_disable()
-
-**函数原型** 
-
-```
-void rti_trace_disable(rt_uint16_t flag);
-```
-
-这个函数的作用是使 RTI 不再监视与 flag 对应的系统事件
-
-**函数参数**
-
-| 参数 | 描述             |
-| ---- | ---------------- |
-| flag | 要屏蔽的事件名称 |
-
-**可选参数** 如下：
-
-```
-RTI_SEM        /* 信号量 */
-RTI_MUTEX      /* 互斥量 */
-RTI_EVENT      /* 事件 */
-RTI_MAILBOX    /* 邮箱 */
-RTI_QUEUE      /* 消息队列 */
-RTI_THREAD     /* 线程 */
-RTI_SCHEDULER  /* 调度器 */
-RTI_INTERRUPT  /* 中断 */
-RTI_TIMER      /* 定时器 */
-RTI_ALL        /* 所有的事件 */
-```
-
-**函数返回** 无
-
-**使用范例**
-
-在一些不想被 RTI 监控的地方可以用函数 rti_trace_disable() 和 rti_trace_enable() 配合将其屏蔽起来
-
-```{.c}
-rti_trace_disable(RTI_EVENT);
-rt_event_send(rti_event, RTI_START_FLAG);
-rti_trace_enable(RTI_EVENT);
-```
-
-因为两个函数运行之间发生的所有 EVENT 事件都将被屏蔽，所以两个函数之间被屏蔽的函数应尽量少的运行时间，更不能一直挂起等待事件到来。
-
-
-
-rti_trace_enable()
-
-**函数原型** 
-
-```
-void rti_trace_enable(rt_uint16_t flag);
-```
-
-这个函数的作用是使 RTI 恢复监视与 flag 对应的系统事件
-
-**函数参数**
-
-| 参数 | 描述             |
-| ---- | ---------------- |
-| flag | 要监视的事件名称 |
-
-**可选参数** 与 rti_trace_disable 的一样
-
-**函数返回** 无
-
-**注意事项**
-
-与函数 rti_trace_disable 配合使用，必须成对出现且传入参数也应一致。
-
-
-
-rti_buffer_used
-
-**函数原型** 
-
-```
-rt_size_t rti_buffer_used(void);
-```
-
-这个函数的作用是查询 RTI 缓冲区已使用的大小
-
-**函数参数** 无
-
-**函数返回**  RTI 缓冲区已经使用的字节数
-
-
-
-rti_data_get
-
-**函数原型** 
-
-```
-rt_size_t rti_data_get(rt_uint8_t *ptr, rt_uint16_t length);
-```
-
-这个函数的作用是从 RTI 的缓冲区里读出 length 大小的数据并存放到 ptr 指向的地址空间
-
-**函数参数**
-
-| 参数   | 描述                                  |
-| ------ | ------------------------------------- |
-| ptr    | 从 RTI 读出数据要存放的地址空间首地址 |
-| length | 从 RTI 读出数据的长度                 |
-
-**函数返回** 从 RTI 成功读出的数据的大小
-
-
-
-rti_data_new_data_notify_set_hook
-
-**函数原型** 
-
-```
-void rti_data_new_data_notify_set_hook(void (*hook)(void));
-```
-
-这个函数的作用是注册一个 RTI 的新数据通知函数，每当缓冲区的数据达到一个数据包的大小时，RTI 都会调用这个函数。
-
-**函数参数**
-
-| 参数 | 描述                     |
-| ---- | ------------------------ |
-| hook | 要注册的通知函数的函数名 |
-
-**函数返回** 无
-
-**使用范例**
-
-可以在使用 RTI 之前先注册 RTI 的新数据通知函数
-
-```{.c}
-void rti_start_record(void)
-{
-    rti_data_new_data_notify_set_hook(rti_data_new_data_notify);
-    rti_start();
-}
-```
-
-也可以在这个函数里直接向外传输数据，不用一直调用函数 rti_buffer_used 检测缓冲区使用情况。
-
-
-
-
-## 注意事项
-
-> 说明：列出在使用这个 package 过程中需要注意的事项；列出常见的问题，以及解决办法。
+## 注意
 
+确保 RT-Tunnel 已启用，且 `TUNNEL_NUM` 至少为 1

RT_insight.c

@@ -0,0 +1,366 @@
+#include "RT_insight.h"
+
+/* ============================================================
+ *                Hardware / System Configuration
+ * ============================================================ */
+// #define BOARD_SYSTICK_FREQ_IN_HZ         (168000000ULL) /**< CPU Systick frequency */
+#define RT_INSIGHT_TUNNEL_ID             (0x52544953UL) /**< Unique ID for RT Insight tunnel ("RTIS") */
+#define Frame_Header_Reserve_Value       (0x55AA0000UL) /**< Frame header reserved pattern */
+#define SysTick_IRQ_ID                   (0x0000000FUL) /**< SysTick IRQ ID */
+#define SysTick_Cnt_Register             (0xE000E018UL) /**< SysTick current count register */
+#define SysTick_Reload_Register          (0xE000E014UL) /**< SysTick reload value register */
+#define Interrupt_Control_State_Register (0xE000ED04UL) /**< Interrupt control/state register */
+
+#define DWT_CYCCNT      (0xE0001004UL) /**< DWT cycle counter register */
+#define DWT_CTRL        (0xE0001000UL) /**< DWT control register */
+#define CoreDebug_DEMCR (0xE000EDFCUL) /**< Debug control register */
+
+#define DWT_CTRL_CYCCNTENA_Msk     (1UL << 0)  /**< Enable cycle counter */
+#define CoreDebug_DEMCR_TRCENA_Msk (1UL << 24) /**< Enable DWT & ITM */
+
+#define TEMP_BUFFER_SIZE 64 /**< The maximum number of entries that can be stored in the temporary buffer */
+
+/* ============================================================
+ *                       Global Variables
+ * ============================================================ */
+rt_tick_t Time_Stamp_Tick;    /**< Current OS tick count */
+uint64_t  Time_Stamp_ns;      /**< Current time in nanoseconds */
+uint64_t  Per_OSTick_ns;      /**< Duration of one OS tick (ns) */
+double    Per_SysTick_Cnt_ns; /**< Duration per SysTick count (ns) */
+
+uint32_t SysTick_Timer_Cnt;    /**< Current SysTick counter value */
+uint32_t SysTick_Timer_Reload; /**< SysTick reload value */
+
+RT_tunnel_t Tunnel;        /**< Tunnel instance for transmitting insight events */
+uint32_t    Event_Num_Cnt; /**< Sequential event number counter */
+
+uint32_t DWT_Last_Cnt = 0; /**< Last DWT counter value */
+uint32_t DWT_Timer_hi = 0; /**< Overflow counter for DWT */
+
+RT_insight_info Temp_Info_Buffer[TEMP_BUFFER_SIZE] = {0}; /**< Backup buffer for failed writes */
+uint32_t        Temp_Info_Buffer_Index             = 0;   /**< Current write index of the temporary buffer */
+uint32_t        Temp_Info_Buffer_Last_Index        = 0;   /**< Last successfully written index in the temporary buffer */
+
+/* ============================================================
+ *                   Time & Event Utilities
+ * ============================================================ */
+
+/**
+ * @brief Initialize DWT timer for precise CPU time measurement.
+ */
+int CPU_TS_TmrInit(void)
+{
+    /* Enable DWT trace and cycle counter */
+    *(volatile uint32_t *)CoreDebug_DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
+
+    /* Reset DWT cycle counter */
+    *(volatile uint32_t *)DWT_CYCCNT = 0;
+
+    /* Enable DWT cycle counter */
+    *(volatile uint32_t *)DWT_CTRL |= DWT_CTRL_CYCCNTENA_Msk;
+
+    return 0;
+}
+
+/**
+ * @brief Get current CPU timestamp in nanoseconds.
+ * @note  Combines DWT low/high counter to form 64-bit time.
+ */
+static uint64_t Get_Time_Stamp_ns(void)
+{
+    uint32_t DWT_Cnt = *(volatile uint32_t *)DWT_CYCCNT;
+
+    /* Handle DWT counter overflow */
+    if (DWT_Cnt < DWT_Last_Cnt)
+    {
+        DWT_Timer_hi += 1;
+    }
+    DWT_Last_Cnt = DWT_Cnt;
+
+    uint64_t full_cycle = ((uint64_t)DWT_Timer_hi << 32) | DWT_Cnt;
+    uint64_t time_ns    = (uint64_t)(Per_SysTick_Cnt_ns * full_cycle);
+
+    return time_ns;
+}
+
+/* ============================================================
+ *                   Event Recording Logic
+ * ============================================================ */
+
+/**
+ * @brief Record an insight event to tunnel.
+ *
+ * @param[in] ID         Event ID or object identifier
+ * @param[in] track_type Event type (thread, ISR, object, timer)
+ */
+static void Event_Record(uint32_t ID, uint32_t track_type)
+{
+    int32_t         write_res    = 0;
+    RT_insight_info Insight_Info = {0};
+
+    /* Generate timestamp */
+    Time_Stamp_ns = Get_Time_Stamp_ns();
+
+    /* Fill event structure */
+    Insight_Info.Frame_Header     = Frame_Header_Reserve_Value | (Event_Num_Cnt & 0xFFFF);
+    Insight_Info.ID               = ID;
+    Insight_Info.Track_Type       = track_type;
+    Insight_Info.Time_Stamp_ns_lo = (uint32_t)(Time_Stamp_ns & 0xFFFFFFFF);
+    Insight_Info.Time_Stamp_ns_hi = (uint32_t)(Time_Stamp_ns >> 32);
+
+    /* Handle pending buffer (atomic update) */
+    rt_base_t level             = rt_hw_interrupt_disable();
+    uint32_t  Last_Index        = Temp_Info_Buffer_Last_Index;
+    uint32_t  Index             = Temp_Info_Buffer_Index;
+    Temp_Info_Buffer_Last_Index = Temp_Info_Buffer_Index;
+    rt_hw_interrupt_enable(level);
+
+    /* Try to flush previous buffered events first */
+    if (Index != Last_Index)
+    {
+        uint32_t len = (Index > Last_Index) ? (Index - Last_Index) : (Index + TEMP_BUFFER_SIZE - Last_Index);
+
+        for (uint32_t i = 0; i < len; i++)
+        {
+            write_res = Tunnel->write(Tunnel, (void *)&Temp_Info_Buffer[Last_Index], sizeof(RT_insight_info));
+            if (write_res != sizeof(RT_insight_info))
+            {
+                break;
+            }
+
+            Last_Index = (Last_Index + 1) % TEMP_BUFFER_SIZE;
+        }
+
+        Temp_Info_Buffer_Last_Index = Last_Index;
+    }
+
+    /* Attempt to write the new event */
+    write_res = Tunnel->write(Tunnel, (void *)&Insight_Info, sizeof(RT_insight_info));
+
+    /* If write fails (-2 = tunnel busy), store into temp buffer */
+    if ((write_res == TUNNEL_BUSY_CODE) && ((Tunnel->status & STATUS_BUFFER_Msk) == STATUS_BUFFER_AVAILABLE))
+    {
+        rt_memcpy(&Temp_Info_Buffer[Temp_Info_Buffer_Index], &Insight_Info, sizeof(Insight_Info));
+        Temp_Info_Buffer_Index = (Temp_Info_Buffer_Index + 1) % TEMP_BUFFER_SIZE;
+    }
+
+    /* Update event counter */
+    Event_Num_Cnt++;
+}
+
+/* ============================================================
+ *               RT-Thread Hook Implementations
+ * ============================================================ */
+
+/**
+ * @brief Scheduler hook: called during thread switch.
+ *
+ * @param[in] from_thread Thread being switched out
+ * @param[in] to_thread   Thread being switched in
+ */
+static void rt_view_scheduler_hook(rt_thread_t from_thread, rt_thread_t to_thread)
+{
+    if (from_thread)
+    {
+        Event_Record((uint32_t)&from_thread->sp, THREAD_EXIT);
+        Event_Record((uint32_t)&to_thread->sp, THREAD_RUN);
+    }
+}
+
+/**
+ * @brief Called when a thread is resumed.
+ *
+ * @param[in] thread Thread being resumed
+ */
+static void rt_view_thread_resume_hook(rt_thread_t thread)
+{
+    Event_Record((uint32_t)&thread->sp, THREAD_RESUME);
+}
+
+/**
+ * @brief Called when a thread is suspended.
+ *
+ * @param[in] thread Thread being suspended
+ */
+static void rt_view_thread_suspend_hook(rt_thread_t thread)
+{
+    Event_Record((uint32_t)&thread->sp, THREAD_SUSPEND);
+}
+
+/**
+ * @brief Called when entering an ISR.
+ */
+static void rt_view_ISR_enter_hook(void)
+{
+    uint32_t ISR_ID = (*(volatile uint32_t *)Interrupt_Control_State_Register) & 0xFF;
+    Event_Record(ISR_ID, IRQ_ENTER);
+}
+
+/**
+ * @brief Called when leaving an ISR.
+ */
+static void rt_view_ISR_leave_hook(void)
+{
+    uint32_t ISR_ID = (*(volatile uint32_t *)Interrupt_Control_State_Register) & 0xFF;
+    Event_Record(ISR_ID, IRQ_EXIT);
+}
+
+/**
+ * @brief Called when taking an RTOS object (semaphore, mutex, etc.)
+ *
+ * @param[in] object Pointer to the RTOS object
+ */
+static void rt_view_object_take_hook(struct rt_object *object)
+{
+    switch (object->type & (~RT_Object_Class_Static))
+    {
+    case RT_Object_Class_Semaphore:
+        Event_Record((uint32_t)object->name, SEM_TAKE);
+        break;
+    case RT_Object_Class_Mutex:
+        Event_Record((uint32_t)object->name, MUTEX_TAKE);
+        break;
+    case RT_Object_Class_Event:
+        Event_Record((uint32_t)object->name, EVENT_TAKE);
+        break;
+    case RT_Object_Class_MailBox:
+        Event_Record((uint32_t)object->name, MAILBOX_TAKE);
+        break;
+    case RT_Object_Class_MessageQueue:
+        Event_Record((uint32_t)object->name, QUEUE_TAKE);
+        break;
+    }
+}
+
+/**
+ * @brief Called when trying to take an RTOS object (non-blocking).
+ *
+ * @param[in] object Pointer to the RTOS object
+ */
+static void rt_view_object_trytake_hook(struct rt_object *object)
+{
+    switch (object->type & (~RT_Object_Class_Static))
+    {
+    case RT_Object_Class_Semaphore:
+        Event_Record((uint32_t)object->name, SEM_TRYTAKE);
+        break;
+    case RT_Object_Class_Mutex:
+        Event_Record((uint32_t)object->name, MUTEX_TRYTAKE);
+        break;
+    case RT_Object_Class_Event:
+        Event_Record((uint32_t)object->name, EVENT_TRYTAKE);
+        break;
+    case RT_Object_Class_MailBox:
+        Event_Record((uint32_t)object->name, MAILBOX_TRYTAKE);
+        break;
+    case RT_Object_Class_MessageQueue:
+        Event_Record((uint32_t)object->name, QUEUE_TRYTAKE);
+        break;
+    }
+}
+
+/**
+ * @brief Called when releasing an RTOS object.
+ *
+ * @param[in] object Pointer to the RTOS object
+ */
+static void rt_view_object_relase_hook(struct rt_object *object)
+{
+    switch (object->type & (~RT_Object_Class_Static))
+    {
+    case RT_Object_Class_Semaphore:
+        Event_Record((uint32_t)object->name, SEM_RELEASE);
+        break;
+    case RT_Object_Class_Mutex:
+        Event_Record((uint32_t)object->name, MUTEX_RELEASE);
+        break;
+    case RT_Object_Class_Event:
+        Event_Record((uint32_t)object->name, EVENT_RELEASE);
+        break;
+    case RT_Object_Class_MailBox:
+        Event_Record((uint32_t)object->name, MAILBOX_RELEASE);
+        break;
+    case RT_Object_Class_MessageQueue:
+        Event_Record((uint32_t)object->name, QUEUE_RELEASE);
+        break;
+    }
+}
+
+/**
+ * @brief Called when a timer callback starts.
+ *
+ * @param[in] t Timer instance
+ */
+static void rt_view_timer_enter_hook(rt_timer_t t)
+{
+    Event_Record((uint32_t)t->parent.name, TIMER_ENTER);
+}
+
+/**
+ * @brief Called when a timer callback ends.
+ *
+ * @param[in] t Timer instance
+ */
+static void rt_view_timer_exit_hook(rt_timer_t t)
+{
+    Event_Record((uint32_t)t->parent.name, TIMER_EXIT);
+}
+
+/* ============================================================
+ *                   RT Insight Initialization
+ * ============================================================ */
+
+/**
+ * @brief Initialize RT Insight module and register all RT-Thread hooks.
+ *
+ * @retval int 0 on success, non-zero on failure.
+ */
+int RT_Insight_Init(void)
+{
+    Event_Num_Cnt        = 0;
+    SysTick_Timer_Reload = *(volatile uint32_t *)SysTick_Reload_Register;
+    Per_OSTick_ns        = 1000000000ULL / RT_TICK_PER_SECOND;
+    Per_SysTick_Cnt_ns   = 1000000000.0 / BOARD_SYSTICK_FREQ_IN_HZ;
+
+    /* Get a free tunnel instance */
+    Tunnel = Get_Free_Tunnel();
+    if (Tunnel == RT_NULL)
+    {
+        LOG_ERROR("Get free tunnel error");
+        return -1;
+    }
+
+    /* Configure tunnel */
+    if (Set_Tunnel_ID(Tunnel, RT_INSIGHT_TUNNEL_ID) != 0)
+    {
+        LOG_ERROR("Set tunnel ID error");
+        return -1;
+    }
+
+    if (Set_Tunnel_Operation(Tunnel, tunnel_write) != 0)
+    {
+        LOG_ERROR("Set tunnel operation error");
+        return -1;
+    }
+
+    /* Initialize timestamp source */
+    CPU_TS_TmrInit();
+
+    /* Register RT-Thread system hooks */
+    rt_scheduler_sethook(rt_view_scheduler_hook);
+    rt_thread_resume_sethook(rt_view_thread_resume_hook);
+    rt_thread_suspend_sethook(rt_view_thread_suspend_hook);
+
+    rt_interrupt_enter_sethook(rt_view_ISR_enter_hook);
+    rt_interrupt_leave_sethook(rt_view_ISR_leave_hook);
+
+    rt_object_trytake_sethook(rt_view_object_trytake_hook);
+    rt_object_take_sethook(rt_view_object_take_hook);
+    rt_object_put_sethook(rt_view_object_relase_hook);
+
+    rt_timer_enter_sethook(rt_view_timer_enter_hook);
+    rt_timer_exit_sethook(rt_view_timer_exit_hook);
+
+    return 0;
+}
+MSH_CMD_EXPORT(RT_Insight_Init, RT_Insight_Init);

RT_insight.h

@@ -0,0 +1,32 @@
+#ifndef __RT_INSIGHT_H__
+#define __RT_INSIGHT_H__
+
+#include "RT_LOG_Print.h"
+#include "RT_insight_config.h"
+#include "RT_tunnel.h"
+#include "rtthread.h"
+#include <rthw.h>
+
+/* ---------------- Insight Data Structure ---------------- */
+/**
+ * @struct RT_insight_info
+ * @brief Structure representing an insight event or trace information.
+ */
+typedef struct _RT_insight_info
+{
+    uint32_t Frame_Header;     /**< Frame header, 4 bytes */
+    uint32_t ID;               /**< Event ID, 4 bytes */
+    uint32_t Track_Type;       /**< Track type, 4 bytes */
+    uint32_t Time_Stamp_ns_lo; /**< Lower 32 bits of timestamp in nanoseconds */
+    uint32_t Time_Stamp_ns_hi; /**< Higher 32 bits of timestamp in nanoseconds */
+} RT_insight_info;
+
+/* ---------------- Insight Initialization ---------------- */
+/**
+ * @brief Initialize the RT Insight module.
+ *
+ * @retval int  0 on success, negative value on error
+ */
+int RT_Insight_Init(void);
+
+#endif // __RT_INSIGHT_H__

RT_insight_config.h

@@ -0,0 +1,55 @@
+#ifndef __RT_INSIGHT_CONFIG_H__
+#define __RT_INSIGHT_CONFIG_H__
+
+/* ---------------- Insight Track Type Masks ---------------- */
+#define BASE_MASK (0xF0000000UL) /**< Base mask for track type category */
+#define FUNC_MASK (0x000000FFUL) /**< Mask for specific function/track type */
+
+/* ---------------- Thread Track Type ---------------- */
+#define THREAD_TRACK_BASE (0x00000000UL)                 /**< Base track type for threads */
+#define THREAD_RUN        (THREAD_TRACK_BASE + (1 << 1)) /**< Thread running */
+#define THREAD_EXIT       (THREAD_TRACK_BASE + (1 << 2)) /**< Thread exit */
+#define THREAD_RESUME     (THREAD_TRACK_BASE + (1 << 3)) /**< Thread resumed */
+#define THREAD_SUSPEND    (THREAD_TRACK_BASE + (1 << 4)) /**< Thread suspended */
+
+/* ---------------- IRQ / ISR Track Type ---------------- */
+#define IRQ_TRACK_BASE (0x10000000UL)              /**< Base track type for IRQs */
+#define IRQ_ENTER      (IRQ_TRACK_BASE + (1 << 1)) /**< IRQ enter */
+#define IRQ_EXIT       (IRQ_TRACK_BASE + (1 << 2)) /**< IRQ exit */
+
+/* ---------------- Timer Track Type ---------------- */
+#define TIMER_TRACK_BASE (0x20000000UL)                /**< Base track type for timers */
+#define TIMER_ENTER      (TIMER_TRACK_BASE + (1 << 1)) /**< Timer callback start */
+#define TIMER_EXIT       (TIMER_TRACK_BASE + (1 << 2)) /**< Timer callback end */
+
+/* ---------------- Semaphore Track Type ---------------- */
+#define SEM_TRACK_BASE (0x30000000UL)              /**< Base track type for semaphores */
+#define SEM_TRYTAKE    (SEM_TRACK_BASE + (1 << 1)) /**< Attempt to take semaphore */
+#define SEM_TAKE       (SEM_TRACK_BASE + (1 << 2)) /**< Semaphore taken */
+#define SEM_RELEASE    (SEM_TRACK_BASE + (1 << 3)) /**< Semaphore released */
+
+/* ---------------- Mutex Track Type ---------------- */
+#define MUTEX_TRACK_BASE (0x40000000UL)                /**< Base track type for mutexes */
+#define MUTEX_TRYTAKE    (MUTEX_TRACK_BASE + (1 << 1)) /**< Attempt to take mutex */
+#define MUTEX_TAKE       (MUTEX_TRACK_BASE + (1 << 2)) /**< Mutex taken */
+#define MUTEX_RELEASE    (MUTEX_TRACK_BASE + (1 << 3)) /**< Mutex released */
+
+/* ---------------- Event Object Track Type ---------------- */
+#define EVENT_TRACK_BASE (0x50000000UL)                /**< Base track type for event objects */
+#define EVENT_TRYTAKE    (EVENT_TRACK_BASE + (1 << 1)) /**< Attempt to take event */
+#define EVENT_TAKE       (EVENT_TRACK_BASE + (1 << 2)) /**< Event taken */
+#define EVENT_RELEASE    (EVENT_TRACK_BASE + (1 << 3)) /**< Event released */
+
+/* ---------------- Mailbox Track Type ---------------- */
+#define MAILBOX_TRACK_BASE (0x60000000UL)                  /**< Base track type for mailboxes */
+#define MAILBOX_TRYTAKE    (MAILBOX_TRACK_BASE + (1 << 1)) /**< Attempt to take mailbox */
+#define MAILBOX_TAKE       (MAILBOX_TRACK_BASE + (1 << 2)) /**< Mailbox taken */
+#define MAILBOX_RELEASE    (MAILBOX_TRACK_BASE + (1 << 3)) /**< Mailbox released */
+
+/* ---------------- Message Queue Track Type ---------------- */
+#define QUEUE_TRACK_BASE (0x70000000UL)                /**< Base track type for message queues */
+#define QUEUE_TRYTAKE    (QUEUE_TRACK_BASE + (1 << 1)) /**< Attempt to take queue */
+#define QUEUE_TAKE       (QUEUE_TRACK_BASE + (1 << 2)) /**< Queue taken */
+#define QUEUE_RELEASE    (QUEUE_TRACK_BASE + (1 << 3)) /**< Queue released */
+
+#endif // __RT_INSIGHT_CONFIG_H__

SConscript

@@ -1,16 +1,9 @@
-# RT-Thread building script for bridge
-
-import os
 from building import *
 
-cwd = GetCurrentDir()
-objs = []
-list = os.listdir(cwd)
+cwd     = GetCurrentDir()
+src     = Glob('*.c')
+CPPPATH = [cwd]
 
-if GetDepend('PKG_USING_RTI'):
-    for d in list:
-        path = os.path.join(cwd, d)
-        if os.path.isfile(os.path.join(path, 'SConscript')):
-            objs = objs + SConscript(os.path.join(d, 'SConscript'))
+group = DefineGroup('RT_INSIGHT', src, depend = [], CPPPATH = CPPPATH)
 
-Return('objs')
+Return('group')

inc/rti.h

@@ -1,136 +0,0 @@
-/*
- * File      : rti.h
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Change Logs:
- * Date           Author       Notes
- * 2018-06-05     flybreak     first version
- */
-#ifndef __RTI_H__
-#define __RTI_H__
-
-#include <rtthread.h>
-#include <rthw.h>
-#include "rti_config.h"
-
-#define   RTI_LOG                   (0u)
-#define   RTI_WARNING               (1u)
-#define   RTI_ERROR                 (2u)
-
-/* rti events. First 32 IDs from 0 .. 31 are Compatible for Systemvie */
-#define   RTI_ID_NOP                (0u)
-#define   RTI_ID_OVERFLOW           (1u)
-#define   RTI_ID_ISR_ENTER          (2u)
-#define   RTI_ID_ISR_EXIT           (3u)
-#define   RTI_ID_THREAD_START_EXEC  (4u)
-#define   RTI_ID_THREAD_STOP_EXEC   (5u)
-#define   RTI_ID_THREAD_START_READY (6u)
-#define   RTI_ID_THREAD_STOP_READY  (7u)
-#define   RTI_ID_THREAD_CREATE      (8u)
-#define   RTI_ID_THREAD_INFO        (9u)
-#define   RTI_ID_START             (10u)
-#define   RTI_ID_STOP              (11u)
-#define   RTI_ID_SYSTIME_CYCLES    (12u)
-#define   RTI_ID_SYSTIME_US        (13u)
-#define   RTI_ID_SYSDESC           (14u)
-#define   RTI_ID_USER_START        (15u)
-#define   RTI_ID_USER_STOP         (16u)
-#define   RTI_ID_IDLE              (17u)
-#define   RTI_ID_ISR_TO_SCHEDULER  (18u)
-#define   RTI_ID_TIMER_ENTER       (19u)
-#define   RTI_ID_TIMER_EXIT        (20u)
-#define   RTI_ID_STACK_INFO        (21u)
-#define   RTI_ID_MODULEDESC        (22u)
-
-#define   RTI_ID_INIT              (24u)
-#define   RTI_ID_NAME_RESOURCE     (25u)
-#define   RTI_ID_PRINT_FORMATTED   (26u)
-#define   RTI_ID_NUMMODULES        (27u)
-#define   RTI_ID_END_CALL          (28u)
-#define   RTI_ID_THREAD_TERMINATE  (29u)
-
-#define   RTI_ID_EX                (31u)
-
-#define   RTI_ID_SEM_BASE         (40u)
-#define   RTI_ID_SEM_TRYTAKE      ( 1u + RTI_ID_SEM_BASE)
-#define   RTI_ID_SEM_TAKEN        ( 2u + RTI_ID_SEM_BASE)
-#define   RTI_ID_SEM_RELEASE      ( 3u + RTI_ID_SEM_BASE)
-
-#define   RTI_ID_MUTEX_BASE       (50u)
-#define   RTI_ID_MUTEX_TRYTAKE    ( 1u + RTI_ID_MUTEX_BASE)
-#define   RTI_ID_MUTEX_TAKEN      ( 2u + RTI_ID_MUTEX_BASE)
-#define   RTI_ID_MUTEX_RELEASE    ( 3u + RTI_ID_MUTEX_BASE)
-
-#define   RTI_ID_EVENT_BASE       (60u)
-#define   RTI_ID_EVENT_TRYTAKE    ( 1u + RTI_ID_EVENT_BASE)
-#define   RTI_ID_EVENT_TAKEN      ( 2u + RTI_ID_EVENT_BASE)
-#define   RTI_ID_EVENT_RELEASE    ( 3u + RTI_ID_EVENT_BASE)
-
-#define   RTI_ID_MAILBOX_BASE     (70u)
-#define   RTI_ID_MAILBOX_TRYTAKE  ( 1u + RTI_ID_MAILBOX_BASE)
-#define   RTI_ID_MAILBOX_TAKEN    ( 2u + RTI_ID_MAILBOX_BASE)
-#define   RTI_ID_MAILBOX_RELEASE  ( 3u + RTI_ID_MAILBOX_BASE)
-
-#define   RTI_ID_QUEUE_BASE       (80u)
-#define   RTI_ID_QUEUE_TRYTAKE    ( 1u + RTI_ID_QUEUE_BASE)
-#define   RTI_ID_QUEUE_TAKEN      ( 2u + RTI_ID_QUEUE_BASE)
-#define   RTI_ID_QUEUE_RELEASE    ( 3u + RTI_ID_QUEUE_BASE)
-
-/*trace event flag*/
-#define RTI_SEM_NUM        (0)
-#define RTI_MUTEX_NUM      (1)
-#define RTI_EVENT_NUM      (2)
-#define RTI_MAILBOX_NUM    (3)
-#define RTI_QUEUE_NUM      (4)
-#define RTI_THREAD_NUM     (5)
-#define RTI_SCHEDULER_NUM  (6)
-#define RTI_INTERRUPT_NUM  (7)
-#define RTI_TIMER_NUM      (8)
-#define RTI_TRACE_NUM      (9)
-
-#define RTI_SEM            (1 << RTI_SEM_NUM      )
-#define RTI_MUTEX          (1 << RTI_MUTEX_NUM    )
-#define RTI_EVENT          (1 << RTI_EVENT_NUM    )
-#define RTI_MAILBOX        (1 << RTI_MAILBOX_NUM  )
-#define RTI_QUEUE          (1 << RTI_QUEUE_NUM    )
-#define RTI_THREAD         (1 << RTI_THREAD_NUM   )
-#define RTI_SCHEDULER      (1 << RTI_SCHEDULER_NUM)
-#define RTI_INTERRUPT      (1 << RTI_INTERRUPT_NUM)
-#define RTI_TIMER          (1 << RTI_TIMER_NUM    )
-#define RTI_ALL            (0x01FF)
-
-/* rti data size */
-#define RTI_INFO_SIZE      (9)
-#define RTI_VALUE_SIZE     (5)
-
-/* rti enable status */
-#define RTI_DISABLE         0
-#define RTI_ENABLE          1
-#define RTI_OVERFLOW        2
-
-/* rti api */
-void rti_start(void);
-void rti_stop(void);
-void rti_trace_enable(rt_uint16_t flag);
-void rti_trace_disable(rt_uint16_t flag);
-rt_size_t rti_data_get(rt_uint8_t *ptr, rt_uint16_t length);
-rt_size_t rti_buffer_used(void);
-void rti_data_new_data_notify_set_hook(void (*hook)(void));
-void rti_print(const char *s);
-
-#endif

inc/rti_config.h

@@ -1,94 +0,0 @@
-/*
- * File      : rti_config.h
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Change Logs:
- * Date           Author       Notes
- * 2018-06-05     flybreak     first version
- */
-#ifndef __RTI_CONFIG_H__
-#define __RTI_CONFIG_H__
-
-#include "rtconfig.h"
-#include "rtdevice.h"
-
-/* RTI interrupt configuration */
-#if defined(ARCH_ARM_CORTEX_M3) || defined(ARCH_ARM_CORTEX_M4) || defined(ARCH_ARM_CORTEX_M7)
-    #define RTI_GET_ISR_ID()   ((*(rt_uint32_t *)(0xE000ED04)) & 0x1FF)    // Get the currently active interrupt Id. (i.e. read Cortex-M ICSR[8:0] = active vector)
-#elif defined(ARCH_ARM_CORTEX_M0)
-    #if defined(__ICCARM__)
-        #define RTI_GET_ISR_ID()   (__get_IPSR())                          // Workaround for IAR, which might do a byte-access to 0xE000ED04. Read IPSR instead.
-    #else
-        #define RTI_GET_ISR_ID()   ((*(rt_uint32_t *)(0xE000ED04)) & 0x3F) // Get the currently active interrupt Id. (i.e. read Cortex-M ICSR[5:0] = active vector)
-    #endif
-#else
-    #error "This kernel is not currently supported, You can implement this function yourself"
-    #define RTI_GET_ISR_ID()                                               // Get the currently active interrupt Id from the user-provided function.
-#endif
-
-/* RTI buffer configuration */
-#ifndef PKG_USING_RTI
-    #define RTI_BUFFER_SIZE        2048                  // Number of bytes that RTI uses for the buffer.
-#else
-    #define RTI_BUFFER_SIZE        PKG_RTI_BUFFER_SIZE
-#endif
-
-/* RTI Id configuration */
-#ifndef PKG_USING_RTI
-    #define RTI_RAM_BASE_ADDRESS         0x20000000      // Default value for the lowest Id reported by the application.
-    #define RTI_ID_SHIFT                 2               // Number of bits to shift the Id to save bandwidth. (i.e. 2 when Ids are 4 byte aligned)
-#else
-    #define RTI_RAM_BASE_ADDRESS         PKG_RTI_RAM_BASE
-    #define RTI_ID_SHIFT                 PKG_RTI_ID_SHIFT
-#endif
-
-/* The application name to be displayed in RTI */
-#ifndef   RTI_APP_NAME
-    #ifndef PKG_USING_RTI
-        #define RTI_APP_NAME        "RT-Thread RTI"
-    #else
-        #define RTI_APP_NAME        PKG_RTI_APP_NAME
-    #endif
-#endif
-
-#ifndef   RTI_SYS_DESC0
-    #ifndef PKG_USING_RTI
-        #define RTI_SYS_DESC0        "I#15=SysTick"
-    #else
-        #define RTI_SYS_DESC0        PKG_RTI_SYS_DESC0
-    #endif
-#endif
-
-#ifndef   RTI_SYS_DESC1
-    #ifndef PKG_USING_RTI
-        #define RTI_SYS_DESC1        ""
-    #else
-        #define RTI_SYS_DESC1        PKG_RTI_SYS_DESC1
-    #endif
-#endif
-
-extern unsigned int             SystemCoreClock;
-#define rt_uint64_t             unsigned long long
-
-#define RTI_GET_TIMESTAMP()     clock_cpu_gettime()
-#define RTI_SYS_FREQ            (SystemCoreClock)
-#define RTI_CPU_FREQ            (SystemCoreClock)
-#define RTI_MAX_STRING_LEN      128
-#define RTI_DATE_PACKAGE_SIZE   1024
-
-#endif

samples/SConscript

@@ -1,9 +0,0 @@
-from building import *
-
-cwd     = GetCurrentDir()
-src     = Glob('*.c') + Glob('*.cpp')
-CPPPATH = [cwd + '/../inc']
-
-group = DefineGroup('rti', src, depend = ['PKG_USING_RTI_UART_SAMPLE'], CPPPATH = CPPPATH)
-
-Return('group')

samples/rti_uart_sample.c

@@ -1,199 +0,0 @@
-/*
- * File      : rti_uart_sample.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Change Logs:
- * Date           Author       Notes
- * 2018-06-05     flybreak     first version
- */
-
-#include <rtthread.h>
-#include <rtdevice.h>
-
-#include "rti.h"
-
-#ifdef RT_USING_FINSH
-#include <finsh.h>
-#endif
-
-#ifndef PKG_RTI_UART_BAUD_RATE
-#define PKG_RTI_UART_BAUD_RATE   BAUD_RATE_460800
-#endif
-
-#define TRANSIT_BUF_SIZE         (PKG_RTI_BUFFER_SIZE / 8)
-#define RTI_UART_BAUD_RATE       (PKG_RTI_UART_BAUD_RATE)
-#define RTI_UART_NAME            "rti_uart"
-
-static rt_uint8_t transit_buf[TRANSIT_BUF_SIZE];
-static rt_device_t rti_dev;
-
-#define REV_START_FIRSE_FARAM_BYTE0 0x53
-#define REV_START_FIRSE_FARAM_BYTE1 0x56
-#define REV_START_SECOND_FARAM_BYTE 0x01
-#define REV_STOP_FARAM_BYTE 0x02
-
-#define REV_START_FIRST_FARAM_SIZE 4
-
-static struct rt_semaphore rx_sem;
-static char rti_rx_stack[1024];
-static struct rt_thread rti_rx_th;
-
-void rti_data_new_data_notify(void)
-{
-    int ret = rti_data_get(transit_buf, TRANSIT_BUF_SIZE);
-    rt_device_write(rti_dev, 0, transit_buf, ret);
-}
-
-rt_err_t rt_ind(rt_device_t dev, rt_size_t size)
-{
-    //rti_data_new_data_notify_set_hook(rti_data_new_data_notify);
-    //rti_start();
-    rt_sem_release(&rx_sem);
-    return 0;
-}
-
-static void rti_rx_entry(void *param)
-{
-    char ch;
-
-    rt_uint8_t rx_cnt = 0;
-    rt_uint8_t rx_buff[REV_START_FIRST_FARAM_SIZE];
-
-    while(1)
-    {
-        while (rt_device_read(rti_dev, -1, &ch, 1) != 1)
-        {
-            rx_cnt = 0;
-            rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
-        }
-
-        //rt_kprintf("%02X ",ch);
-
-        rx_buff[rx_cnt++] = ch;
-
-        if(rx_cnt==REV_START_FIRST_FARAM_SIZE)
-        {
-            if(rx_buff[0] == REV_START_FIRSE_FARAM_BYTE0 && rx_buff[1] == REV_START_FIRSE_FARAM_BYTE1)
-            {
-                rti_data_new_data_notify_set_hook(rti_data_new_data_notify);
-                rti_start();
-            }
-
-            rx_cnt = 0;
-        }
-
-        if(ch == REV_START_SECOND_FARAM_BYTE)
-        {
-            rti_data_new_data_notify_set_hook(rti_data_new_data_notify);
-            rti_start();
-        }
-
-        if(ch == REV_STOP_FARAM_BYTE)
-        {
-            rti_stop();
-            rti_data_new_data_notify_set_hook(NULL);
-        }
-    }
-}
-
-void rti_uart_sample(void)
-{
-    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
-
-    rt_sem_init(&rx_sem, "rti_sem", 0, RT_IPC_FLAG_FIFO);
-
-    rti_dev = rt_console_get_device();
-
-#ifdef RT_USING_FINSH
-    finsh_set_device(RTI_UART_NAME);
-#endif
-    rt_console_set_device(RTI_UART_NAME);
-
-    rti_dev->open_flag &= ~RT_DEVICE_FLAG_STREAM;
-
-    config.baud_rate = RTI_UART_BAUD_RATE;
-    rt_device_control(rti_dev, RT_DEVICE_CTRL_CONFIG, &config);
-
-    rt_device_set_rx_indicate(rti_dev, rt_ind);
-    rt_device_open(rti_dev, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
-
-    rt_thread_init(&rti_rx_th,"rti_rx",rti_rx_entry,RT_NULL,&rti_rx_stack[0],sizeof(rti_rx_stack),20 - 1, 20);
-    rt_thread_startup(&rti_rx_th);
-}
-#ifdef RT_USING_FINSH
-MSH_CMD_EXPORT(rti_uart_sample, start record by uart.);
-#endif
-
-/*
- * rti uart device
- */
-
-#define RTI_UART_BUF             (128)
-static char uart_buf[RTI_UART_BUF];
-static struct rt_serial_device rti_serial;
-
-static rt_err_t rti_uart_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
-{
-    return RT_EOK;
-}
-static rt_err_t rti_uart_control(struct rt_serial_device *serial, int cmd, void *arg)
-{
-    return RT_EOK;
-}
-static int rti_uart_putc(struct rt_serial_device *serial, char c)
-{
-    static int index = 0;
-    uart_buf[index++] = c;
-    if (c == '\n' || index == RTI_UART_BUF - 1)
-    {
-        uart_buf[index] = '\0';
-        rti_print(uart_buf);
-        index = 0;
-    }
-    return 1;
-}
-static int rti_uart_getc(struct rt_serial_device *serial)
-{
-    return -1;
-}
-
-static const struct rt_uart_ops rti_uart_ops =
-{
-    .configure = rti_uart_configure,
-    .control = rti_uart_control,
-    .putc = rti_uart_putc,
-    .getc = rti_uart_getc,
-    .dma_transmit = RT_NULL
-};
-
-static int rti_uart_init(void)
-{
-    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
-    rt_err_t result = 0;
-
-    /* init rti_uart object */
-    rti_serial.ops    = &rti_uart_ops;
-    rti_serial.config = config;
-
-    /* register rti_uart device */
-    result = rt_hw_serial_register(&rti_serial, RTI_UART_NAME,
-                                   RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
-                                   NULL);
-    return result;
-}
-INIT_APP_EXPORT(rti_uart_init);

src/SConscript

@@ -1,9 +0,0 @@
-from building import *
-
-cwd     = GetCurrentDir()
-src     = Glob('*.c') + Glob('*.cpp')
-CPPPATH = [cwd + '/../inc']
-
-group = DefineGroup('rti', src, depend = ['PKG_USING_RTI'], CPPPATH = CPPPATH)
-
-Return('group')

src/rti.c

@@ -1,799 +0,0 @@
-/*
- * File      : rti.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Change Logs:
- * Date           Author       Notes
- * 2018-06-05     flybreak     first version
- */
-
-/*
-   Examples packets:
-   01 F4 03 80 80 10 // Overflow packet. Data is a single U32.
-                          This packet means: 500 packets lost, Timestamp is 0x40000
-   02 0F 50          // ISR(15) Enter. Timestamp 80 (0x50)
-   03 20             // ISR Exit. Timestamp 32 (0x20) (Shortest possible packet.)
-   event tryrecv packets:
-   ID|DataSize|len|String|Value|TimeStampDelta
-   3D|   05   |03 |726462| 01  | B90E
-   61|   5    | 3 | rdb  |  1  | 1849
-   B90E = 10111001 00001110 -> 0111 00111001 =1849
-*/
-
-#include "rti.h"
-
-static struct
-{
-    rt_uint32_t time_stamp_last;
-
-    /* rti overflow packet count*/
-    rt_uint32_t packet_count;
-
-    /* rti enable status*/
-    rt_uint8_t  enable;
-
-    /* event disable nest*/
-    rt_uint8_t  disable_nest[RTI_TRACE_NUM];
-
-} rti_status;
-
-struct rt_ringbuffer *tx_ringbuffer = RT_NULL;
-static rt_thread_t tidle, rti_thread;
-static const rt_uint8_t rti_sync[10] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-static void (*rti_data_new_data_notify)(void);
-
-/* rti recording functions */
-static void rti_overflow(void);
-static void rti_record_systime(void);
-static void rti_on_idle(void);
-static void rti_isr_enter(void);
-static void rti_isr_exit(void);
-static void rti_isr_to_scheduler(void);
-static void rti_enter_timer(rt_uint32_t timer);
-static void rti_exit_timer(void);
-static void rti_thread_start_exec(rt_uint32_t thread);
-static void rti_thread_stop_exec(void);
-static void rti_thread_start_ready(rt_uint32_t thread);
-static void rti_thread_stop_ready(rt_uint32_t thread);
-static void rti_thread_create(rt_uint32_t thread);
-static void rti_record_object(rt_uint32_t rti_id, struct rt_object *object);
-static void rti_send_sys_info(void);
-static void rti_send_sys_desc(const char *ptr);
-static void rti_send_thread_list(void);
-static void rti_send_thread_info(const rt_thread_t thread);
-static void rti_send_packet_void(rt_uint8_t rti_id);
-static void rti_send_packet_value(rt_uint8_t rti_id, rt_uint32_t value);
-static void rti_send_packet(rt_uint8_t rti_id, rt_uint8_t *packet_sta, rt_uint8_t *packet_end);
-
-/* rti encodeing functions */
-static rt_uint8_t *rti_record_ready(rt_uint8_t *start);
-static rt_uint8_t *rti_encode_val(rt_uint8_t *present, rt_uint32_t value);
-static rt_uint8_t *rti_encode_str(rt_uint8_t *present, const char *ptr, rt_uint8_t max_len);
-static rt_uint32_t rti_shrink_id(rt_uint32_t Id);
-
-/* rti hook functions */
-static void rti_timer_enter(rt_timer_t t);
-static void rti_timer_exit(rt_timer_t t);
-static void rti_thread_inited(rt_thread_t thread);
-static void rti_thread_suspend(rt_thread_t thread);
-static void rti_thread_resume(rt_thread_t thread);
-static void rti_scheduler(rt_thread_t from, rt_thread_t to);
-//static void rti_object_attach(rt_object_t object);
-static void rti_object_detach(rt_object_t object);
-static void rti_interrupt_enter(void);
-static void rti_interrupt_leave(void);
-static void rti_object_trytake(rt_object_t object);
-static void rti_object_take(rt_object_t object);
-static void rti_object_put(rt_object_t object);
-
-static int rti_init(void);
-static rt_size_t rti_data_put(const rt_uint8_t *ptr, rt_uint16_t length);
-
-#ifndef __on_rti_data_new_data_notify
-    #define __on_rti_data_new_data_notify()          __ON_HOOK_ARGS(rti_data_new_data_notify, ())
-#endif
-
-/* rti hook functions */
-static void rti_timer_enter(rt_timer_t t)
-{
-    if (!rti_status.enable || rti_status.disable_nest[RTI_TIMER_NUM])
-        return ;
-    rti_enter_timer((rt_uint32_t)t);
-}
-
-static void rti_timer_exit(rt_timer_t t)
-{
-    if (!rti_status.enable || rti_status.disable_nest[RTI_TIMER_NUM])
-        return ;
-    rti_exit_timer();
-}
-
-static void rti_thread_inited(rt_thread_t thread)
-{
-    if (!rti_status.enable || rti_status.disable_nest[RTI_THREAD_NUM])
-        return ;
-    rti_thread_create((rt_uint32_t)thread);
-    rti_send_thread_info(thread);
-}
-
-static void rti_thread_suspend(rt_thread_t thread)
-{
-    if (!rti_status.enable || rti_status.disable_nest[RTI_THREAD_NUM])
-        return ;
-    rti_thread_stop_ready((rt_uint32_t)thread);
-}
-
-static void rti_thread_resume(rt_thread_t thread)
-{
-    if (!rti_status.enable || rti_status.disable_nest[RTI_THREAD_NUM])
-        return ;
-    rti_thread_start_ready((rt_uint32_t)thread);
-}
-
-static void rti_scheduler(rt_thread_t from, rt_thread_t to)
-{
-    if (!rti_status.enable || rti_status.disable_nest[RTI_SCHEDULER_NUM])
-        return ;
-    rti_thread_stop_ready((rt_uint32_t)from);
-    if (to == tidle)
-        rti_on_idle();
-    else
-        rti_thread_start_exec((rt_uint32_t)to);
-}
-
-//static void rti_object_attach(rt_object_t object)
-//{
-//    if (!rti_status.enable || rti_status.disable_nest[RTI_THREAD_NUM])
-//        return ;
-//    switch (object->type & (~RT_Object_Class_Static))
-//    {
-//    case RT_Object_Class_Thread:
-//        rti_thread_create((rt_uint32_t)object);
-//        rti_send_thread_info((rt_thread_t)object);
-//        break;
-//    default:
-//        break;
-//    }
-//}
-
-static void rti_object_detach(rt_object_t object)
-{
-    if (!rti_status.enable || rti_status.disable_nest[RTI_THREAD_NUM])
-        return ;
-    switch (object->type & (~RT_Object_Class_Static))
-    {
-    case RT_Object_Class_Thread:
-        rti_thread_stop_exec();
-        break;
-    default:
-        break;
-    }
-}
-
-static void rti_interrupt_enter(void)
-{
-    if (!rti_status.enable || rti_status.disable_nest[RTI_INTERRUPT_NUM])
-        return ;
-    rti_isr_enter();
-}
-
-static void rti_interrupt_leave(void)
-{
-    rt_thread_t current;
-
-    if (!rti_status.enable || rti_status.disable_nest[RTI_INTERRUPT_NUM])
-        return ;
-
-    if (rt_interrupt_get_nest())
-    {
-        rti_isr_exit();
-        return;
-    }
-    rti_isr_to_scheduler();
-    current = rt_thread_self();
-    if (current == tidle)
-        rti_on_idle();
-    else
-        rti_thread_start_exec((rt_uint32_t)current);
-}
-
-static void rti_object_trytake(rt_object_t object)
-{
-    if (!rti_status.enable)
-        return ;
-    switch (object->type & (~RT_Object_Class_Static))
-    {
-    case RT_Object_Class_Semaphore:
-        if (!rti_status.disable_nest[RTI_SEM_NUM])
-            rti_record_object(RTI_ID_SEM_TRYTAKE, object);
-        break;
-    case RT_Object_Class_Mutex:
-        if (!rti_status.disable_nest[RTI_MUTEX_NUM])
-            rti_record_object(RTI_ID_MUTEX_TRYTAKE, object);
-        break;
-    case RT_Object_Class_Event:
-        if (!rti_status.disable_nest[RTI_EVENT_NUM])
-            rti_record_object(RTI_ID_EVENT_TRYTAKE, object);
-        break;
-    case RT_Object_Class_MailBox:
-        if (!rti_status.disable_nest[RTI_MAILBOX_NUM])
-            rti_record_object(RTI_ID_MAILBOX_TRYTAKE, object);
-        break;
-    case RT_Object_Class_MessageQueue:
-        if (!rti_status.disable_nest[RTI_QUEUE_NUM])
-            rti_record_object(RTI_ID_QUEUE_TRYTAKE, object);
-        break;
-    }
-}
-
-static void rti_object_take(rt_object_t object)
-{
-    if (!rti_status.enable)
-        return ;
-    switch (object->type & (~RT_Object_Class_Static))
-    {
-    case RT_Object_Class_Semaphore:
-        if (!rti_status.disable_nest[RTI_SEM_NUM])
-            rti_record_object(RTI_ID_SEM_TAKEN, object);
-        break;
-    case RT_Object_Class_Mutex:
-        if (!rti_status.disable_nest[RTI_MUTEX_NUM])
-            rti_record_object(RTI_ID_MUTEX_TAKEN, object);
-        break;
-    case RT_Object_Class_Event:
-        if (!rti_status.disable_nest[RTI_EVENT_NUM])
-            rti_record_object(RTI_ID_EVENT_TAKEN, object);
-        break;
-    case RT_Object_Class_MailBox:
-        if (!rti_status.disable_nest[RTI_MAILBOX_NUM])
-            rti_record_object(RTI_ID_MAILBOX_TAKEN, object);
-        break;
-    case RT_Object_Class_MessageQueue:
-        if (!rti_status.disable_nest[RTI_QUEUE_NUM])
-            rti_record_object(RTI_ID_QUEUE_TAKEN, object);
-        break;
-    }
-}
-
-static void rti_object_put(rt_object_t object)
-{
-    if (!rti_status.enable)
-        return ;
-    switch (object->type & (~RT_Object_Class_Static))
-    {
-    case RT_Object_Class_Semaphore:
-        if (!rti_status.disable_nest[RTI_SEM_NUM])
-            rti_record_object(RTI_ID_SEM_RELEASE, object);
-        break;
-    case RT_Object_Class_Mutex:
-        if (!rti_status.disable_nest[RTI_MUTEX_NUM])
-            rti_record_object(RTI_ID_MUTEX_RELEASE, object);
-        break;
-    case RT_Object_Class_Event:
-        if (!rti_status.disable_nest[RTI_EVENT_NUM])
-            rti_record_object(RTI_ID_EVENT_RELEASE, object);
-        break;
-    case RT_Object_Class_MailBox:
-        if (!rti_status.disable_nest[RTI_MAILBOX_NUM])
-            rti_record_object(RTI_ID_MAILBOX_RELEASE, object);
-        break;
-    case RT_Object_Class_MessageQueue:
-        if (!rti_status.disable_nest[RTI_QUEUE_NUM])
-            rti_record_object(RTI_ID_QUEUE_RELEASE, object);
-        break;
-    }
-}
-
-/* rti encodeing functions */
-static rt_uint8_t *rti_record_ready(rt_uint8_t *start)
-{
-    /* reserve packet header size */
-    return start + 4;
-}
-
-static rt_uint8_t *rti_encode_val(rt_uint8_t *present, rt_uint32_t value)
-{
-    while (value > 0x7F)
-    {
-        *present++ = (rt_uint8_t)(value | 0x80);
-        value >>= 7;
-    };
-    *present++ = (rt_uint8_t)value;
-    return present;
-}
-
-static rt_uint8_t *rti_encode_str(rt_uint8_t *present, const char *ptr, rt_uint8_t max_len)
-{
-    rt_uint8_t len = 0, n;
-
-    while (*(ptr + len) && len < max_len)
-    {
-        len++;
-    }
-    if (len < 0xFF)
-    {
-        *present++ = len;
-    }
-    else
-    {
-        *present++ = 0xFF;
-        *present++ = (len & 0xFF);
-        *present++ = ((len >> 8) & 0xFF);
-    }
-    for (n = 0; n < len; n++)
-    {
-        *present++ = *ptr++;
-    }
-    return present;
-}
-
-static rt_uint32_t rti_shrink_id(rt_uint32_t Id)
-{
-    return ((Id) - RTI_RAM_BASE_ADDRESS) >> RTI_ID_SHIFT;
-}
-
-/* rti recording functions */
-static void rti_overflow(void)
-{
-    rt_uint8_t packet[11];
-    rt_uint8_t *present;
-    rt_uint32_t time_stamp, delta;
-
-    packet[0] = RTI_ID_OVERFLOW;
-    present   = &packet[1];
-    present = rti_encode_val(present, rti_status.packet_count);
-
-    time_stamp  = RTI_GET_TIMESTAMP();
-    delta = time_stamp - rti_status.time_stamp_last;
-    present = rti_encode_val(present, delta);
-
-    /* send overflow package success */
-    if (rti_data_put(packet, present - packet) > 0)
-    {
-        rti_status.enable = RTI_ENABLE;
-        rti_status.time_stamp_last = time_stamp;
-        rti_status.packet_count = 0;
-    }
-    else
-    {
-        rti_status.packet_count ++;
-    }
-}
-
-static void rti_record_systime(void)
-{
-    rt_uint8_t packet[RTI_INFO_SIZE + 2 * RTI_VALUE_SIZE];
-    rt_uint8_t *start, *present;
-    rt_uint64_t systime;
-
-    systime = (rt_uint64_t)(rt_tick_get() * 1000 / RT_TICK_PER_SECOND);
-
-    start = rti_record_ready(packet);
-    present = rti_encode_val(start, (rt_uint32_t)systime);
-    present = rti_encode_val(present, (rt_uint32_t)(systime >> 32));
-
-    rti_send_packet(RTI_ID_SYSTIME_US, start, present);
-}
-
-static void rti_record_object(rt_uint32_t rti_id, struct rt_object *object)
-{
-    rt_uint8_t packet[RTI_INFO_SIZE + 4 * RTI_VALUE_SIZE];
-    rt_uint8_t *start, *present;
-
-    start = rti_record_ready(packet);
-    present = rti_encode_str(start, object->name, RT_NAME_MAX);
-    if ((object->type & (~RT_Object_Class_Static)) == RT_Object_Class_Event)
-        present = rti_encode_val(present, ((rt_event_t)object)->set);
-
-    rti_send_packet(rti_id, start, present);
-}
-
-static void rti_on_idle(void)
-{
-    rti_send_packet_void(RTI_ID_IDLE);
-}
-
-static void rti_isr_enter(void)
-{
-    rti_send_packet_value(RTI_ID_ISR_ENTER, RTI_GET_ISR_ID());
-}
-
-static void rti_isr_exit(void)
-{
-    rti_send_packet_void(RTI_ID_ISR_EXIT);
-}
-
-static void rti_isr_to_scheduler(void)
-{
-    rti_send_packet_void(RTI_ID_ISR_TO_SCHEDULER);
-}
-
-static void rti_enter_timer(rt_uint32_t timer)
-{
-    rti_send_packet_value(RTI_ID_TIMER_ENTER, rti_shrink_id(timer));
-}
-
-static void rti_exit_timer(void)
-{
-    rti_send_packet_void(RTI_ID_TIMER_EXIT);
-}
-
-static void rti_thread_start_exec(rt_uint32_t thread)
-{
-    rti_send_packet_value(RTI_ID_THREAD_START_EXEC, rti_shrink_id(thread));
-}
-
-static void rti_thread_stop_exec(void)
-{
-    rti_send_packet_void(RTI_ID_THREAD_STOP_EXEC);
-}
-
-static void rti_thread_start_ready(rt_uint32_t thread)
-{
-    rti_send_packet_value(RTI_ID_THREAD_START_READY, rti_shrink_id(thread));
-}
-
-static void rti_thread_stop_ready(rt_uint32_t thread)
-{
-    rt_uint8_t packet[RTI_INFO_SIZE + 2 * RTI_VALUE_SIZE];
-    rt_uint8_t *start, *present;
-
-    start = rti_record_ready(packet);
-    present = rti_encode_val(start, rti_shrink_id(thread));
-    present = rti_encode_val(present, 0);
-
-    rti_send_packet(RTI_ID_THREAD_STOP_READY, start, present);
-}
-
-static void rti_thread_create(rt_uint32_t thread)
-{
-    rti_send_packet_value(RTI_ID_THREAD_CREATE, rti_shrink_id(thread));
-}
-
-static void rti_send_sys_desc(const char *ptr)
-{
-    rt_uint8_t packet[RTI_INFO_SIZE + 1 + RTI_MAX_STRING_LEN];
-    rt_uint8_t *start, *present;
-
-    start = rti_record_ready(packet);
-    present = rti_encode_str(start, ptr, RTI_MAX_STRING_LEN);
-
-    rti_send_packet(RTI_ID_SYSDESC, start, present);
-}
-
-static void rti_send_sys_info(void)
-{
-    // Add sync packet ( 10 * 0x00)
-    // Send system description
-    // Send system time
-    // Send thread list
-    rti_data_put(rti_sync, 10);
-    rti_send_packet_void(RTI_ID_START);
-    {
-        rt_uint8_t packet[RTI_INFO_SIZE + 4 * RTI_VALUE_SIZE];
-        rt_uint8_t *start, *present;
-
-        start = rti_record_ready(packet);
-        present = rti_encode_val(start, RTI_SYS_FREQ);
-        present = rti_encode_val(present, RTI_CPU_FREQ);
-        present = rti_encode_val(present, RTI_RAM_BASE_ADDRESS);
-        present = rti_encode_val(present, RTI_ID_SHIFT);
-
-        rti_send_packet(RTI_ID_INIT, start, present);
-    }
-    rti_send_sys_desc("N="RTI_APP_NAME",O=RT-Thread");
-    rti_send_sys_desc(RTI_SYS_DESC0);
-    rti_send_sys_desc(RTI_SYS_DESC1);
-    rti_record_systime();
-    rti_send_thread_list();
-}
-
-static void rti_send_thread_info(const rt_thread_t thread)
-{
-    rt_uint8_t packet[RTI_INFO_SIZE + RTI_VALUE_SIZE + 1 + 32];
-    rt_uint8_t *start, *present;
-
-    rt_enter_critical();
-    start = rti_record_ready(packet);
-    present = rti_encode_val(start, rti_shrink_id((rt_uint32_t)thread));
-    present = rti_encode_val(present, thread->current_priority);
-    present = rti_encode_str(present, thread->name, 32);
-    rti_send_packet(RTI_ID_THREAD_INFO, start, present);
-
-    present = rti_encode_val(start, rti_shrink_id((rt_uint32_t)thread));
-    present = rti_encode_val(present, (rt_uint32_t)thread->stack_addr);
-    present = rti_encode_val(present, thread->stack_size);
-    present = rti_encode_val(present, 0);
-    rti_send_packet(RTI_ID_STACK_INFO, start, present);
-    rt_exit_critical();
-}
-
-static void rti_send_thread_list(void)
-{
-    struct rt_thread *thread;
-    struct rt_list_node *node;
-    struct rt_list_node *list;
-    struct rt_object_information *info;
-
-    info = rt_object_get_information(RT_Object_Class_Thread);
-    list = &info->object_list;
-
-    tidle = rt_thread_idle_gethandler();
-
-    rt_enter_critical();
-    for (node = list->next; node != list; node = node->next)
-    {
-        thread = rt_list_entry(node, struct rt_thread, list);
-        /* skip idle thread */
-        if (thread != tidle)
-            rti_send_thread_info(thread);
-    }
-    rt_exit_critical();
-}
-
-/* send a void package */
-static void rti_send_packet_void(rt_uint8_t rti_id)
-{
-    rt_uint8_t packet[RTI_INFO_SIZE];
-    rt_uint8_t *start;
-
-    start = rti_record_ready(packet);
-    rti_send_packet(rti_id, start, start);
-}
-
-/* send a value package */
-static void rti_send_packet_value(rt_uint8_t rti_id, rt_uint32_t value)
-{
-    rt_uint8_t packet[RTI_INFO_SIZE + RTI_VALUE_SIZE];
-    rt_uint8_t *start, *present;
-
-    present = start = rti_record_ready(packet);
-    present = rti_encode_val(present, value);
-
-    rti_send_packet(rti_id, start, present);
-}
-
-void rti_print(const char *s)
-{
-    rt_uint8_t packet[RTI_INFO_SIZE + 2 * RTI_VALUE_SIZE + RTI_MAX_STRING_LEN];
-    rt_uint8_t *start, *present;
-
-    start = rti_record_ready(packet);
-    present = rti_encode_str(start, s, RTI_MAX_STRING_LEN);
-    present = rti_encode_val(present, RTI_LOG);
-    present = rti_encode_val(present, 0);
-
-    rti_send_packet(RTI_ID_PRINT_FORMATTED, start, present);
-}
-
-static void rti_send_packet(rt_uint8_t rti_id, rt_uint8_t *packet_sta, rt_uint8_t *packet_end)
-{
-    rt_uint16_t  len;
-    rt_uint32_t  time_stamp, delta;
-
-    if (rti_status.enable == RTI_DISABLE)
-        return ;
-    if (rti_id < 24)
-    {
-        *--packet_sta = rti_id;
-    }
-    else
-    {
-        len = packet_end - packet_sta;
-        if (len > 127)
-        {
-            *--packet_sta = (len >> 7);
-            *--packet_sta = len | 0x80;
-        }
-        else
-        {
-            *--packet_sta = len;
-        }
-        if (rti_id > 127)
-        {
-            *--packet_sta = (rti_id >> 7);
-            *--packet_sta = rti_id | 0x80;
-        }
-        else
-        {
-            *--packet_sta = rti_id;
-        }
-    }
-    time_stamp  = RTI_GET_TIMESTAMP();
-    delta = time_stamp - rti_status.time_stamp_last;
-    packet_end = rti_encode_val(packet_end, delta);
-    if (rti_status.enable == RTI_OVERFLOW)
-    {
-        rti_overflow();
-        if (rti_status.enable != RTI_ENABLE)
-            return ;
-    }
-    /* overflow */
-    if (rti_data_put(packet_sta, packet_end - packet_sta) == 0)
-    {
-        rti_status.enable = RTI_OVERFLOW;
-        rti_status.packet_count ++;
-        rti_overflow();
-    }
-
-    rti_status.time_stamp_last = time_stamp;
-}
-
-/*
- * rti api function.
- */
-void rti_data_new_data_notify_set_hook(void (*hook)(void))
-{
-    rti_data_new_data_notify = hook;
-}
-void rti_trace_disable(rt_uint16_t flag)
-{
-    register rt_ubase_t temp;
-    temp = rt_hw_interrupt_disable();
-
-    for (rt_uint8_t i = 0; i < RTI_TRACE_NUM; i++)
-    {
-        if (flag & (1 << i))
-        {
-            rti_status.disable_nest[i] ++;
-        }
-    }
-    rt_hw_interrupt_enable(temp);
-}
-
-void rti_trace_enable(rt_uint16_t flag)
-{
-    register rt_ubase_t temp;
-    temp = rt_hw_interrupt_disable();
-
-    for (rt_uint8_t i = 0; i < RTI_TRACE_NUM; i++)
-    {
-        if (flag & (1 << i))
-        {
-            rti_status.disable_nest[i] --;
-        }
-    }
-    rt_hw_interrupt_enable(temp);
-}
-
-static rt_size_t rti_data_put(const rt_uint8_t *ptr, rt_uint16_t length)
-{
-    register rt_ubase_t temp;
-    rt_size_t size = 0;
-    if (!rti_status.enable)
-        return 0;
-
-    temp = rt_hw_interrupt_disable();
-    if (rt_ringbuffer_space_len(tx_ringbuffer) > length)
-        size = rt_ringbuffer_put(tx_ringbuffer, ptr, length);
-    if (rt_ringbuffer_data_len(tx_ringbuffer) > RTI_BUFFER_SIZE / 2)
-    {
-        if (rti_thread != RT_NULL)
-        {
-            rti_trace_disable(RTI_ALL);
-            rt_thread_resume(rti_thread);
-            rti_trace_enable(RTI_ALL);
-            rti_thread = RT_NULL;
-        }
-    }
-    rt_hw_interrupt_enable(temp);
-    return size;
-}
-
-rt_size_t rti_data_get(rt_uint8_t *ptr, rt_uint16_t length)
-{
-    if (tx_ringbuffer == RT_NULL)
-        return 0;
-    return rt_ringbuffer_get(tx_ringbuffer, ptr, length);;
-}
-
-rt_size_t rti_buffer_used(void)
-{
-    return rt_ringbuffer_data_len(tx_ringbuffer);
-}
-
-void rti_start(void)
-{
-    rt_kprintf("rti start\n");
-    rt_ringbuffer_reset(tx_ringbuffer);
-    rti_status.enable = RTI_ENABLE;
-    rti_send_sys_info();
-}
-
-void rti_stop(void)
-{
-    rti_send_packet_void(RTI_ID_STOP);
-    rt_thread_delay(50);
-    RT_OBJECT_HOOK_CALL(rti_data_new_data_notify, ());
-    rt_thread_delay(50);
-    RT_OBJECT_HOOK_CALL(rti_data_new_data_notify, ());
-
-    rti_status.enable = RTI_DISABLE;
-    rt_kprintf("rti stop\n");
-    if (rti_thread != RT_NULL)
-    {
-        rt_thread_resume(rti_thread);
-        rti_thread = RT_NULL;
-    }
-}
-
-static void rti_thread_entry(void *parameter)
-{
-    register rt_ubase_t temp;
-    rt_thread_t thread;
-
-    while (1)
-    {
-        thread = rt_thread_self();
-        while (rti_status.enable && (rti_buffer_used() > RTI_DATE_PACKAGE_SIZE))
-        {
-            RT_OBJECT_HOOK_CALL(rti_data_new_data_notify, ());
-        }
-        temp = rt_hw_interrupt_disable();
-
-        rti_thread = thread;
-        rt_thread_suspend(thread);
-
-        rt_hw_interrupt_enable(temp);
-
-        rt_schedule();
-    }
-}
-
-static int rti_init(void)
-{
-    rt_thread_t rti_thread = RT_NULL;
-
-    tidle = rt_thread_idle_gethandler();
-
-    tx_ringbuffer = rt_ringbuffer_create(RTI_BUFFER_SIZE);
-    if (tx_ringbuffer == RT_NULL)
-        return -1;
-
-    rti_thread = rt_thread_create("rti",
-                                  rti_thread_entry,
-                                  RT_NULL,
-                                  1024, 20, 5);
-    if (rti_thread != RT_NULL)
-        rt_thread_startup(rti_thread);
-    else
-    {
-        rt_ringbuffer_destroy(tx_ringbuffer);
-        return -1;
-    }
-    /* register hooks */
-    //rt_object_attach_sethook(rti_object_attach);
-    rt_object_detach_sethook(rti_object_detach);
-    rt_object_trytake_sethook(rti_object_trytake);
-    rt_object_take_sethook(rti_object_take);
-    rt_object_put_sethook(rti_object_put);
-
-    rt_thread_suspend_sethook(rti_thread_suspend);
-    rt_thread_resume_sethook(rti_thread_resume);
-    rt_thread_inited_sethook(rti_thread_inited);
-    rt_scheduler_sethook(rti_scheduler);
-
-    rt_timer_enter_sethook(rti_timer_enter);
-    rt_timer_exit_sethook(rti_timer_exit);
-
-    rt_interrupt_enter_sethook(rti_interrupt_enter);
-    rt_interrupt_leave_sethook(rti_interrupt_leave);
-
-    return 0;
-}
-INIT_COMPONENT_EXPORT(rti_init);