第一次修改控件版本

+{
+    "git.ignoreLimitWarning": true
+}

+cmake_minimum_required(VERSION 2.8)
+
+if (NOT USE_SYSTEM_ARCH)
+    # select use platform 'LINUX' or 'RTOS' here, reset cache and reload cmake project
+    set(USE_SYSTEM_ARCH LINUX)
+endif ()
+
+if (USE_SYSTEM_ARCH MATCHES RTOS)
+    cmake_minimum_required(VERSION 3.15)
+    set(CMAKE_C_COMPILER arm-none-eabi-gcc)
+    set(CMAKE_CXX_COMPILER arm-none-eabi-g++)
+    set(CMAKE_ASM_COMPILER arm-none-eabi-gcc)
+    set(CMAKE_AR arm-none-eabi-ar)
+    set(CMAKE_OBJCOPY arm-none-eabi-objcopy)
+    set(CMAKE_OBJDUMP arm-none-eabi-objdump)
+    set(SIZE arm-none-eabi-size)
+    set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+endif ()
+
+project(entry)
+
+# Disable in-source builds to prevent source tree corruption.
+if (" ${CMAKE_SOURCE_DIR}" STREQUAL " ${CMAKE_BINARY_DIR}")
+    message(FATAL_ERROR "FATAL: In-source builds are not allowed.
+       You should create a separate directory for build files.")
+endif ()
+
+if (USE_SYSTEM_ARCH MATCHES LINUX)
+    add_definitions(-DSYSTEM_ARCH_LINUX)
+    add_subdirectory(samples/sample_c/platform/linux/manifold2)
+
+    message("-- Attention: If you want to use opencv C++ sample, please uncomment the next line.")
+#   add_subdirectory(samples/sample_c++/platform/linux/manifold2)
+
+    set(LIBRARY_PATH psdk_lib/lib/x86_64-linux-gnu-gcc)
+
+    install(FILES ${LIBRARY_PATH}/libpayloadsdk.a
+            DESTINATION "${CMAKE_INSTALL_PREFIX}/lib"
+            )
+
+    install(DIRECTORY psdk_lib/include
+            DESTINATION "${CMAKE_INSTALL_PREFIX}"
+            )
+elseif (USE_SYSTEM_ARCH MATCHES RTOS)
+    add_definitions(-DSYSTEM_ARCH_RTOS)
+    add_subdirectory(samples/sample_c/platform/rtos_freertos/stm32f4_discovery/project/armgcc)
+endif ()
+
+add_custom_target(${PROJECT_NAME} ALL)

+END USER LICENSE AGREEMENT
+YOU AGREE TO USE THE SDK SOLELY IN ACCORDANCE WITH THE TERMS AND CONDITIONS OF THIS END USER LICENSE AGREEMENT (THE “AGREEMENT”), AND YOU AGREE THAT YOU ARE BOUND BY AND ARE A PARTY TO THIS AGREEMENT. YOU WARRANT THAT YOU ARE AT LEAST EIGHTEEN YEARS OLD AND THAT YOU HAVE THE LEGAL CAPACITY TO ENTER INTO CONTRACTS. IF YOU ARE AGREEING TO BE BOUND BY THIS AGREEMENT ON BEHALF OF A COMPANY, ORGANIZATION, OR OTHER ENTITY, THEN (i) “YOU” INCLUDES YOU AND THAT COMPANY, ORGANIZATION OR ENTITY, AND (ii) YOU REPRESENT AND WARRANT THAT YOU ARE AN AUTHORIZED REPRESENTATIVE OF SUCH COMPANY, ORGANIZATION OR ENTITY WITH THE AUTHORITY TO BIND SUCH COMPANY, ORGANIZATION OR ENTITY TO THIS AGREEMENT.
+YOUR USE OF THE SDK IS EXPRESSLY CONDITIONED ON YOUR ACCEPTANCE OF THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT, YOU MAY NOT INSTALL OR USE THE SDK.
+    1. About This Agreement. 
+        1.1 Generally. This Agreement applies to the SDK made available by GDU to you. 
+        1.2 Additional Terms. Certain additional and/or different terms may apply to certain types of users. If you are a federal, state, or local government entity (including but not limited to any agency or other sub-governmental organization thereof) utilizing the SDK in your official capacity, and to whom GDU has agreed to provide the SDK, then our Government Terms apply to you.
+    2. Definitions
+“Analytics Data” means information collected from a GDU Product (e.g., a GDU UAV) that is used in connection with an Application and/or devices used to operate the GDU Product (e.g., a mobile device). The Analytics Data may include Header Data and/or Event Data. Analytics Data may be used by GDU for any lawful purpose, including without limitation, for research or to improve its SDK or GDU Products. 
+“Application” means a software program that is developed by you using the SDK for use with GDU Products.
+“Confidential Information” means the SDK and all other information disclosed to you by GDU that would reasonably be considered to be confidential, or is or was considered by GDU to be confidential, except for information which you can demonstrate: (a) is previously rightfully known to you without restriction on disclosure; (b) is or becomes, from no act or failure to act on your part, generally known in the relevant industry or public domain; (c) is disclosed to you by a third-party as a matter of right and without restriction on disclosure; or (d) is or was independently developed by you without access to, use of, or reference to the Confidential Information.
+“Documentation” means any online read me, help files, technical specifications, or other related explanatory materials that are contained in the SDK or that accompany the SDK.
+“GDU” means SZ GDU TECHNOLOGY CO., LTD. and its affiliates.
+“GDU Products” means GDU hardware, software, and services, such as unmanned aerial vehicles (UAVs), flight controllers, sensors, s, gimbals, remote controllers, accessories, etc.
+“Event Data” means information about time of operation or events, session identification numbers, event types, and flight operation information, including but not limited to GPS data, navigation, operation, speed, distance, modes, mission, command, altitude, takeoff and landing, payload and other component use, battery levels, etc.
+“Header Data” means information about the software (including but not limited to installation identification, app key, SDK version of an Application) and hardware (including but not limited to product identifiers and names of UAVs, payloads, remote controllers, etc.).
+“Licensee Disclosure” means any information that you may provide to GDU in connection with this Agreement, including, for example, feedback on errors and improvements within or relating to the SDK.
+“Privacy Policy” means GDU’s privacy policy located at https://developer.gdu.com/policies/privacy/.
+“SDK” or “Software Development Kit” means software (source code and object code), applications, tools, sample code, templates, fonts, logos, icons, images, libraries, interfaces, Updates, Documentation, application programming interfaces (APIs), information, data, files, and other materials, whether tangible or intangible, in whatever form or medium provided to you by GDU for use by you in connection with your Application. For the purpose of this Agreement, SDK includes, without limitation, (a) the GDU “Guidance” software development kit (https://developer.gdu.com/guidance-sdk/), (b) the GDU “Mobile” software development kit (https://developer.gdu.com/mobile-sdk/), (c) the GDU “Payload” software development kit (https://developer.gdu.com/payload-sdk/, and/or (d) the GDU “Onboard” software development kit (https://developer.gdu.com/onboard-sdk/).
+“Open-Source Component” means software, interfaces and firmware subject to an open-source software license, which means any software license approved as open-source licenses by the Open Source Initiative or any substantially similar licenses, including without limitation any license that, as a condition of distribution of the software licensed under such license, requires that the distributor make the software available in source code format.
+“Third-Party Component” means software, interfaces and firmware licensed by GDU from a third-party (e.g., a supplier of GDU) for incorporation into the SDK and distributed as an integral part of the SDK, as applicable. Third-Party Components may include Open-Source Components.
+“Updates” means bug fixes, service packs, hot fixes, updates, upgrades, enhancements, modifications, and new releases of versions of the SDK.
+“Warranty Logs” means information provided to and/or received by the SDK that is necessary for determining warranty eligibility and product reliability, including without limitation SDK function calls (including without limitation time, function name, results/feedback, etc.), protocol or commands sent from or to a mobile device, an Application, and/or a remote controller (including without limitation time, name, type, command/action, etc.).
+
+    3. License.
+        3.1 License Grants. The SDK is licensed, not sold, to you by GDU and/or, if applicable, its suppliers and licensors. Subject to the terms and conditions of this Agreement, you are hereby granted a limited, worldwide, non-exclusive, non-sublicensable, and nontransferable right to use the SDK solely in the manner described in the Documentation and solely to develop, test, and operate Applications in connection with GDU products. 
+        3.2 Use Restrictions. You may not use the SDK except as permitted in this Agreement and any additional terms and conditions that GDU provides pursuant to Section 3.1. Except with GDU’s prior written consent or otherwise provided herein, you may not: (a) alter, modify or create any derivative works of the SDK, including the underlying source code, or the Documentation in any way, including without limitation customization, translation or localization; (b) port, reverse compile, reverse assemble, reverse engineer, or otherwise attempt to separate any of the components of the SDK or derive the source code for the SDK (except to the extent applicable laws specifically prohibit such restriction); (c) copy, redistribute, encumber, sell, rent, lease, sublicense, or otherwise transfer rights to the SDK; (d) remove or alter any trademark, logo, copyright or other proprietary notices, legends, symbols or labels in the SDK; (e) block, disable, or otherwise affect any advertising, advertisement banner window, links to other sites and services, or other features that constitute an integral part of the SDK; or (f) use any part of the SDK to develop applications for use with hardware devices that are not GDU Products, unless they are the devices running the applications or are devices connected (directly or indirectly) to GDU Product(s) the SDK interfaces with. You may not release the results of any performance or functional evaluation of any of the SDK to any third-party without prior written approval of GDU for each such release. You may not cause or permit any third-party to do any of the foregoing.
+        3.3 Distribution of Object Code. You may distribute your Application with object code of the SDK, provided that you must: (1) distribute such object code of the SDK in execution form only; (2) distribute such code only as a part of your Applications; (3) not distribute any portion of the SDK that is not object code, including but not limited to source code, header files and Documentation; (4) not charge a separate price or fee for the object code of the SDK that is distinct from the fee you charge for your Application; (5) not distribute, link, or integrate the object code of the SDK such that any part of the object code of the SDK becomes subject to an open source license; and (6) include the following copyright notice within your Application’s source code in the same locations as your own copyright notice: “Portions copyright (c) 2014–Present GDU. All rights reserved.”. To the extent that any source code is provided to you as part of the SDK, you may use, modify and compile the source code solely for the purposes of developing your Applications. 
+        3.4 Third-Party Components. You acknowledge that the SDK may contain Third-Party Components. All third-party licensors and suppliers retain all right, title and interest in and to such Third-Party Components and all copies thereof, including all copyright and other intellectual property rights. Your use of any Third-Party Components shall be subject to, and you shall comply with, the terms and conditions of this Agreement, and the applicable restrictions and other terms and conditions set forth in any Third-Party Components documentation or printed materials, including without limitation an end user license agreement.
+        3.5 Open-Source Components. The SDK may include Open-Source Components that are subject to open-source software licenses. The Documentation accompanying the SDK includes copies of the licenses applicable to the Open-Source Components. To the extent there is conflict between the license terms covering the Open-Source Components and this Agreement, the terms of such licenses will apply in lieu of the terms of this Agreement. To the extent the terms of the licenses applicable to Open-Source Components prohibit any of the restrictions in this Agreement with respect to such Open-Source Component, such restrictions will not apply to such Open-Source Component. 
+    4. Reservation of Rights. GDU and its licensors reserve all rights, including but not limited to ownership and intellectual property rights, including in the SDK, not expressly granted to you. GDU’s licensors are the intended third-party beneficiaries of this Agreement and have the express right to rely upon and directly enforce the terms set forth herein. There are no implied licenses granted by GDU under this Agreement. Except as specified above, you shall have no rights to the SDK. You acknowledge and agree that the form and nature of the SDK that GDU provides may change without prior notice to you and that future versions of the SDK may be incompatible with Applications developed on previous versions of the SDK. You acknowledge and agree that GDU may stop providing the SDK or any features of the SDK permanently or temporarily to you or users generally at GDU’s sole discretion, without prior notice to you. If the SDK is a “beta” release, you acknowledge and agree that the SDK is a “beta” release for evaluation purposes only and may contain bugs, defects and errors and that the SDK may fail, return inaccurate results, and/or be subject to other malfunctions.
+    5. Your Applications and Use of the SDK.
+        5.1 Rights in Your Applications. Subject to Section 4 above, GDU agrees that it obtains no right, title, or interest from you (or your licensors) under this Agreement in or to any Applications that you develop using the SDK, including any sole and separate intellectual property rights of yours that subsist in those Applications. 
+        5.2 Permitted Applications. You agree to use the SDK and develop Applications solely for purposes that are permitted by: (a) this Agreement; (b) the GDU Developer Policy available at https://developer.gdu.com/policies/developer/; and (c) any applicable law, rule, regulation, or generally accepted practice or guideline in the relevant jurisdiction, including but not limited to laws, rules, or regulations regarding the export of data or software to and from the United States or other relevant countries, and national, public, and personal security.
+        5.3 Your Responsibilities. You agree that you are solely responsible for, and that GDU has no responsibility to you or any third-party for, or access to: (a) any data, content, or resources that you create, transmit, or display through the Applications you develop on or with the SDK (whether originating with you or a third-party), and for the consequences of your actions (including any loss or damage suffered by GDU) by doing so; and (b) any breach of your obligations under this Agreement, any applicable third-party contract or terms of service, or any applicable law, rule, or regulation, and for the consequences (including any loss or damage suffered by GDU) of any such breach.
+        5.4 Compliance with Law; Safety. For the avoidance of doubt, you agree that you shall at all times strictly comply with all applicable laws, rules and regulations and shall not threaten the safety of national security, public security, or the health, privacy, or safety of any person.
+    6. Privacy and Automatically Collected Information. 
+        6.1 SDK Use and User Information.  In order to continually improve the SDK, GDU may automatically collect certain usage statistics including, but not limited to, unique identifiers, associated IP address, and other information on which tools and services in the SDK are being used and how they are being used. This data is collected in the aggregate to improve the SDK and is maintained in accordance with GDU’s Privacy Policy. We may also collect certain personal information from you, including but not limited to your legal name, mailing address, phone number, email address, and other contact or personal information. We may also collect additional information in order to verify your identity or provide certain functions. This information will be maintained in accordance with GDU’s Privacy Policy, and you hereby agree that we may share this information with our third-party business partners for purposes of verifying your identity or provide certain functions and as otherwise permitted by our Privacy Policy.
+        6.2 Application User Information.  The SDK may automatically collect Analytics Data, such as Header Data and/or Event Data. The Analytics Data may be provided to GDU and used by GDU for any use in research or improving its SDK or GDU Products. The Analytics Data may be used by GDU for any lawful purpose, including without limitation, for research or to improve its SDK or GDU Products. Certain SDK (e.g., Mobile SDK) may also automatically collect Warranty Log information, for example, for the purpose of determining warranty eligibility and product reliability. The Warranty Logs are stored locally on a device running the Application (e.g., mobile device) and are not automatically transmitted to GDU without prior user consent. You may be required to make the Warranty Logs available to GDU to support any warranty claims regarding the SDK. By using the SDK and creating an Application, you represent and warrant that you will provide clear and conspicuous notice to each user of the Application of the automatic collection, storage, and GDU’s use of the Analytics Data and Warranty Logs, and that you will obtain any legally-required consents for GDU to receive and use the Analytics Data and Warranty Logs for the purposes specified herein. The Application User Information is maintained in accordance with GDU’s Privacy Policy located at https://developer.gdu.com/policies/privacy/.
+    7. Proprietary Rights. You acknowledge and agree that the SDK belongs to GDU or its licensors. You agree that you neither own nor hereby acquire any claim or right of ownership to the SDK or to any related patents, copyrights, trademarks, or other intellectual property. GDU and its licensors retain all right, title, and interest in and to all copies of the SDK at all times, regardless of the form or media in or on which the original or other copies may subsequently exist. This license is not a sale of the original or any subsequent copy. The SDK is protected by copyright and other intellectual property laws and by international treaties. You may not make any copies of the SDK except as otherwise permitted by this Agreement. Any and all other copies of the SDK made by you are in violation of this license. All content accessed through the SDK is the property of the applicable content owner and may be protected by applicable copyright law. This license gives you no rights to such content. All trademarks used in connection with the SDK are owned by GDU, its affiliates and/or its licensors and other suppliers, and no license to use any such trademarks is provided hereunder.
+    8. Information Submitted to GDU Not Deemed Confidential. GDU works with many application developers and some of their products may be similar to or compete with Your Applications. GDU may also be developing its own similar or competing applications, or may decide to do so in the future. To avoid potential misunderstandings, GDU CANNOT AGREE, AND EXPRESSLY DISCLAIMS, ANY CONFIDENTIALITY OBLIGATIONS OR USE RESTRICTIONS, EXPRESS OR IMPLIED, WITH RESPECT TO ANY LICENSEE DISCLOSURE. Such licensee disclosure may include, for example, feedback on errors and improvements within or relating to the SDK. You agree any such licensee disclosure will be non-confidential. GDU will be free to use and disclose any licensee disclosure on an unrestricted basis without notifying or compensating you. You release GDU from all liability and obligations that may arise from the receipt, review, use, or disclosure of any portion of any licensee disclosure. Any physical materials you submit to GDU will become GDU property and GDU will have no obligation to return those materials to you or to certify their destruction.
+    9. No Support. This Agreement does not entitle you to receive from GDU or its licensors hard-copy documentation, support, telephone assistance, or enhancements or updates to the SDK.
+    10. Term and Termination. This Agreement and your right to use the SDK may be terminated by you or by GDU at any time upon written notice. This Agreement automatically terminates if you fail to comply with its terms and conditions. Immediately upon termination, you shall return or destroy all copies of the SDK in your possession, custody, or control and, if requested by GDU, you shall certify to GDU in writing that such return or destruction has occurred. The following Sections of this Agreement survive any expiration or termination hereof: 1, 2, 3.2, 3.3, 3.4, 3.5, and 4 through 18 (inclusive).
+    11. No warranty. YOU AGREE THAT THE SDK IS PROVIDED “AS IS” AND THAT GDU AND ITS LICENSORS MAKE NO OTHER WARRANTY AS TO THE SDK, INCLUDING, BUT NOT LIMITED TO, UNINTERRUPTED USE, ACCURACY, AND DATA LOSS. GDU AND ITS LICENSORS DISCLAIM ALL OTHER WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, PRIVACY, SECURITY, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE (EVEN IF GDU KNOWS OR SHOULD HAVE KNOWN OF SUCH PURPOSE), RELATED TO THE SDK, ITS USE OR ANY INABILITY TO USE IT, THE RESULTS OF ITS USE AND THIS AGREEMENT. GDU AND ITS LICENSORS DO NOT WARRANT THAT THE SDK OR ANY RESULTS OF USE THEREOF WILL BE FREE OF DEFECTS, ERRORS OR VIRUSES, RELIABLE OR ABLE TO OPERATE ON AN UNINTERRUPTED BASIS OR IN A PARTICULAR ENVIRONMENT OR THAT ERRORS THEREIN, IF ANY, WILL BE CORRECTED.
+    12. Limitation of Liability. TO THE FULLEST EXTENT PERMITTED BY LAW, GDU AND ITS AFFILIATES AND LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES, WHETHER IN CONTRACT OR TORT (INCLUDING NEGLIGENCE) OR ANY OTHER LEGAL OR EQUITABLE THEORY, ARISING FROM THIS AGREEMENT AND/OR YOUR USE OF THE SDK OR DEVELOPMENT OR DISTRIBUTION OF ANY APPLICATION, INCLUDING WITHOUT LIMITATION ANY INDIRECT, CONSEQUENTIAL, SPECIAL, EXEMPLARY, INCIDENTAL DAMAGES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. YOU AGREE THAT YOU SHALL HAVE THE SOLE RESPONSIBILITY FOR PROTECTING YOUR DATA, BY PERIODIC BACKUP OR OTHERWISE, USED IN CONNECTION WITH THE SDK. IN ANY CASE, GDU AND ITS AFFILIATES AND LICENSORS’ SOLE LIABILITY AND YOUR EXCLUSIVE REMEDY UNDER ANY PROVISION OF THIS AGREEMENT SHALL BE TO STOP USING THE SDK, WITH THE EXCEPTION OF DEATH OR PERSONAL INJURY CAUSED BY THE SOLE NEGLIGENCE OF GDU, AND SOLELY TO THE EXTENT APPLICABLE LAW PROHIBITS THE LIMITATION OF DAMAGES IN SUCH CASES.
+    13. Indemnification. TO THE MAXIMUM EXTENT PERMITTED BY LAW, YOU AGREE TO DEFEND, INDEMNIFY, AND HOLD HARMLESS GDU, ITS AFFILIATES AND THEIR RESPECTIVE DIRECTORS, OFFICERS, EMPLOYEES, AND AGENTS FROM AND AGAINST ANY AND ALL CLAIMS, ACTIONS, SUITS, OR PROCEEDINGS, AS WELL AS ANY AND ALL LOSSES, LIABILITIES, DAMAGES, COSTS, AND EXPENSES (INCLUDING REASONABLE ATTORNEYS’ FEES) ARISING OUT OF OR ACCRUING FROM: (A) YOUR USE OF THE SDK, INCLUDING THIRD-PARTY SOFTWARE AND/OR DOCUMENTATION; (B) ANY APPLICATION YOU DEVELOP ON OR WITH THE SDK THAT IS ALLEGED TO OR DETERMINED TO INFRINGE ANY PATENT, COPYRIGHT, TRADEMARK, OR OTHER INTELLECTUAL PROPERTY OR PROPRIETARY RIGHT OF A THIRD PARTY; AND (C) YOUR NONCOMPLIANCE WITH ANY TERM OF THIS AGREEMENT, EXCEPT FOR DEATH OR PERSONAL INJURY CAUSED BY THE SOLE NEGLIGENCE OF GDU.
+    14. Confidentiality. You shall use your best efforts to preserve and protect the confidentiality of the Confidential Information at all times, both during the term hereof and for a period of at least 3 years after termination of this Agreement, provided, however, that any source code you receive shall be held in confidence in perpetuity. You shall not disclose, disseminate, or otherwise publish or communicate Confidential Information to any person, firm, corporation or other third-party without the prior written consent of GDU. You shall not use any Confidential Information other than in the course of the activities permitted hereunder. You agree to use your best efforts to prevent and protect the contents of the SDK from unauthorized disclosure or use. You shall notify GDU in writing immediately upon discovery of any unauthorized use or disclosure of Confidential Information or any other breach of this Agreement, and will cooperate with GDU in every reasonable way to regain possession of Confidential Information and prevent any further unauthorized use.
+If you are legally compelled to disclose any of the Confidential Information, then, prior to such disclosure, you will (i) immediately notify GDU prior to such disclosure to allow GDU an opportunity to contest the disclosure, (ii) assert the privileged and confidential nature of the Confidential Information, and (iii) cooperate fully with GDU in protecting against any such disclosure and/or obtaining a protective order narrowing the scope of such disclosure and/or use of the Confidential Information. In the event such protection is not obtained, you shall disclose the Confidential Information only to the extent necessary to comply with the applicable legal requirements.
+    15. Injunctive Relief. You acknowledge and agree that your breach or threatened breach of this Agreement shall cause GDU irreparable damage for which recovery of money damages would be inadequate and that GDU therefore may obtain timely injunctive relief to protect its rights under this Agreement in addition to any and all other remedies available at law or in equity.
+    16. Export Controls. The SDK and the underlying information and technology may not be downloaded or otherwise exported or re-exported (a) into (or to a national or resident of) any country to which the U.S. has embargoed goods; or (b) to or through or involve any party on any U.S. government screening or prohibited list (including those as updated from time-to-time on the U.S. Consolidated Screening List (available at http://export.gov/ecr/eg_main_023148.asp). By downloading or using the SDK and/or Documentation, you are agreeing to the foregoing and you represent and warrant that you are not located in, under the control of, or a national or resident of any such country or on any such list and you agree to comply with all export laws and other applicable laws.
+    17. Miscellaneous. (a) This Agreement, together with any amendments and any additional agreements you may enter into with GDU in connection with the use of SDK, shall constitute the entire agreement between the parties concerning the subject matter hereof, which may only be modified by a written amendment signed by an authorized executive of GDU. (b) Any dispute, controversy, difference or claim arising out of or relating to this contract, including the existence, validity, interpretation, performance, breach or termination thereof or any dispute regarding non-contractual obligations arising out of or relating to it shall be referred to and finally resolved by arbitration administered by the Hong Kong International Arbitration Centre (“HKIAC”) under the HKIAC Administered Arbitration Rules in force when the Notice of Arbitration is submitted. The law of this arbitration clause shall be Hong Kong law, excluding its conflict of law provisions. The seat of arbitration shall be Hong Kong. The number of arbitrators shall be three (3) in accordance with such rules. The arbitration proceedings shall be conducted in English. Any awards of shall be final and binding upon the applicable parties. (c) This Agreement shall not be governed by the United Nations Convention on Contracts for the International Sale of Goods. (d) If any part of this Agreement is held invalid or unenforceable, that part shall be construed to reflect the parties' original intent, and the remaining portions remain in full force and effect, or GDU may at its option terminate this Agreement. (e) The controlling language of this Agreement is English. If you have received a translation into another language, it has been provided for your convenience only. (f) A waiver by either party of any term or condition of this Agreement or any breach thereof, in any one instance, shall not waive such term or condition or any subsequent breach thereof. (g) You may not assign or otherwise transfer by operation of law or otherwise this Agreement or any rights or obligations herein. GDU may assign this Agreement to any entity at its sole discretion. (h) This Agreement shall be binding upon and shall inure to the benefit of the parties, their successors and permitted assigns.
+    18. User Outside the People’s Republic of China. If you are using the SDK outside the People’s Republic of China, then the following shall apply: (a) You confirm that this Agreement and all related documentation is and will be in the English language; (b) you are responsible for complying with any local laws in your jurisdiction which might impact your right to import, export or use the SDK, and you represent that you have complied with any regulations or registration procedures required by applicable law to make this license enforceable.
+
+This End User License Agreement was last modified on December 11, 2017.

+The following portions of the GDU’s Payload SDK (“Software” referred to in the terms below) are made available to you under the terms of the MIT License. A copy of the MIT license is available at https://opensource.org/licenses/MIT.
+
+.
+├── CMakeLists.txt
+├── doc
+│   ├── gdu_sdk_code_style
+│   │   ├── gdu_sdk_template.c
+│   │   └── gdu_sdk_template.h
+│   └── simple_model
+│       ├── M300_OSDK_Adapter.stp
+│       ├── M300_RTK_1.stp
+│       ├── M300_RTK_2.stp
+│       ├── M300_RTK_3.stp
+│       ├── Skyport_Adapter_2.stp
+│       └── X-Port 80mm.stp
+├── EULA.txt
+├── LICENSE.txt
+├── psdk_lib
+│   ├── include
+│   │   ├── gdu_aircraft_info.h
+│   │   ├── gdu__manager.h
+│   │   ├── gdu_core.h
+│   │   ├── gdu_error.h
+│   │   ├── gdu_fc_subscription.h
+│   │   ├── gdu_flight_controller.h
+│   │   ├── gdu_gimbal.h
+│   │   ├── gdu_gimbal_manager.h
+│   │   ├── gdu_high_speed_data_channel.h
+│   │   ├── gdu_hms.h
+│   │   ├── gdu_hms_info_table.h
+│   │   ├── gdu_liveview.h
+│   │   ├── gdu_logger.h
+│   │   ├── gdu_low_speed_data_channel.h
+│   │   ├── gdu_mop_channel.h
+│   │   ├── gdu_payload_.h
+│   │   ├── gdu_perception.h
+│   │   ├── gdu_platform.h
+│   │   ├── gdu_positioning.h
+│   │   ├── gdu_power_management.h
+│   │   ├── gdu_time_sync.h
+│   │   ├── gdu_typedef.h
+│   │   ├── gdu_upgrade.h
+│   │   ├── gdu_version.h
+│   │   ├── gdu_waypoint_v2.h
+│   │   ├── gdu_waypoint_v2_type.h
+│   │   ├── gdu_widget.h
+│   │   ├── gdu_xport.h
+│   │   └── legacy_psdk2.x
+│   │       ├── psdk_aircraft_info.h
+│   │       ├── psdk_core.h
+│   │       ├── psdk_data_channel.h
+│   │       ├── psdk_data_subscription.h
+│   │       ├── psdk_data_transmission.h
+│   │       ├── psdk_error.h
+│   │       ├── psdk_gimbal.h
+│   │       ├── psdk_logger.h
+│   │       ├── psdk_mop_channel.h
+│   │       ├── psdk_payload_.h
+│   │       ├── psdk_payload_collaboration.h
+│   │       ├── psdk_platform.h
+│   │       ├── psdk_positioning.h
+│   │       ├── psdk_power_management.h
+│   │       ├── psdk_product_info.h
+│   │       ├── psdk_time_sync.h
+│   │       ├── psdk_typedef.h
+│   │       ├── psdk_upgrade.h
+│   │       ├── psdk_version.h
+│   │       ├── psdk_widget.h
+│   │       └── psdk_xport.h
+│   └── lib
+│       ├── aarch64-himix100-linux-gcc
+│       │   └── libpayloadsdk.a
+│       ├── aarch64-linux-android-gcc
+│       │   └── libpayloadsdk.a
+│       ├── aarch64-linux-gnu-gcc
+│       │   └── libpayloadsdk.a
+│       ├── armcc_cortex-m4
+│       │   └── libpayloadsdk.lib
+│       ├── arm-himix100-linux-gcc
+│       │   └── libpayloadsdk.a
+│       ├── arm-himix200-linux-gcc
+│       │   └── libpayloadsdk.a
+│       ├── arm-hisiv300-linux-gcc
+│       │   └── libpayloadsdk.a
+│       ├── arm-hisiv400-linux-gcc
+│       │   └── libpayloadsdk.a
+│       ├── arm-hisiv500-linux-gcc
+│       │   └── libpayloadsdk.a
+│       ├── arm-hisiv600-linux-gcc
+│       │   └── libpayloadsdk.a
+│       ├── arm-linux-androideabi-gcc
+│       │   └── libpayloadsdk.a
+│       ├── arm-linux-gnueabi-gcc
+│       │   └── libpayloadsdk.a
+│       ├── arm-linux-gnueabihf-gcc
+│       │   └── libpayloadsdk.a
+│       ├── arm-none-eabi-gcc
+│       │   └── libpayloadsdk.a
+│       └── x86_64-linux-gnu-gcc
+│           └── libpayloadsdk.a
+├── README.md
+├── samples
+│   ├── sample_c
+│   │   ├── module_sample
+│   │   │   ├── _emu
+│   │   │   │   ├── gdu_media_file_manage
+│   │   │   │   │   ├── gdu_media_file_core.c
+│   │   │   │   │   ├── gdu_media_file_core.h
+│   │   │   │   │   ├── gdu_media_file_jpg.c
+│   │   │   │   │   ├── gdu_media_file_jpg.h
+│   │   │   │   │   ├── gdu_media_file_mp4.c
+│   │   │   │   │   └── gdu_media_file_mp4.h
+│   │   │   │   ├── media_file
+│   │   │   │   │   ├── out.h264
+│   │   │   │   │   ├── PSDK_0001_ORG.jpg
+│   │   │   │   │   ├── PSDK_0002_ORG.jpg
+│   │   │   │   │   ├── PSDK_0003_ORG.jpg
+│   │   │   │   │   ├── PSDK_0004_ORG.mp4
+│   │   │   │   │   └── PSDK_0005.h264
+│   │   │   │   ├── test_payload_cam_emu_base.c
+│   │   │   │   ├── test_payload_cam_emu_base.h
+│   │   │   │   ├── test_payload_cam_emu_media.c
+│   │   │   │   └── test_payload_cam_emu_media.h
+│   │   │   ├── _manager
+│   │   │   │   ├── test__manager.c
+│   │   │   │   └── test__manager.h
+│   │   │   ├── data_transmission
+│   │   │   │   ├── test_data_transmission.c
+│   │   │   │   └── test_data_transmission.h
+│   │   │   ├── fc_subscription
+│   │   │   │   ├── test_fc_subscription.c
+│   │   │   │   └── test_fc_subscription.h
+│   │   │   ├── flight_control
+│   │   │   │   ├── test_flight_control.c
+│   │   │   │   └── test_flight_control.h
+│   │   │   ├── gimbal_emu
+│   │   │   │   ├── test_payload_gimbal_emu.c
+│   │   │   │   └── test_payload_gimbal_emu.h
+│   │   │   ├── gimbal_manager
+│   │   │   │   ├── test_gimbal_manager.c
+│   │   │   │   └── test_gimbal_manager.h
+│   │   │   ├── hms
+│   │   │   │   ├── test_hms.c
+│   │   │   │   └── test_hms.h
+│   │   │   ├── liveview
+│   │   │   │   ├── test_liveview.c
+│   │   │   │   └── test_liveview.h
+│   │   │   ├── mop_channel
+│   │   │   │   ├── mop_channel_test_file
+│   │   │   │   │   └── mop_send_test_file.mp4
+│   │   │   │   ├── test_mop_channel.c
+│   │   │   │   └── test_mop_channel.h
+│   │   │   ├── payload_collaboration
+│   │   │   │   ├── test_payload_collaboration.c
+│   │   │   │   └── test_payload_collaboration.h
+│   │   │   ├── perception
+│   │   │   │   ├── test_perception.c
+│   │   │   │   └── test_perception.h
+│   │   │   ├── positioning
+│   │   │   │   ├── test_positioning.c
+│   │   │   │   └── test_positioning.h
+│   │   │   ├── power_management
+│   │   │   │   ├── test_power_management.c
+│   │   │   │   └── test_power_management.h
+│   │   │   ├── time_sync
+│   │   │   │   ├── test_time_sync.c
+│   │   │   │   └── test_time_sync.h
+│   │   │   ├── upgrade
+│   │   │   │   ├── test_upgrade.c
+│   │   │   │   ├── test_upgrade_common_file_transfer.c
+│   │   │   │   ├── test_upgrade_common_file_transfer.h
+│   │   │   │   ├── test_upgrade.h
+│   │   │   │   ├── test_upgrade_platform_opt.c
+│   │   │   │   └── test_upgrade_platform_opt.h
+│   │   │   ├── utils
+│   │   │   │   ├── util_buffer.c
+│   │   │   │   ├── util_buffer.h
+│   │   │   │   ├── util_file.c
+│   │   │   │   ├── util_file.h
+│   │   │   │   ├── util_md5.c
+│   │   │   │   ├── util_md5.h
+│   │   │   │   ├── util_misc.c
+│   │   │   │   ├── util_misc.h
+│   │   │   │   ├── util_time.c
+│   │   │   │   └── util_time.h
+│   │   │   ├── waypoint_v2
+│   │   │   │   ├── test_waypoint_v2.c
+│   │   │   │   └── test_waypoint_v2.h
+│   │   │   ├── widget
+│   │   │   │   ├── file_binary_array_list_en.c
+│   │   │   │   ├── file_binary_array_list_en.h
+│   │   │   │   ├── test_widget.c
+│   │   │   │   ├── test_widget.h
+│   │   │   │   ├── widget_file
+│   │   │   │   │   ├── cn_big_screen
+│   │   │   │   │   │   ├── icon_button1.png
+│   │   │   │   │   │   ├── icon_button2.png
+│   │   │   │   │   │   ├── icon_list_item1.png
+│   │   │   │   │   │   ├── icon_list_item2.png
+│   │   │   │   │   │   ├── icon_scale.png
+│   │   │   │   │   │   ├── icon_switch_select.png
+│   │   │   │   │   │   ├── icon_switch_unselect.png
+│   │   │   │   │   │   └── widget_config.json
+│   │   │   │   │   └── en_big_screen
+│   │   │   │   │       ├── icon_button1.png
+│   │   │   │   │       ├── icon_button2.png
+│   │   │   │   │       ├── icon_list_item1.png
+│   │   │   │   │       ├── icon_list_item2.png
+│   │   │   │   │       ├── icon_scale.png
+│   │   │   │   │       ├── icon_switch_select.png
+│   │   │   │   │       ├── icon_switch_unselect.png
+│   │   │   │   │       └── widget_config.json
+│   │   │   │   └── widget_file_c
+│   │   │   │       └── en_big_screen
+│   │   │   │           ├── icon_button1_png.h
+│   │   │   │           ├── icon_button2_png.h
+│   │   │   │           ├── icon_list_item1_png.h
+│   │   │   │           ├── icon_list_item2_png.h
+│   │   │   │           ├── icon_scale_png.h
+│   │   │   │           ├── icon_switch_select_png.h
+│   │   │   │           ├── icon_switch_unselect_png.h
+│   │   │   │           └── widget_config_json.h
+│   │   │   ├── widget_interaction_test
+│   │   │   │   ├── file_binary_array_list_en.c
+│   │   │   │   ├── file_binary_array_list_en.h
+│   │   │   │   ├── test_widget_interaction.c
+│   │   │   │   ├── test_widget_interaction.h
+│   │   │   │   ├── widget_file
+│   │   │   │   │   ├── cn_big_screen
+│   │   │   │   │   │   ├── icon_button1.png
+│   │   │   │   │   │   ├── icon_button2.png
+│   │   │   │   │   │   ├── icon_list_item1.png
+│   │   │   │   │   │   ├── icon_list_item2.png
+│   │   │   │   │   │   ├── icon_scale.png
+│   │   │   │   │   │   ├── icon_switch_select.png
+│   │   │   │   │   │   ├── icon_switch_unselect.png
+│   │   │   │   │   │   └── widget_config.json
+│   │   │   │   │   └── en_big_screen
+│   │   │   │   │       ├── icon_button1.png
+│   │   │   │   │       ├── icon_button2.png
+│   │   │   │   │       ├── icon_list_item1.png
+│   │   │   │   │       ├── icon_list_item2.png
+│   │   │   │   │       ├── icon_scale.png
+│   │   │   │   │       ├── icon_switch_select.png
+│   │   │   │   │       ├── icon_switch_unselect.png
+│   │   │   │   │       └── widget_config.json
+│   │   │   │   └── widget_file_c
+│   │   │   │       └── en_big_screen
+│   │   │   │           ├── icon_button1_png.h
+│   │   │   │           ├── icon_button2_png.h
+│   │   │   │           ├── icon_list_item1_png.h
+│   │   │   │           ├── icon_list_item2_png.h
+│   │   │   │           ├── icon_scale_png.h
+│   │   │   │           ├── icon_switch_select_png.h
+│   │   │   │           ├── icon_switch_unselect_png.h
+│   │   │   │           └── widget_config_json.h
+│   │   │   └── xport
+│   │   │       ├── test_payload_xport.c
+│   │   │       └── test_payload_xport.h
+│   │   └── platform
+│   │       ├── linux
+│   │       │   ├── common
+│   │       │   │   ├── 3rdparty
+│   │       │   │   │   └── ffmpeg
+│   │       │   │   │       └── FindFFMPEG.cmake
+│   │       │   │   ├── monitor
+│   │       │   │   │   ├── sys_monitor.c
+│   │       │   │   │   └── sys_monitor.h
+│   │       │   │   ├── osal
+│   │       │   │   │   ├── osal.c
+│   │       │   │   │   ├── osal_fs.c
+│   │       │   │   │   ├── osal_fs.h
+│   │       │   │   │   ├── osal.h
+│   │       │   │   │   ├── osal_socket.c
+│   │       │   │   │   └── osal_socket.h
+│   │       │   │   └── upgrade_platform_opt
+│   │       │   │       ├── upgrade_platform_opt_linux.c
+│   │       │   │       └── upgrade_platform_opt_linux.h
+│   │       │   └── manifold2
+│   │       │       ├── application
+│   │       │       │   ├── gdu_sdk_app_info.h
+│   │       │       │   ├── gdu_sdk_config.h
+│   │       │       │   └── main.c
+│   │       │       ├── CMakeLists.txt
+│   │       │       └── hal
+│   │       │           ├── hal_network.c
+│   │       │           ├── hal_network.h
+│   │       │           ├── hal_uart.c
+│   │       │           ├── hal_uart.h
+│   │       │           ├── hal_usb_bulk.c
+│   │       │           └── hal_usb_bulk.h
+│   │       └── rtos_freertos
+│   │           ├── common
+│   │           │   └── osal
+│   │           │       ├── osal.c
+│   │           │       └── osal.h
+│   │           └── stm32f4_discovery
+│   │               ├── application
+│   │               │   ├── application.c
+│   │               │   ├── application.h
+│   │               │   ├── gdu_sdk_app_info.h
+│   │               │   ├── gdu_sdk_config.h
+│   │               │   ├── FreeRTOSConfig.h
+│   │               │   └── main.c
+│   │               ├── drivers
+│   │               │   ├── BSP
+│   │               │   │   ├── apply_high_power.c
+│   │               │   │   ├── apply_high_power.h
+│   │               │   │   ├── gdu_ringbuffer.c
+│   │               │   │   ├── gdu_ringbuffer.h
+│   │               │   │   ├── freertos.c
+│   │               │   │   ├── led.c
+│   │               │   │   ├── led.h
+│   │               │   │   ├── pps.c
+│   │               │   │   ├── pps.h
+│   │               │   │   ├── startup_stm32f407vgtx.s
+│   │               │   │   ├── stm32f4xx_hal_conf.h
+│   │               │   │   ├── stm32f4xx_hal_msp.c
+│   │               │   │   ├── stm32f4xx_hal_timebase_tim.c
+│   │               │   │   ├── stm32f4xx_it.c
+│   │               │   │   ├── stm32f4xx_it.h
+│   │               │   │   ├── syscalls.c
+│   │               │   │   ├── sysmem.c
+│   │               │   │   ├── system_stm32f4xx.c
+│   │               │   │   ├── uart.c
+│   │               │   │   └── uart.h
+│   │               │   ├── CMSIS
+│   │               │   │   ├── Device
+│   │               │   │   │   └── ST
+│   │               │   │   │       └── STM32F4xx
+│   │               │   │   │           ├── Include
+│   │               │   │   │           └── Source
+│   │               │   │   └── Include
+│   │               │   ├── STM32F4xx_HAL_Driver
+│   │               │   │   ├── Inc
+│   │               │   │   └── Src
+│   │               │   └── USB_HOST
+│   │               │       ├── App
+│   │               │       │   ├── usb_host.c
+│   │               │       │   └── usb_host.h
+│   │               │       └── Target
+│   │               │           ├── usbh_conf.c
+│   │               │           └── usbh_conf.h
+│   │               ├── hal
+│   │               │   ├── hal_uart.c
+│   │               │   └── hal_uart.h
+│   │               ├── middlewares
+│   │               │   ├── ST
+│   │               │   │   └── STM32_USB_Host_Library
+│   │               │   │       ├── Class
+│   │               │   │       │   └── CDC
+│   │               │   │       │       ├── Inc
+│   │               │   │       │       │   └── usbh_cdc.h
+│   │               │   │       │       └── Src
+│   │               │   │       │           └── usbh_cdc.c
+│   │               │   │       └── Core
+│   │               │   │           ├── Inc
+│   │               │   │           │   ├── usbh_core.h
+│   │               │   │           │   ├── usbh_ctlreq.h
+│   │               │   │           │   ├── usbh_def.h
+│   │               │   │           │   ├── usbh_ioreq.h
+│   │               │   │           │   └── usbh_pipes.h
+│   │               │   │           └── Src
+│   │               │   │               ├── usbh_core.c
+│   │               │   │               ├── usbh_ctlreq.c
+│   │               │   │               ├── usbh_ioreq.c
+│   │               │   │               └── usbh_pipes.c
+│   │               │   └── Third_Party
+│   │               │       └── FreeRTOS
+│   │               │           └── Source
+│   │               │               ├── CMSIS_RTOS
+│   │               │               ├── croutine.c
+│   │               │               ├── event_groups.c
+│   │               │               ├── include
+│   │               │               ├── list.c
+│   │               │               ├── portable
+│   │               │               ├── queue.c
+│   │               │               ├── stream_buffer.c
+│   │               │               ├── tasks.c
+│   │               │               └── timers.c
+│   │               └── project
+│   │                   ├── clion_app
+│   │                   │   ├── CMakeLists.txt
+│   │                   │   ├── STM32F407VGTX_FLASH.ld
+│   │                   │   └── stm32f4discovery.cfg
+│   │                   └── mdk_app
+│   │                       └── mdk_app.uvprojx
+│   └── sample_c++
+│       ├── module_sample
+│       │   ├── liveview
+│       │   │   ├── data
+│       │   │   │   ├── cars.xml
+│       │   │   │   ├── haarcascade_frontalface_alt.xml
+│       │   │   │   └── tensorflow
+│       │   │   │       ├── frozen_inference_graph.pb
+│       │   │   │       └── ssd_inception_v2_coco_2017_11_17.pbtxt
+│       │   │   ├── gdu__image_handler.cpp
+│       │   │   ├── gdu__image_handler.hpp
+│       │   │   ├── gdu__stream_decoder.cpp
+│       │   │   ├── gdu__stream_decoder.hpp
+│       │   │   ├── test_liveview.cpp
+│       │   │   ├── test_liveview_entry.cpp
+│       │   │   ├── test_liveview_entry.hpp
+│       │   │   └── test_liveview.hpp
+│       │   └── perception
+│       │       ├── test_perception.cpp
+│       │       ├── test_perception_entry.cpp
+│       │       ├── test_perception_entry.hpp
+│       │       └── test_perception.hpp
+│       └── platform
+│           └── linux
+│               ├── common
+│               │   └── osal
+│               │       ├── osal.c
+│               │       └── osal.h
+│               └── manifold2
+│                   ├── application
+│                   │   ├── application.cpp
+│                   │   ├── application.hpp
+│                   │   ├── gdu_sdk_app_info.h
+│                   │   └── main.cpp
+│                   ├── CMakeLists.txt
+│                   ├── FindFFMPEG.cmake
+│                   └── hal
+│                       ├── hal_network.c
+│                       ├── hal_network.h
+│                       ├── hal_uart.c
+│                       ├── hal_uart.h
+│                       ├── hal_usb_bulk.c
+│                     └── hal_usb_bulk.h
+└── tools
+    └── file2c
+        ├── file2c.exe
+        └── readme.txt
+
+Unless otherwise agreed, all other portions of GDU’s Payload SDK are and will be made available under the SDK End User License Agreement (EULA). A copy of the SDK EULA is distributed with this software and is available at https://developer.gdu.com/policies/eula/.
+-------------------------------------------------------------
+Copyright (c) 2021 GDU.
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+===============================================================
+GDU’s Payload SDK uses libraries of List and MD5, whose license is as below.
+
+-------------------------------------------------------------
+crypto-algorithms
+=================
+About
+---
+These are basic implementations of standard cryptography algorithms, written by Brad Conte (brad@bradconte.com) from
+scratch and without any cross-licensing. They exist to provide publically accessible, restriction-free implementations
+of popular cryptographic algorithms, like AES and SHA-1. These are primarily intended for educational and pragmatic
+purposes (such as comparing a specification to actual implementation code, or for building an internal application
+that computes test vectors for a product). The algorithms have been tested against standard test vectors.
+This code is released into the public domain free of any restrictions. The author requests acknowledgement if the code
+is used, but does not require it. This code is provided free of any liability and without any quality claims by the
+author.
+Note that these are *not* cryptographically secure implementations. They have no resistence to side-channel attacks
+and should not be used in contexts that need cryptographically secure implementations.
+These algorithms are not optimized for speed or space. They are primarily designed to be easy to read, although some
+basic optimization techniques have been employed.
+Building
+The source code for each algorithm will come in a pair of a source code file and a header file. There should be no
+inter-header file dependencies, no additional libraries, no platform-specific header files, or any other complicating
+matters. Compiling them should be as easy as adding the relevent source code to the project.
+===============================================================
+GDU’s Payload SDK uses libraries of CMSIS (https://developer.arm.com/tools-and-software/embedded/cmsis), which is licensed under the Apache License, Version 2.0. A copy of the Apache license is provided below and is also available at http://www.apache.org/licenses/LICENSE-2.0.
+
+-------------------------------------------------------------
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; and
+You must cause any modified files to carry prominent notices stating that You changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+===============================================================
+GDU’s Payload SDK uses unmodified libraries of cJSON, whose license is as below.
+
+-------------------------------------------------------------
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+===============================================================
+GDU’s Payload SDK uses unmodified libraries of freeRTOS (http://www.FreeRTOS.org), which is licensed under the MIT License. Full license text is available on the following link: http://www.freertos.org/a00114.html. A copy of the MIT license is provided below and is also available at https://opensource.org/licenses/MIT.
+
+-------------------------------------------------------------
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+===============================================================
+GDU’s Payload SDK uses unmodified libraries of STM32F4xx_HAL_Driver, BSP STM324xG_EVAL libraries and STM32 Projects libraries in STM32CubeF4 package, which is licensed by ST under BSD 3-Clause license. A copy of the license is provided below and is also available at opensource.org/licenses/BSD-3-Clause.
+
+-------------------------------------------------------------
+Note: This license has also been called the "New BSD License" or "Modified BSD License". See also the 2-clause BSD License.
+
+Copyright <YEAR> <COPYRIGHT HOLDER>
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+{
+  "enableCMake": false
+}

+{
+  "CurrentProjectSetting": "无配置"
+}

+{
+  "ExpandedNodes": [
+    "",
+    "\\sample_c",
+    "\\sample_c\\platform",
+    "\\sample_c\\platform\\linux",
+    "\\sample_c\\platform\\linux\\H3",
+    "\\sample_c\\platform\\linux\\H3\\music"
+  ],
+  "SelectedNode": "\\sample_c\\platform\\linux\\H3\\music\\music.c",
+  "PreviewInSolutionExplorer": false
+}

+/**
+ ********************************************************************
+ * @file    test_data_transmission.c
+ * @brief
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+
+/* Includes ------------------------------------------------------------------*/
+#include "test_data_transmission.h"
+#include "gdu_logger.h"
+#include "gdu_platform.h"
+#include "utils/util_misc.h"
+#include "gdu_data_transmission.h"
+#include "gdu_aircraft_info.h"
+
+/* Private constants ---------------------------------------------------------*/
+#define DATA_TRANSMISSION_TASK_FREQ         (1)
+#define DATA_TRANSMISSION_TASK_STACK_SIZE   (2048)
+
+/* Private types -------------------------------------------------------------*/
+
+/* Private functions declaration ---------------------------------------------*/
+static void *UserDataTransmission_Task(void *arg);
+static T_GduReturnCode ReceiveDataFromMobile(const uint8_t *data, uint16_t len);
+static T_GduReturnCode ReceiveDataFromCloud(const uint8_t *data, uint16_t len);
+static T_GduReturnCode ReceiveDataFromExtensionPort(const uint8_t *data, uint16_t len);
+static T_GduReturnCode ReceiveDataFromPayload(const uint8_t *data, uint16_t len);
+
+/* Private variables ---------------------------------------------------------*/
+static T_GduTaskHandle s_userDataTransmissionThread;
+static T_GduAircraftInfoBaseInfo s_aircraftInfoBaseInfo;
+
+/* Exported functions definition ---------------------------------------------*/
+T_GduReturnCode GduTest_DataTransmissionStartService(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+    E_GduChannelAddress channelAddress;
+    char ipAddr[GDU_IP_ADDR_STR_SIZE_MAX];
+    uint16_t port;
+
+    gduStat = GduLowSpeedDataChannel_Init();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("init data transmission module error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    gduStat = GduAircraftInfo_GetBaseInfo(&s_aircraftInfoBaseInfo);
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("get aircraft base info error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
+    }
+
+    channelAddress = GDU_CHANNEL_ADDRESS_MASTER_RC_APP;
+    gduStat = GduLowSpeedDataChannel_RegRecvDataCallback(channelAddress, ReceiveDataFromMobile);
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("register receive data from mobile error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (osalHandler->TaskCreate("user_transmission_task", UserDataTransmission_Task,
+                                DATA_TRANSMISSION_TASK_STACK_SIZE, NULL, &s_userDataTransmissionThread) !=
+        GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("user data transmission task create error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+T_GduReturnCode GduTest_DataTransmissionStopService(void)
+{
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+    T_GduReturnCode returnCode;
+
+    if (osalHandler->TaskDestroy(s_userDataTransmissionThread) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("user data transmission task destroy error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    returnCode = GduLowSpeedDataChannel_DeInit();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("deinit data transmission module error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/* Private functions definition-----------------------------------------------*/
+#ifndef __CC_ARM
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-noreturn"
+#pragma GCC diagnostic ignored "-Wreturn-type"
+#endif
+
+static void *UserDataTransmission_Task(void *arg)
+{
+    T_GduReturnCode gduStat;
+    const uint8_t dataToBeSent[10] = {0x00, 0x11, 0x22, 0x33, 0x44,0x55,0x66,0x77,0x88,0x99};
+    T_GduDataChannelState state = {0};
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+    E_GduChannelAddress channelAddress;
+
+    USER_UTIL_UNUSED(arg);
+
+    while (1) {
+        osalHandler->TaskSleepMs(1000 / DATA_TRANSMISSION_TASK_FREQ);
+
+        channelAddress = GDU_CHANNEL_ADDRESS_MASTER_RC_APP;
+        gduStat = GduLowSpeedDataChannel_SendData(channelAddress, dataToBeSent, sizeof(dataToBeSent));
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
+            USER_LOG_ERROR("send data to mobile error.");
+
+    }
+}
+
+#ifndef __CC_ARM
+#pragma GCC diagnostic pop
+#endif
+
+static T_GduReturnCode ReceiveDataFromMobile(const uint8_t *data, uint16_t len)
+{
+    char *printData = NULL;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    printData = osalHandler->Malloc(len + 1);
+    if (printData == NULL) {
+        USER_LOG_ERROR("malloc memory for printData fail.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED;
+    }
+
+    strncpy(printData, (const char *) data, len);
+    printData[len] = '\0';
+    USER_LOG_INFO("receive data from mobile: %s, len:%d.", printData, len);
+    GduTest_WidgetLogAppend("receive data: %s, len:%d.", printData, len);
+
+    osalHandler->Free(printData);
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode ReceiveDataFromCloud(const uint8_t *data, uint16_t len)
+{
+    char *printData = NULL;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    printData = osalHandler->Malloc(len + 1);
+    if (printData == NULL) {
+        USER_LOG_ERROR("malloc memory for printData fail.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED;
+    }
+
+    strncpy(printData, (const char *) data, len);
+    printData[len] = '\0';
+    USER_LOG_INFO("receive data from cloud: %s, len:%d.", printData, len);
+    GduTest_WidgetLogAppend("receive data: %s, len:%d.", printData, len);
+
+    osalHandler->Free(printData);
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode ReceiveDataFromExtensionPort(const uint8_t *data, uint16_t len)
+{
+    char *printData = NULL;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    printData = osalHandler->Malloc(len + 1);
+    if (printData == NULL) {
+        USER_LOG_ERROR("malloc memory for printData fail.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED;
+    }
+
+    strncpy(printData, (const char *) data, len);
+    printData[len] = '\0';
+    USER_LOG_INFO("receive data from extension port: %s, len:%d.", printData, len);
+    GduTest_WidgetLogAppend("receive data: %s, len:%d.", printData, len);
+
+    osalHandler->Free(printData);
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode ReceiveDataFromPayload(const uint8_t *data, uint16_t len)
+{
+    char *printData = NULL;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    printData = osalHandler->Malloc(len + 1);
+    if (printData == NULL) {
+        USER_LOG_ERROR("malloc memory for printData fail.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_MEMORY_ALLOC_FAILED;
+    }
+
+    strncpy(printData, (const char *) data, len);
+    printData[len] = '\0';
+    USER_LOG_INFO("receive data from payload port: %s, len:%d.", printData, len);
+    GduTest_WidgetLogAppend("receive data: %s, len:%d.", printData, len);
+
+    osalHandler->Free(printData);
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/****************** (C) COPYRIGHT GDU Innovations *****END OF FILE****/

+/**
+ ********************************************************************
+ * @file    test_data_transmission.h
+ * @brief   This is the header file for "test_data_transmission.c", defining the structure and
+ * (exported) function prototypes.
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef TEST_DATA_TRANSMISSION_H
+#define TEST_DATA_TRANSMISSION_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "gdu_typedef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Exported constants --------------------------------------------------------*/
+
+
+/* Exported types ------------------------------------------------------------*/
+
+/* Exported functions --------------------------------------------------------*/
+T_GduReturnCode GduTest_DataTransmissionStartService(void);
+T_GduReturnCode GduTest_DataTransmissionStopService(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TEST_DATA_TRANSMISSION_H
+
+/************************ (C) COPYRIGHT GDU Innovations *******END OF FILE******/

+/**
+ ********************************************************************
+ * @file    test_fc_subscription.c
+ * @brief
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include <utils/util_misc.h>
+#include <math.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include "test_fc_subscription.h"
+#include "gdu_logger.h"
+#include "gdu_platform.h"
+
+
+/* Private constants ---------------------------------------------------------*/
+#define FC_SUBSCRIPTION_TASK_FREQ         (50)
+#define FC_SUBSCRIPTION_TASK_STACK_SIZE   (2048)
+
+/* Private types -------------------------------------------------------------*/
+
+/********************** mycode *******************************/
+
+#define  Is_Show_Debug false
+
+//共享变量
+gdu_f64_t lampAngle = 0;				//转换后舵机的角度
+
+extern int gimbalLinkageState;
+extern pthread_mutex_t gimbalMutex;
+/********************** mycode *******************************/
+
+/* Private functions declaration ---------------------------------------------*/
+static void *UserFcSubscription_Task(void *arg);
+static T_GduReturnCode GduTest_FcSubscriptionReceiveQuaternionCallback(const uint8_t *data, uint16_t dataSize,
+                                                                const T_GduDataTimestamp *timestamp);
+/* Private variables ---------------------------------------------------------*/
+static T_GduTaskHandle s_userFcSubscriptionThread;
+static bool s_userFcSubscriptionDataShow = false;
+static uint8_t s_totalSatelliteNumberUsed = 0;
+
+/* Exported functions definition ---------------------------------------------*/
+
+T_GduReturnCode GduReceiveGpsPositionCallback(const uint8_t *data, uint16_t dataSize, const T_GduDataTimestamp *timestamp)
+{
+	T_GduFcSubscriptionGpsPosition *pos = (T_GduFcSubscriptionGpsPosition *)data;
+
+	//USER_LOG_DEBUG("gps position is :%d, %d, %d", pos->x, pos->y, pos->z);
+
+	return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+T_GduReturnCode GduTest_FcSubscriptionStartService(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduOsalHandler *osalHandler = NULL;
+
+    osalHandler = GduPlatform_GetOsalHandler();
+
+    gduStat = GduFcSubscription_Init();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("init data subscription module error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+//    gduStat = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_QUATERNION, GDU_DATA_SUBSCRIPTION_TOPIC_10_HZ,
+//                                               GduTest_FcSubscriptionReceiveQuaternionCallback);
+//    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+//        USER_LOG_ERROR("Subscribe topic quaternion error.");
+//        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+//    } else {
+//        USER_LOG_DEBUG("Subscribe topic quaternion success.");
+//    }
+//
+//    gduStat = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_VELOCITY, GDU_DATA_SUBSCRIPTION_TOPIC_1_HZ,
+//                                               NULL);
+//    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+//        USER_LOG_ERROR("Subscribe topic velocity error.");
+//        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+//    } else {
+//        USER_LOG_DEBUG("Subscribe topic velocity success.");
+//    }
+
+    // gduStat = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_GPS_POSITION, GDU_DATA_SUBSCRIPTION_TOPIC_1_HZ,
+    //                                            GduReceiveGpsPositionCallback);
+    // if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+    //     USER_LOG_ERROR("Subscribe topic gps position error.");
+    //     return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    // } else {
+    //     USER_LOG_DEBUG("Subscribe topic gps position success.");
+    // }
+
+    gduStat = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_GIMBAL_ANGLES, GDU_DATA_SUBSCRIPTION_TOPIC_50_HZ,
+                                               NULL);
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic gimbal angles error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    } else {
+        USER_LOG_DEBUG("Subscribe topic gimbal angles success.");
+    }
+    
+
+   // gduStat = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_GPS_DETAILS, GDU_DATA_SUBSCRIPTION_TOPIC_1_HZ,
+//                                               NULL);
+//    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+//        USER_LOG_ERROR("Subscribe topic gps details error.");
+//        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+//    } else {
+//        USER_LOG_DEBUG("Subscribe topic gps details success.");
+//    }
+     
+    pthread_mutex_init(&gimbalMutex,NULL);//初始化互斥锁
+
+     if (osalHandler->TaskCreate("user_subscription_task", UserFcSubscription_Task,
+                                 FC_SUBSCRIPTION_TASK_STACK_SIZE, NULL, &s_userFcSubscriptionThread) !=
+         GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+         USER_LOG_ERROR("user data subscription task create error.");
+         return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+     }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+T_GduReturnCode GduTest_FcSubscriptionRunSample(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+    T_GduFcSubscriptionVelocity velocity = {0};
+    T_GduDataTimestamp timestamp = {0};
+    T_GduFcSubscriptionGpsPosition gpsPosition = {0};
+    T_GduFcSubscriptionSingleBatteryInfo singleBatteryInfo = {0};
+
+    USER_LOG_INFO("Fc subscription sample start");
+
+    USER_LOG_INFO("--> Step 1: Init fc subscription module");
+    gduStat = GduFcSubscription_Init();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("init data subscription module error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    USER_LOG_INFO("--> Step 2: Subscribe the topics of quaternion, velocity and gps position");
+    gduStat = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_QUATERNION, GDU_DATA_SUBSCRIPTION_TOPIC_10_HZ,
+                                               GduTest_FcSubscriptionReceiveQuaternionCallback);
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic quaternion error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    gduStat = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_VELOCITY, GDU_DATA_SUBSCRIPTION_TOPIC_1_HZ,
+                                               NULL);
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic velocity error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    gduStat = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_GPS_POSITION, GDU_DATA_SUBSCRIPTION_TOPIC_1_HZ,
+                                               NULL);
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic gps position error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    USER_LOG_INFO("--> Step 3: Get latest value of the subscribed topics in the next 20s\r\n");
+
+    for (int i = 0; i < 10; ++i) {
+        osalHandler->TaskSleepMs(1000 / FC_SUBSCRIPTION_TASK_FREQ);
+        gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_VELOCITY,
+                                                          (uint8_t *) &velocity,
+                                                          sizeof(T_GduFcSubscriptionVelocity),
+                                                          &timestamp);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get value of topic velocity error.");
+        } else {
+            USER_LOG_INFO("velocity: x = %f y = %f z = %f healthFlag = %d.", velocity.data.x, velocity.data.y,
+                          velocity.data.z, velocity.health);
+        }
+
+        gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_GPS_POSITION,
+                                                          (uint8_t *) &gpsPosition,
+                                                          sizeof(T_GduFcSubscriptionGpsPosition),
+                                                          &timestamp);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get value of topic gps position error.");
+        } else {
+            USER_LOG_INFO("gps position: x = %d y = %d z = %d.", gpsPosition.x, gpsPosition.y, gpsPosition.z);
+        }
+
+        //Attention: if you want to subscribe the single battery info on M300 RTK, you need connect USB cable to
+        //OSDK device or use topic GDU_FC_SUBSCRIPTION_TOPIC_BATTERY_INFO instead.
+        gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_BATTERY_SINGLE_INFO_INDEX1,
+                                                          (uint8_t *) &singleBatteryInfo,
+                                                          sizeof(T_GduFcSubscriptionSingleBatteryInfo),
+                                                          &timestamp);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get value of topic battery single info index1 error.");
+        } else {
+            USER_LOG_INFO(
+                "battery single info index1: capacity percent = %ld% voltage = %ldV temperature = %.2f degree.",
+                singleBatteryInfo.batteryCapacityPercent,
+                singleBatteryInfo.currentVoltage / 1000,
+                (gdu_f32_t) singleBatteryInfo.batteryTemperature / 10);
+        }
+
+        gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_BATTERY_SINGLE_INFO_INDEX2,
+                                                          (uint8_t *) &singleBatteryInfo,
+                                                          sizeof(T_GduFcSubscriptionSingleBatteryInfo),
+                                                          &timestamp);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get value of topic battery single info index2 error.");
+        } else {
+            USER_LOG_INFO(
+                "battery single info index2: capacity percent = %ld% voltage = %ldV temperature = %.2f degree.\r\n",
+                singleBatteryInfo.batteryCapacityPercent,
+                singleBatteryInfo.currentVoltage / 1000,
+                (gdu_f32_t) singleBatteryInfo.batteryTemperature / 10);
+        }
+    }
+
+    USER_LOG_INFO("--> Step 4: Deinit fc subscription module");
+
+    gduStat = GduFcSubscription_DeInit();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Deinit fc subscription error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    USER_LOG_INFO("Fc subscription sample end");
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+T_GduReturnCode GduTest_FcSubscriptionDataShowTrigger(void)
+{
+    s_userFcSubscriptionDataShow = !s_userFcSubscriptionDataShow;
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+T_GduReturnCode GduTest_FcSubscriptionGetTotalSatelliteNumber(uint8_t *number)
+{
+    *number = s_totalSatelliteNumberUsed;
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/* Private functions definition-----------------------------------------------*/
+#ifndef __CC_ARM
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-noreturn"
+#pragma GCC diagnostic ignored "-Wreturn-type"
+#endif
+
+static void *UserFcSubscription_Task(void *arg)
+{
+    T_GduReturnCode gduStat;
+    T_GduFcSubscriptionVelocity velocity = {0};
+    T_GduDataTimestamp timestamp = {0};
+    T_GduFcSubscriptionGpsPosition gpsPosition = {0};
+    T_GduFcSubscriptionGpsDetails gpsDetails = {0};
+    T_GduOsalHandler *osalHandler = NULL;
+	T_GduFcSubscriptionGpsTime gpsTime = 0;
+	
+	T_GduFcSubscriptionGimbalAngles gimbalangle = {0};			//存储云台角度信息
+	T_GduFcSubscriptionQuaternion quaternion = {0};
+	T_GduFcSubscriptionPositionFused PositionFused = {0};   	//融合位置信息
+
+    USER_UTIL_UNUSED(arg);
+    osalHandler = GduPlatform_GetOsalHandler();
+
+    while (1) {
+       osalHandler->TaskSleepMs(1000 / FC_SUBSCRIPTION_TASK_FREQ);
+
+    //     gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_VELOCITY,
+    //                                                       (uint8_t *) &velocity,
+    //                                                       sizeof(T_GduFcSubscriptionVelocity),
+    //                                                       &timestamp);
+    //     if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+    //         USER_LOG_ERROR("get value of topic velocity error.");
+    //     }
+    //    USER_LOG_INFO("velocity: x %f y %f z %f, healthFlag %d.", velocity.data.x, velocity.data.y,
+    //                       velocity.data.z, velocity.health);
+    //     if (s_userFcSubscriptionDataShow == true) {
+    //         USER_LOG_INFO("velocity: x %f y %f z %f, healthFlag %d.", velocity.data.x, velocity.data.y,
+    //                       velocity.data.z, velocity.health);
+    //     }
+    //     else
+    //     {
+    //         printf("s_userFcSubscriptionDataShow == false\n");
+    //     }
+		
+	   pthread_mutex_lock(&gimbalMutex);
+    	//获取相机云台角度信息
+		gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_GIMBAL_ANGLES,
+                                                          (uint8_t *) &gimbalangle,
+                                                          sizeof(T_GduFcSubscriptionGimbalAngles),
+                                                          &timestamp);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get value of topic gimbal angle error.");
+        }
+		else
+		{               
+				//USER_LOG_INFO(" = %f  ",gimbalangle.x);
+                if(gimbalangle.x >= 0)
+                {
+                   lampAngle = 0;
+                }
+                else
+                {
+                   lampAngle = abs(gimbalangle.x);
+                 
+                }         
+		}
+	   pthread_mutex_unlock(&gimbalMutex);
+		
+
+        // gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_GPS_POSITION,
+        //                                                   (uint8_t *) &gpsPosition,
+        //                                                   sizeof(T_GduFcSubscriptionGpsPosition),
+        //                                                   &timestamp);
+        // if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        //     USER_LOG_ERROR("get value of topic gps position error.");
+        // }
+
+        // if (s_userFcSubscriptionDataShow == true) {
+        //     USER_LOG_INFO("gps position: x %d y %d z %d.", gpsPosition.x, gpsPosition.y, gpsPosition.z);
+        // }
+
+        // gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_GPS_DETAILS,
+        //                                                   (uint8_t *) &gpsDetails,
+        //                                                   sizeof(T_GduFcSubscriptionGpsDetails),
+        //                                                   &timestamp);
+        // if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        //     USER_LOG_ERROR("get value of topic gps details error.");
+        // }
+
+        // gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_GPS_TIME,
+        //                                                   (uint8_t *) &gpsTime,
+        //                                                   sizeof(T_GduFcSubscriptionGpsTime),
+        //                                                   &timestamp);
+        // if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        //     USER_LOG_ERROR("get value of topic gps time error.");
+        // }
+
+        // gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_GPS_DATE,
+        //                                                   (uint8_t *) &gpsTime,
+        //                                                   sizeof(T_GduFcSubscriptionGpsTime),
+        //                                                   &timestamp);
+        // if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        //     USER_LOG_ERROR("get value of topic gps time error.");
+        // }
+
+        // if (s_userFcSubscriptionDataShow == true) {
+        //     USER_LOG_INFO("gps total satellite number used: %d %d %d.",
+        //                   gpsDetails.gpsSatelliteNumberUsed,
+        //                   gpsDetails.glonassSatelliteNumberUsed,
+        //                   gpsDetails.totalSatelliteNumberUsed);
+        //     s_totalSatelliteNumberUsed = gpsDetails.totalSatelliteNumberUsed;
+        // }
+
+    }
+}
+
+#ifndef __CC_ARM
+#pragma GCC diagnostic pop
+#endif
+
+static T_GduReturnCode GduTest_FcSubscriptionReceiveQuaternionCallback(const uint8_t *data, uint16_t dataSize,
+                                                                       const T_GduDataTimestamp *timestamp)
+{
+    T_GduFcSubscriptionQuaternion *quaternion = (T_GduFcSubscriptionQuaternion *) data;
+    gdu_f64_t pitch, yaw, roll;
+
+    USER_UTIL_UNUSED(dataSize);
+
+    pitch = (gdu_f64_t) asinf(-2 * quaternion->q1 * quaternion->q3 + 2 * quaternion->q0 * quaternion->q2) * 57.3;
+    roll = (gdu_f64_t) atan2f(2 * quaternion->q1 * quaternion->q2 + 2 * quaternion->q0 * quaternion->q3,
+                              -2 * quaternion->q2 * quaternion->q2 - 2 * quaternion->q3 * quaternion->q3 + 1) *
+           57.3;
+    yaw = (gdu_f64_t) atan2f(2 * quaternion->q2 * quaternion->q3 + 2 * quaternion->q0 * quaternion->q1,
+                             -2 * quaternion->q1 * quaternion->q1 - 2 * quaternion->q2 * quaternion->q2 + 1) * 57.3;
+
+    if (s_userFcSubscriptionDataShow == true) {
+        USER_LOG_INFO("receive quaternion data.");
+
+        USER_LOG_INFO("timestamp: millisecond %u microsecond %u.", timestamp->millisecond,
+                      timestamp->microsecond);
+        USER_LOG_INFO("quaternion: %f %f %f %f.\r\n", quaternion->q0, quaternion->q1, quaternion->q2, quaternion->q3);
+        USER_LOG_INFO("euler angles: pitch = %.2f roll = %.2f yaw = %.2f.", pitch, yaw, roll);
+        //GduTest_WidgetLogAppend("pitch = %.2f roll = %.2f yaw = %.2f.", pitch, yaw, roll);
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/****************** (C) COPYRIGHT GDU Innovations *****END OF FILE****/

+/**
+ ********************************************************************
+ * @file    test_fc_subscription.h
+ * @brief   This is the header file for "test_fc_subscription.c", defining the structure and
+ * (exported) function prototypes.
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef TEST_FC_SUBSCRIPTION_H
+#define TEST_FC_SUBSCRIPTION_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "gdu_typedef.h"
+#include "gdu_fc_subscription.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Exported constants --------------------------------------------------------*/
+
+
+/* Exported types ------------------------------------------------------------*/
+
+
+/* Exported functions --------------------------------------------------------*/
+T_GduReturnCode GduTest_FcSubscriptionStartService(void);
+T_GduReturnCode GduTest_FcSubscriptionRunSample(void);
+T_GduReturnCode GduTest_FcSubscriptionDataShowTrigger(void);
+T_GduReturnCode GduTest_FcSubscriptionGetTotalSatelliteNumber(uint8_t *number);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TEST_FC_SUBSCRIPTION_H
+/************************ (C) COPYRIGHT GDU Innovations *******END OF FILE******/

+/**
+ ********************************************************************
+ * @file    test_flight_control.c
+ * @brief
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include "gdu_flight_controller.h"
+#include "test_flight_control.h"
+#include "gdu_fc_subscription.h"
+#include "gdu_platform.h"
+#include "gdu_logger.h"
+#include <math.h>
+//#include <widget_interaction_test/test_widget_interaction.h>
+/* Private constants ---------------------------------------------------------*/
+
+/* Private types -------------------------------------------------------------*/
+#pragma pack(1)
+typedef struct {
+    gdu_f32_t x;
+    gdu_f32_t y;
+    gdu_f32_t z;
+} T_GduTestFlightControlVector3f; // pack(1)
+#pragma pack()
+
+typedef struct {
+    E_GduFcSubscriptionDisplayMode displayMode;
+    char *displayModeStr;
+} T_GduTestFlightControlDisplayModeStr;
+
+/* Private values -------------------------------------------------------------*/
+static T_GduOsalHandler *s_osalHandler = NULL;
+static const double s_earthCenter = 6378137.0;
+static const double s_degToRad = 0.01745329252;
+
+static const T_GduTestFlightControlDisplayModeStr s_flightControlDisplayModeStr[] = {
+    {.displayMode = GDU_FC_SUBSCRIPTION_DISPLAY_MODE_ATTITUDE, .displayModeStr = "attitude mode"},
+    {.displayMode = GDU_FC_SUBSCRIPTION_DISPLAY_MODE_P_GPS, .displayModeStr = "p_gps mode"},
+    {.displayMode = GDU_FC_SUBSCRIPTION_DISPLAY_MODE_ASSISTED_TAKEOFF, .displayModeStr = "assisted takeoff mode"},
+    {.displayMode = GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_TAKEOFF, .displayModeStr = "auto takeoff mode"},
+    {.displayMode = GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_LANDING, .displayModeStr = "auto landing mode"},
+    {.displayMode = GDU_FC_SUBSCRIPTION_DISPLAY_MODE_NAVI_GO_HOME, .displayModeStr = "go home mode"},
+    {.displayMode = GDU_FC_SUBSCRIPTION_DISPLAY_MODE_FORCE_AUTO_LANDING, .displayModeStr = "force landing mode"},
+    {.displayMode = GDU_FC_SUBSCRIPTION_DISPLAY_MODE_ENGINE_START, .displayModeStr = "engine start mode"},
+    {.displayMode = 0xFF, .displayModeStr = "unknown mode"}
+};
+
+/* Private functions declaration ---------------------------------------------*/
+static uint8_t GduTest_FlightControlGetDisplayModeIndex(E_GduFcSubscriptionDisplayMode displayMode);
+static T_GduFcSubscriptionFlightStatus GduTest_FlightControlGetValueOfFlightStatus(void);
+static T_GduFcSubscriptionDisplaymode GduTest_FlightControlGetValueOfDisplayMode(void);
+static T_GduFcSubscriptionAvoidData GduTest_FlightControlGetValueOfAvoidData(void);
+static T_GduFcSubscriptionQuaternion GduTest_FlightControlGetValueOfQuaternion(void);
+static T_GduFcSubscriptionPositionFused GduTest_FlightControlGetValueOfPositionFused(void);
+static gdu_f32_t GduTest_FlightControlGetValueOfRelativeHeight(void);
+static bool GduTest_FlightControlMotorStartedCheck(void);
+static bool GduTest_FlightControlTakeOffInAirCheck(void);
+static bool GduTest_FlightControlLandFinishedCheck(void);
+static bool GduTest_FlightControlMonitoredTakeoff(void);
+static bool GduTest_FlightControlCheckActionStarted(E_GduFcSubscriptionDisplayMode mode);
+static bool GduTest_FlightControlMonitoredLanding(void);
+static bool GduTest_FlightControlGoHomeAndConfirmLanding(void);
+static T_GduTestFlightControlVector3f GduTest_FlightControlQuaternionToEulerAngle(T_GduFcSubscriptionQuaternion quat);
+static T_GduTestFlightControlVector3f
+GduTest_FlightControlLocalOffsetFromGpsAndFusedHeightOffset(T_GduFcSubscriptionPositionFused target,
+                                                            T_GduFcSubscriptionPositionFused origin,
+                                                            gdu_f32_t targetHeight,
+                                                            gdu_f32_t originHeight);
+static T_GduTestFlightControlVector3f
+GduTest_FlightControlVector3FSub(T_GduTestFlightControlVector3f vectorA, T_GduTestFlightControlVector3f vectorB);
+static int GduTest_FlightControlSignOfData(gdu_f32_t data);
+static void GduTest_FlightControlHorizCommandLimit(gdu_f32_t speedFactor, gdu_f32_t *commandX, gdu_f32_t *commandY);
+static gdu_f32_t GduTest_FlightControlVectorNorm(T_GduTestFlightControlVector3f v);
+static T_GduReturnCode
+GduTest_FlightControlJoystickCtrlAuthSwitchEventCallback(T_GduFlightControllerJoystickCtrlAuthorityEventInfo eventData);
+static bool
+GduTest_FlightControlMoveByPositionOffset(T_GduTestFlightControlVector3f offsetDesired, float yawDesiredInDeg,
+                                          float posThresholdInM,
+                                          float yawThresholdInDeg);
+static void
+GduTest_FlightControlVelocityAndYawRateCtrl(T_GduTestFlightControlVector3f offsetDesired, float yawRate,
+                                            uint32_t timeMs);
+static T_GduReturnCode GduTest_FlightControlInit(void);
+static T_GduReturnCode GduTest_FlightControlDeInit(void);
+static void GduTest_FlightControlTakeOffLandingSample(void);
+static void GduTest_FlightControlPositionControlSample(void);
+static void GduTest_FlightControlGoHomeForceLandingSample(void);
+static void GduTest_FlightControlVelocityControlSample(void);
+static void GduTest_FlightControlArrestFlyingSample(void);
+static void GduTest_FlightControlSample(E_GduTestFlightCtrlSampleSelect flightCtrlSampleSelect);
+
+/* Exported functions definition ---------------------------------------------*/
+T_GduReturnCode GduTest_FlightControlRunSample(E_GduTestFlightCtrlSampleSelect flightCtrlSampleSelect)
+{
+    T_GduReturnCode returnCode;
+
+    USER_LOG_DEBUG("Init flight Control Sample");
+    GduTest_WidgetLogAppend("Init flight Control Sample");
+
+    returnCode = GduTest_FlightControlInit();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Init flight Control sample failed,error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    GduTest_FlightControlSample(flightCtrlSampleSelect);
+
+    USER_LOG_DEBUG("Deinit Flight Control Sample");
+    GduTest_WidgetLogAppend("Deinit Flight Control Sample");
+    returnCode = GduTest_FlightControlDeInit();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Deinit Flight Control sample failed,error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    return returnCode;
+}
+
+/* Private functions definition-----------------------------------------------*/
+T_GduReturnCode GduTest_FlightControlInit(void)
+{
+    T_GduReturnCode returnCode;
+
+    s_osalHandler = GduPlatform_GetOsalHandler();
+    if (!s_osalHandler) return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+
+    returnCode = GduFlightController_Init();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Init flight controller module failed, error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduFcSubscription_Init();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Init data subscription module failed, error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    /*! subscribe fc data */
+    returnCode = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_STATUS_FLIGHT,
+                                                  GDU_DATA_SUBSCRIPTION_TOPIC_10_HZ,
+                                                  NULL);
+
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic flight status failed, error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_STATUS_DISPLAYMODE,
+                                                  GDU_DATA_SUBSCRIPTION_TOPIC_10_HZ,
+                                                  NULL);
+
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic display mode failed, error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_AVOID_DATA,
+                                                  GDU_DATA_SUBSCRIPTION_TOPIC_10_HZ,
+                                                  NULL);
+
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic avoid data failed,error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_QUATERNION,
+                                                  GDU_DATA_SUBSCRIPTION_TOPIC_10_HZ,
+                                                  NULL);
+
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic quaternion failed,error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_POSITION_FUSED,
+                                                  GDU_DATA_SUBSCRIPTION_TOPIC_10_HZ,
+                                                  NULL);
+
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic position fused failed,error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_ALTITUDE_FUSED,
+                                                  GDU_DATA_SUBSCRIPTION_TOPIC_10_HZ,
+                                                  NULL);
+
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic altitude fused failed,error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_ALTITUDE_OF_HOMEPOINT,
+                                                  GDU_DATA_SUBSCRIPTION_TOPIC_1_HZ,
+                                                  NULL);
+
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Subscribe topic altitude of home point failed,error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduFlightController_RegJoystickCtrlAuthorityEventCallback(
+        GduTest_FlightControlJoystickCtrlAuthSwitchEventCallback);
+
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS && returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_NONSUPPORT) {
+        USER_LOG_ERROR("Register joystick control authority event callback failed,error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+T_GduReturnCode GduTest_FlightControlDeInit(void)
+{
+    T_GduReturnCode returnCode;
+
+    returnCode = GduFlightController_Deinit();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Deinit flight controller module failed, error code:0x%08llX",
+                       returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduFcSubscription_DeInit();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Deinit data subscription module failed, error code:0x%08llX",
+                       returnCode);
+        return returnCode;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+void GduTest_FlightControlTakeOffLandingSample()
+{
+    T_GduReturnCode returnCode;
+
+    USER_LOG_INFO("Flight control takeoff-landing sample start");
+    GduTest_WidgetLogAppend("Flight control takeoff-landing sample start");
+    USER_LOG_INFO("--> Step 1: Obtain joystick control authority.");
+    GduTest_WidgetLogAppend("--> Step 1: Obtain joystick control authority.");
+    returnCode = GduFlightController_ObtainJoystickCtrlAuthority();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Obtain joystick authority failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 2: Take off\r\n");
+    GduTest_WidgetLogAppend("--> Step 2: Take off\r\n");
+    if (!GduTest_FlightControlMonitoredTakeoff()) {
+        USER_LOG_ERROR("Take off failed");
+        goto out;
+    }
+    USER_LOG_INFO("Successful take off\r\n");
+    GduTest_WidgetLogAppend("Successful take off\r\n");
+    s_osalHandler->TaskSleepMs(4000);
+
+    USER_LOG_INFO("--> Step 3: Landing\r\n");
+    GduTest_WidgetLogAppend("--> Step 3: Landing\r\n");
+    if (!GduTest_FlightControlMonitoredLanding()) {
+        USER_LOG_ERROR("Landing failed");
+        goto out;
+    }
+    USER_LOG_INFO("Successful landing\r\n");
+    GduTest_WidgetLogAppend("Successful landing\r\n");
+
+    USER_LOG_INFO("--> Step 4: Release joystick authority");
+    GduTest_WidgetLogAppend("--> Step 4: Release joystick authority");
+    returnCode = GduFlightController_ReleaseJoystickCtrlAuthority();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Release joystick authority failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+out:
+    USER_LOG_INFO("Flight control takeoff-landing sample end");
+    GduTest_WidgetLogAppend("Flight control takeoff-landing sample end");
+}
+
+void GduTest_FlightControlPositionControlSample()
+{
+    T_GduReturnCode returnCode;
+
+    USER_LOG_INFO("Flight control move-by-position sample start");
+    GduTest_WidgetLogAppend("Flight control move-by-position sample start");
+
+    USER_LOG_INFO("--> Step 1: Obtain joystick control authority.");
+    GduTest_WidgetLogAppend("--> Step 1: Obtain joystick control authority.");
+    returnCode = GduFlightController_ObtainJoystickCtrlAuthority();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Obtain joystick authority failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 2: Take off\r\n");
+    GduTest_WidgetLogAppend("--> Step 2: Take off\r\n");
+    if (!GduTest_FlightControlMonitoredTakeoff()) {
+        USER_LOG_ERROR("Take off failed");
+        goto out;
+    }
+    USER_LOG_INFO("Successful take off\r\n");
+    GduTest_WidgetLogAppend("Successful take off\r\n");
+
+    USER_LOG_INFO("--> Step 3: Move to north:0(m), earth:6(m), up:6(m) , yaw:30(degree) from current point");
+    GduTest_WidgetLogAppend("--> Step 3: Move to north:0(m), earth:6(m), up:6(m) , yaw:30(degree) from current point");
+    if (!GduTest_FlightControlMoveByPositionOffset((T_GduTestFlightControlVector3f) {0, 6, 6}, 30, 0.8, 1)) {
+        USER_LOG_ERROR("Move to north:0(m), earth:6(m), up:6(m) , yaw:30(degree) from current point failed");
+        goto out;
+    };
+
+    USER_LOG_INFO("--> Step 4: Move to north:6(m), earth:0(m), up:-3(m) , yaw:-30(degree) from current point");
+    GduTest_WidgetLogAppend(
+        "--> Step 4: Move to north:6(m), earth:0(m), up:-3(m) , yaw:-30(degree) from current point");
+    if (!GduTest_FlightControlMoveByPositionOffset((T_GduTestFlightControlVector3f) {6, 0, -3}, -30, 0.8, 1)) {
+        USER_LOG_ERROR("Move to north:6(m), earth:0(m), up:-3(m) , yaw:-30(degree) from current point failed");
+        goto out;
+    };
+
+    USER_LOG_INFO("--> Step 5: Move to north:-6(m), earth:-6(m), up:0(m) , yaw:0(degree) from current point");
+    GduTest_WidgetLogAppend("--> Step 5: Move to north:-6(m), earth:-6(m), up:0(m) , yaw:0(degree) from current point");
+    if (!GduTest_FlightControlMoveByPositionOffset((T_GduTestFlightControlVector3f) {-6, -6, 0}, 0, 0.8, 1)) {
+        USER_LOG_ERROR("Move to north:-6(m), earth:-6(m), up:0(m) , yaw:0(degree) from current point failed");
+        goto out;
+    }
+
+    USER_LOG_INFO("--> Step 6: Landing\r\n");
+    GduTest_WidgetLogAppend("--> Step 6: Landing\r\n");
+    if (!GduTest_FlightControlMonitoredLanding()) {
+        USER_LOG_ERROR("Landing failed");
+        goto out;
+    }
+    USER_LOG_INFO("Successful landing\r\n");
+    GduTest_WidgetLogAppend("Successful landing\r\n");
+
+    USER_LOG_INFO("--> Step 7: Release joystick authority");
+    GduTest_WidgetLogAppend("--> Step 7: Release joystick authority");
+    returnCode = GduFlightController_ReleaseJoystickCtrlAuthority();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Release joystick authority failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+out:
+    USER_LOG_INFO("Flight control move-by-position sample end");
+    GduTest_WidgetLogAppend("Flight control move-by-position sample end");
+}
+
+void GduTest_FlightControlGoHomeForceLandingSample()
+{
+    T_GduReturnCode returnCode;
+
+    USER_LOG_INFO("Flight control go-home-force-landing sample start");
+    GduTest_WidgetLogAppend("Flight control go-home-force-landing sample start");
+
+	//no need Obtain joystick control authority
+//    USER_LOG_INFO("--> Step 1: Obtain joystick control authority");
+//    GduTest_WidgetLogAppend("--> Step 1: Obtain joystick control authority");
+//    returnCode = GduFlightController_ObtainJoystickCtrlAuthority();
+//    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+//        USER_LOG_ERROR("Obtain joystick authority failed, error code: 0x%08X", returnCode);
+//        goto out;
+//    }
+//    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 2: Take off\r\n");
+    GduTest_WidgetLogAppend("--> Step 2: Take off\r\n");
+    if (!GduTest_FlightControlMonitoredTakeoff()) {
+        USER_LOG_ERROR("Take off failed");
+        goto out;
+    }
+    USER_LOG_INFO("Successful take off\r\n");
+    GduTest_WidgetLogAppend("Successful take off\r\n");
+
+    USER_LOG_INFO("--> Step 3: Move to north:0(m), earth:0(m), up:30(m) , yaw:0(degree) from current point");
+    GduTest_WidgetLogAppend("--> Step 3: Move to north:0(m), earth:0(m), up:30(m) , yaw:0(degree) from current point");
+    if (!GduTest_FlightControlMoveByPositionOffset((T_GduTestFlightControlVector3f) {0, 0, 30}, 0, 0.8, 1)) {
+        USER_LOG_ERROR("Move to north:0(m), earth:0(m), up:30(m) , yaw:0(degree) from current point failed");
+        goto out;
+    }
+
+    USER_LOG_INFO("--> Step 4: Move to north:10(m), earth:0(m), up:0(m) , yaw:0(degree) from current point");
+    GduTest_WidgetLogAppend("--> Step 4: Move to north:10(m), earth:0(m), up:0(m) , yaw:0(degree) from current point");
+    if (!GduTest_FlightControlMoveByPositionOffset((T_GduTestFlightControlVector3f) {10, 0, 0}, 0, 0.8, 1)) {
+        USER_LOG_ERROR("Move to north:10(m), earth:0(m), up:0(m) , yaw:0(degree) from current point failed");
+        goto out;
+    }
+
+    USER_LOG_INFO("--> Step 5: Set aircraft current position as new home location!");
+    GduTest_WidgetLogAppend("--> Step 5: Set aircraft current position as new home location!");
+    returnCode = GduFlightController_SetHomeLocationUsingCurrentAircraftLocation();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Set aircraft current position as new home location failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+    USER_LOG_INFO("--> Step 6: Set go home altitude to 50(m)\r\n");
+    GduTest_WidgetLogAppend("--> Step 6: Set go home altitude to 50(m)\r\n");
+    returnCode = GduFlightController_SetGoHomeAltitude(50);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Set go home altitude to 50(m) failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+    /*! get go home altitude */
+    E_GduFlightControllerGoHomeAltitude goHomeAltitude;
+    returnCode = GduFlightController_GetGoHomeAltitude(&goHomeAltitude);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get go home altitude failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    USER_LOG_INFO("Current go home altitude is %d m\r\n", goHomeAltitude);
+    GduTest_WidgetLogAppend("Current go home altitude is %d m\r\n", goHomeAltitude);
+
+    USER_LOG_INFO("--> Step 7: Move to north:20(m), earth:0(m), up:0(m) , yaw:0(degree) from current point");
+    GduTest_WidgetLogAppend("--> Step 7: Move to north:20(m), earth:0(m), up:0(m) , yaw:0(degree) from current point");
+    if (!GduTest_FlightControlMoveByPositionOffset((T_GduTestFlightControlVector3f) {20, 0, 0}, 0, 0.8, 1)) {
+        USER_LOG_ERROR("Move to north:20(m), earth:0(m), up:0(m) , yaw:0(degree) from current point failed");
+        goto out;
+    }
+
+    USER_LOG_INFO("--> Step 8: Go home and confirm force landing\r\n");
+    GduTest_WidgetLogAppend("--> Step 8: Go home and confirm force landing\r\n");
+    if (!GduTest_FlightControlGoHomeAndConfirmLanding()) {
+        USER_LOG_ERROR("Go home and confirm force landing failed");
+        goto out;
+    }
+    USER_LOG_INFO("Successful go home and confirm force landing\r\n");
+    GduTest_WidgetLogAppend("Successful go home and confirm force landing\r\n");
+
+    USER_LOG_INFO("-> Step 9: Release joystick authority");
+    GduTest_WidgetLogAppend("-> Step 9: Release joystick authority");
+    returnCode = GduFlightController_ReleaseJoystickCtrlAuthority();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Release joystick authority failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+out:
+    USER_LOG_INFO("Flight control go-home-force-landing sample end");
+    GduTest_WidgetLogAppend("Flight control go-home-force-landing sample end");
+}
+
+void GduTest_FlightControlVelocityControlSample()
+{
+    T_GduReturnCode returnCode;
+
+    USER_LOG_INFO("Flight control move-by-velocity sample start");
+    GduTest_WidgetLogAppend("Flight control move-by-velocity sample start");
+
+    USER_LOG_INFO("--> Step 1: Obtain joystick control authority");
+    GduTest_WidgetLogAppend("--> Step 1: Obtain joystick control authority");
+    returnCode = GduFlightController_ObtainJoystickCtrlAuthority();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Obtain joystick authority failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 2: Take off\r\n");
+    GduTest_WidgetLogAppend("--> Step 2: Take off\r\n");
+    if (!GduTest_FlightControlMonitoredTakeoff()) {
+        USER_LOG_ERROR("Take off failed");
+        goto out;
+    }
+    USER_LOG_INFO("Successful take off\r\n");
+    GduTest_WidgetLogAppend("Successful take off\r\n");
+
+    USER_LOG_INFO(
+        "--> Step 3: Move with north:0(m/s), earth:0(m/s), up:5(m/s), yaw:0(deg/s) from current point for 2s!");
+    GduTest_WidgetLogAppend(
+        "--> Step 3: Move with north:0(m/s), earth:0(m/s), up:5(m/s), yaw:0(deg/s) from current point for 2s!");
+    GduTest_FlightControlVelocityAndYawRateCtrl((T_GduTestFlightControlVector3f) {0, 0, 5.0}, 0, 2000);
+
+    USER_LOG_INFO("--> Step 4: Emergency brake for 2s");
+    GduTest_WidgetLogAppend("--> Step 4: Emergency brake for 2s");
+    returnCode = GduFlightController_ExecuteEmergencyBrakeAction();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Emergency brake failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(2000);
+    returnCode = GduFlightController_CancelEmergencyBrakeAction();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Cancel emergency brake action failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+    USER_LOG_INFO(
+        "--> Step 5: Move with north:-1.5(m/s), earth:2(m/s), up:0(m/s), yaw:20(deg/s) from current point for 2s!");
+    GduTest_WidgetLogAppend(
+        "--> Step 5: Move with north:-1.5(m/s), earth:2(m/s), up:0(m/s), yaw:20(deg/s) from current point for 2s!");
+    GduTest_FlightControlVelocityAndYawRateCtrl((T_GduTestFlightControlVector3f) {-1.5, 2, 0}, 20, 2000);
+
+    USER_LOG_INFO("--> Step 6: Emergency brake for 2s");
+    GduTest_WidgetLogAppend("--> Step 6: Emergency brake for 2s");
+    returnCode = GduFlightController_ExecuteEmergencyBrakeAction();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Emergency brake failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(2000);
+    returnCode = GduFlightController_CancelEmergencyBrakeAction();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Cancel emergency brake action failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+    USER_LOG_INFO(
+        "--> Step 7: Move with north:3(m/s), earth:0(m/s), up:0(m/s), yaw:0(deg/s) from current point for 2.5s!");
+    GduTest_WidgetLogAppend(
+        "--> Step 7: Move with north:3(m/s), earth:0(m/s), up:0(m/s), yaw:0(deg/s) from current point for 2.5s!");
+    GduTest_FlightControlVelocityAndYawRateCtrl((T_GduTestFlightControlVector3f) {3, 0, 0}, 0, 2500);
+
+    USER_LOG_INFO("--> Step 8: Emergency brake for 2s");
+    GduTest_WidgetLogAppend("--> Step 8: Emergency brake for 2s");
+    returnCode = GduFlightController_ExecuteEmergencyBrakeAction();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Emergency brake failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(2000);
+    returnCode = GduFlightController_CancelEmergencyBrakeAction();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Cancel emergency brake action failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+    USER_LOG_INFO(
+        "--> Step 9: Move with north:-1.6(m/s), earth:-2(m/s), up:0(m/s), yaw:0(deg/s) from current point for 2.2s!");
+    GduTest_WidgetLogAppend(
+        "--> Step 9: Move with north:-1.6(m/s), earth:-2(m/s), up:0(m/s), yaw:0(deg/s) from current point for 2.2s!");
+    GduTest_FlightControlVelocityAndYawRateCtrl((T_GduTestFlightControlVector3f) {-1.6, -2, 0}, 0, 2200);
+
+    USER_LOG_INFO("--> Step 10: Emergency brake for 2s");
+    GduTest_WidgetLogAppend("--> Step 10: Emergency brake for 2s");
+    returnCode = GduFlightController_ExecuteEmergencyBrakeAction();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Emergency brake failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(2000);
+    returnCode = GduFlightController_CancelEmergencyBrakeAction();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Cancel emergency brake action failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+    USER_LOG_INFO("--> Step 11: Landing\r\n");
+    GduTest_WidgetLogAppend("--> Step 11: Landing\r\n");
+    if (!GduTest_FlightControlMonitoredLanding()) {
+        USER_LOG_ERROR("Landing failed");
+        goto out;
+    }
+    USER_LOG_INFO("Successful landing\r\n");
+    GduTest_WidgetLogAppend("Successful landing\r\n");
+
+    USER_LOG_INFO("--> Step 12: Release joystick authority");
+    GduTest_WidgetLogAppend("--> Step 12: Release joystick authority");
+    returnCode = GduFlightController_ReleaseJoystickCtrlAuthority();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Release joystick authority failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+
+out:
+    USER_LOG_INFO("Flight control move-by-velocity sample end");
+    GduTest_WidgetLogAppend("Flight control move-by-velocity sample end");
+}
+
+void GduTest_FlightControlArrestFlyingSample()
+{
+    T_GduReturnCode returnCode;
+
+    USER_LOG_INFO("Flight control arrest-flying sample start");
+    GduTest_WidgetLogAppend("Flight control arrest-flying sample start");
+
+    USER_LOG_INFO("--> Step 1: Enable arrest-flying");
+    GduTest_WidgetLogAppend("--> Step 1: Enable arrest-flying");
+    returnCode = GduFlightController_ArrestFlying();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Enable arrest-flying failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(2000);
+
+    //you can replace with takeoff to test in air.
+    USER_LOG_INFO("--> Step 2: Turn on motors\r\n");
+    GduTest_WidgetLogAppend("--> Step 2: Turn on motors\r\n");
+    returnCode = GduFlightController_TurnOnMotors();
+    if (returnCode == GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Turn on motors successfully, but arrest-flying failed");
+        s_osalHandler->TaskSleepMs(4000);
+        USER_LOG_INFO("--> Step 3: Turn off motors\r\n");
+        GduTest_WidgetLogAppend("--> Step 3: Turn off motors\r\n");
+        returnCode = GduFlightController_TurnOffMotors();
+        if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("Turn off motors failed, error code: 0x%08X", returnCode);
+        }
+        goto out;
+    }
+
+    USER_LOG_INFO("Turn on motors failed.Arrest-flying successfully\r\n");
+    GduTest_WidgetLogAppend("Turn on motors failed.Arrest-flying successfully\r\n");
+    s_osalHandler->TaskSleepMs(2000);
+
+    USER_LOG_INFO("--> Step 3: Disable arrest-flying");
+    GduTest_WidgetLogAppend("--> Step 3: Disable arrest-flying");
+    returnCode = GduFlightController_CancelArrestFlying();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Disable arrest-flying failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(2000);
+
+    USER_LOG_INFO("--> Step 4: Turn on motors\r\n");
+    GduTest_WidgetLogAppend("--> Step 4: Turn on motors\r\n");
+    returnCode = GduFlightController_TurnOnMotors();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Turn on motors failed and disable arrest-flying failed, error code: 0x%08X", returnCode);
+        goto out;
+    } else {
+        USER_LOG_INFO("Turn on motors successfully and disable arrest-flying successfully\r\n");
+        s_osalHandler->TaskSleepMs(4000);
+        USER_LOG_INFO("--> Step 5: Turn off motors");
+        GduTest_WidgetLogAppend("--> Step 5: Turn off motors");
+        returnCode = GduFlightController_TurnOffMotors();
+        if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("Turn off motors failed, error code: 0x%08X", returnCode);
+        }
+    }
+
+out:
+    USER_LOG_INFO("Flight control arrest-flying sample end");
+    GduTest_WidgetLogAppend("Flight control arrest-flying sample end");
+}
+
+void GduTest_FlightControlSetGetParamSample()
+{
+    T_GduReturnCode returnCode;
+    E_GduFlightControllerObstacleAvoidanceEnableStatus horizontalVisualObstacleAvoidanceStatus;
+    E_GduFlightControllerObstacleAvoidanceEnableStatus horizontalRadarObstacleAvoidanceStatus;
+    E_GduFlightControllerObstacleAvoidanceEnableStatus upwardsVisualObstacleAvoidanceStatus;
+    E_GduFlightControllerObstacleAvoidanceEnableStatus upwardsRadarObstacleAvoidanceStatus;
+    E_GduFlightControllerObstacleAvoidanceEnableStatus downloadsVisualObstacleAvoidanceStatus;
+    E_GduFlightControllerGoHomeAltitude goHomeAltitude;
+    E_GduFlightControllerRtkPositionEnableStatus rtkEnableStatus;
+    E_GduFlightControllerRCLostAction rcLostAction;
+
+    USER_LOG_INFO("Flight control set-get-param sample start");
+    GduTest_WidgetLogAppend("Flight control set-get-param sample start");
+
+    /*! Turn on horizontal vision avoid enable */
+    USER_LOG_INFO("--> Step 1: Turn on horizontal visual obstacle avoidance");
+    GduTest_WidgetLogAppend("--> Step 1: Turn on horizontal visual obstacle avoidance");
+    returnCode = GduFlightController_SetHorizontalVisualObstacleAvoidanceEnableStatus(
+        GDU_FLIGHT_CONTROLLER_ENABLE_OBSTACLE_AVOIDANCE);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Turn on horizontal visual obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    };
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 2: Get horizontal horizontal visual obstacle status\r\n");
+    GduTest_WidgetLogAppend("--> Step 2: Get horizontal horizontal visual obstacle status\r\n");
+    returnCode = GduFlightController_GetHorizontalVisualObstacleAvoidanceEnableStatus(
+        &horizontalVisualObstacleAvoidanceStatus);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get horizontal visual obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    USER_LOG_INFO("Current horizontal visual obstacle avoidance status is %d\r\n",
+                  horizontalVisualObstacleAvoidanceStatus);
+    s_osalHandler->TaskSleepMs(1000);
+
+    /*! Turn on horizontal radar avoid enable */
+    USER_LOG_INFO("--> Step 3: Turn on horizontal radar obstacle avoidance");
+    GduTest_WidgetLogAppend("--> Step 3: Turn on horizontal radar obstacle avoidance");
+    returnCode = GduFlightController_SetHorizontalRadarObstacleAvoidanceEnableStatus(
+        GDU_FLIGHT_CONTROLLER_ENABLE_OBSTACLE_AVOIDANCE);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Turn on horizontal radar obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    };
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 4: Get horizontal radar obstacle avoidance status\r\n");
+    GduTest_WidgetLogAppend("--> Step 4: Get horizontal radar obstacle avoidance status\r\n");
+    returnCode = GduFlightController_GetHorizontalRadarObstacleAvoidanceEnableStatus(
+        &horizontalRadarObstacleAvoidanceStatus);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get horizontal radar obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    USER_LOG_INFO("Current horizontal radar obstacle avoidance status is %d\r\n",
+                  horizontalRadarObstacleAvoidanceStatus);
+    s_osalHandler->TaskSleepMs(1000);
+
+    /*! Turn on upwards vision avoid enable */
+    USER_LOG_INFO("--> Step 5: Turn on upwards visual obstacle avoidance.");
+    GduTest_WidgetLogAppend("--> Step 5: Turn on upwards visual obstacle avoidance.");
+    returnCode = GduFlightController_SetUpwardsVisualObstacleAvoidanceEnableStatus(
+        GDU_FLIGHT_CONTROLLER_ENABLE_OBSTACLE_AVOIDANCE);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Turn on upwards visual obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    };
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 6: Get upwards visual obstacle avoidance status\r\n");
+    GduTest_WidgetLogAppend("--> Step 6: Get upwards visual obstacle avoidance status\r\n");
+    returnCode = GduFlightController_GetUpwardsVisualObstacleAvoidanceEnableStatus(
+        &upwardsVisualObstacleAvoidanceStatus);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get upwards visual obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    USER_LOG_INFO("Current upwards visual obstacle avoidance status is %d\r\n", upwardsVisualObstacleAvoidanceStatus);
+    s_osalHandler->TaskSleepMs(1000);
+
+    /*! Turn on upwards radar avoid enable */
+    USER_LOG_INFO("--> Step 7: Turn on upwards radar obstacle avoidance.");
+    GduTest_WidgetLogAppend("--> Step 7: Turn on upwards radar obstacle avoidance.");
+    returnCode = GduFlightController_SetUpwardsRadarObstacleAvoidanceEnableStatus(
+        GDU_FLIGHT_CONTROLLER_ENABLE_OBSTACLE_AVOIDANCE);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Turn on upwards radar obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 8: Get upwards radar obstacle avoidance status\r\n");
+    GduTest_WidgetLogAppend("--> Step 8: Get upwards radar obstacle avoidance status\r\n");
+    returnCode = GduFlightController_GetUpwardsRadarObstacleAvoidanceEnableStatus(&upwardsRadarObstacleAvoidanceStatus);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get upwards radar obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    USER_LOG_INFO("Current upwards radar obstacle avoidance status is %d\r\n", upwardsRadarObstacleAvoidanceStatus);
+    s_osalHandler->TaskSleepMs(1000);
+
+    /*! Turn on downwards vision avoid enable */
+    USER_LOG_INFO("--> Step 9: Turn on downwards visual obstacle avoidance.");
+    GduTest_WidgetLogAppend("--> Step 9: Turn on downwards visual obstacle avoidance.");
+    returnCode = GduFlightController_SetDownwardsVisualObstacleAvoidanceEnableStatus(
+        GDU_FLIGHT_CONTROLLER_ENABLE_OBSTACLE_AVOIDANCE);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Turn on downwards visual obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 10: Get downwards visual obstacle avoidance status\r\n");
+    GduTest_WidgetLogAppend("--> Step 10: Get downwards visual obstacle avoidance status\r\n");
+    returnCode = GduFlightController_GetDownwardsVisualObstacleAvoidanceEnableStatus(
+        &downloadsVisualObstacleAvoidanceStatus);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get downwards visual obstacle avoidance failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    USER_LOG_INFO("Current downwards visual obstacle avoidance status is %d\r\n",
+                  downloadsVisualObstacleAvoidanceStatus);
+    s_osalHandler->TaskSleepMs(1000);
+
+    /*! Set new go home altitude */
+    USER_LOG_INFO("--> Step 11: Set go home altitude to 50(m)");
+    GduTest_WidgetLogAppend("--> Step 11: Set go home altitude to 50(m)");
+    returnCode = GduFlightController_SetGoHomeAltitude(50);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Set go home altitude to 50(m) failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(1000);
+
+    /*! get go home altitude */
+    USER_LOG_INFO("--> Step 12: Get go home altitude\r\n");
+    GduTest_WidgetLogAppend("--> Step 12: Get go home altitude\r\n");
+    returnCode = GduFlightController_GetGoHomeAltitude(&goHomeAltitude);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get go home altitude failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    USER_LOG_INFO("Current go home altitude is %d m\r\n", goHomeAltitude);
+    s_osalHandler->TaskSleepMs(2000);
+
+    /*! Set rtk enable */
+    USER_LOG_INFO("--> Step 13: Set rtk enable status");
+    GduTest_WidgetLogAppend("--> Step 13: Set rtk enable status");
+    returnCode = GduFlightController_SetRtkPositionEnableStatus(GDU_FLIGHT_CONTROLLER_ENABLE_RTK_POSITION);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Set rtk enable failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 14: Get rtk enable status\r\n");
+    GduTest_WidgetLogAppend("--> Step 14: Get rtk enable status\r\n");
+    returnCode = GduFlightController_GetRtkPositionEnableStatus(&rtkEnableStatus);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get rtk enable failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    USER_LOG_INFO("Current rtk enable status is %d\r\n", rtkEnableStatus);
+    s_osalHandler->TaskSleepMs(1000);
+
+    /*! Set rc lost action */
+    USER_LOG_INFO("--> Step 15: Set rc lost action");
+    GduTest_WidgetLogAppend("--> Step 15: Set rc lost action");
+    returnCode = GduFlightController_SetRCLostAction(GDU_FLIGHT_CONTROLLER_RC_LOST_ACTION_GOHOME);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Set rc lost action failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    s_osalHandler->TaskSleepMs(1000);
+
+    USER_LOG_INFO("--> Step 16: Get rc lost action\r\n");
+    GduTest_WidgetLogAppend("--> Step 16: Get rc lost action\r\n");
+    returnCode = GduFlightController_GetRCLostAction(&rcLostAction);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get rc lost action failed, error code: 0x%08X", returnCode);
+        goto out;
+    }
+    USER_LOG_INFO("Current rc lost action is %d\r\n", rcLostAction);
+    GduTest_WidgetLogAppend("Current rc lost action is %d\r\n", rcLostAction);
+    s_osalHandler->TaskSleepMs(1000);
+
+out:
+    USER_LOG_INFO("Flight control set-get-param sample end");
+    GduTest_WidgetLogAppend("Flight control set-get-param sample end");
+}
+
+void GduTest_FlightControlSample(E_GduTestFlightCtrlSampleSelect flightCtrlSampleSelect)
+{
+    switch (flightCtrlSampleSelect) {
+        case E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_TAKE_OFF_LANDING: {
+            GduTest_FlightControlTakeOffLandingSample();
+            break;
+        }
+        case E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_TAKE_OFF_POSITION_CTRL_LANDING: {
+            GduTest_FlightControlPositionControlSample();
+            break;
+        }
+        case E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_TAKE_OFF_GO_HOME_FORCE_LANDING: {
+            GduTest_FlightControlGoHomeForceLandingSample();
+            break;
+        }
+        case E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_TAKE_OFF_VELOCITY_CTRL_LANDING: {
+            GduTest_FlightControlVelocityControlSample();
+            break;
+        }
+        case E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_ARREST_FLYING: {
+            GduTest_FlightControlArrestFlyingSample();
+            break;
+        }
+        case E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_SET_GET_PARAM: {
+            GduTest_FlightControlSetGetParamSample();
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+uint8_t GduTest_FlightControlGetDisplayModeIndex(E_GduFcSubscriptionDisplayMode displayMode)
+{
+    uint8_t i;
+
+    for (i = 0; i < sizeof(s_flightControlDisplayModeStr) / sizeof(T_GduTestFlightControlDisplayModeStr); i++) {
+        if (s_flightControlDisplayModeStr[i].displayMode == displayMode) {
+            return i;
+        }
+    }
+
+    return i;
+}
+
+T_GduFcSubscriptionFlightStatus GduTest_FlightControlGetValueOfFlightStatus(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduFcSubscriptionFlightStatus flightStatus;
+    T_GduDataTimestamp flightStatusTimestamp = {0};
+
+    gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_STATUS_FLIGHT,
+                                                      (uint8_t *) &flightStatus,
+                                                      sizeof(T_GduFcSubscriptionFlightStatus),
+                                                      &flightStatusTimestamp);
+
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get value of topic flight status error, error code: 0x%08X", gduStat);
+        flightStatus = 0;
+    } else {
+        USER_LOG_DEBUG("Timestamp: millisecond %u microsecond %u.", flightStatusTimestamp.millisecond,
+                       flightStatusTimestamp.microsecond);
+        USER_LOG_DEBUG("Flight status: %d.", flightStatus);
+    }
+
+    return flightStatus;
+}
+
+T_GduFcSubscriptionDisplaymode GduTest_FlightControlGetValueOfDisplayMode(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduFcSubscriptionDisplaymode displayMode;
+    T_GduDataTimestamp displayModeTimestamp = {0};
+
+    gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_STATUS_DISPLAYMODE,
+                                                      (uint8_t *) &displayMode,
+                                                      sizeof(T_GduFcSubscriptionDisplaymode),
+                                                      &displayModeTimestamp);
+
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get value of topic display mode error, error code: 0x%08X", gduStat);
+        displayMode = 0;
+    } else {
+        USER_LOG_DEBUG("Timestamp: millisecond %u microsecond %u.", displayModeTimestamp.millisecond,
+                       displayModeTimestamp.microsecond);
+        USER_LOG_DEBUG("Display mode : %d.", displayMode);
+    }
+
+    return displayMode;
+}
+
+T_GduFcSubscriptionAvoidData GduTest_FlightControlGetValueOfAvoidData(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduFcSubscriptionAvoidData avoidData = {0};
+    T_GduDataTimestamp avoidDataTimestamp = {0};
+
+    gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_AVOID_DATA,
+                                                      (uint8_t *) &avoidData,
+                                                      sizeof(T_GduFcSubscriptionAvoidData),
+                                                      &avoidDataTimestamp);
+
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get value of topic avoid data error, error code: 0x%08X", gduStat);
+    } else {
+        USER_LOG_DEBUG("Timestamp: millisecond %u microsecond %u.", avoidDataTimestamp.millisecond,
+                       avoidDataTimestamp.microsecond);
+        USER_LOG_DEBUG("Avoid downwards distance is %f m", avoidData.down);
+    }
+
+    return avoidData;
+}
+
+T_GduFcSubscriptionQuaternion GduTest_FlightControlGetValueOfQuaternion(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduFcSubscriptionQuaternion quaternion = {0};
+    T_GduDataTimestamp quaternionTimestamp = {0};
+
+    gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_QUATERNION,
+                                                      (uint8_t *) &quaternion,
+                                                      sizeof(T_GduFcSubscriptionQuaternion),
+                                                      &quaternionTimestamp);
+
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get value of topic quaternion error, error code: 0x%08X", gduStat);
+    } else {
+        USER_LOG_DEBUG("Timestamp: millisecond %u microsecond %u.", quaternionTimestamp.millisecond,
+                       quaternionTimestamp.microsecond);
+        USER_LOG_DEBUG("Quaternion: %f %f %f %f.", quaternion.q0, quaternion.q1, quaternion.q2, quaternion.q3);
+    }
+
+    return quaternion;
+}
+
+T_GduFcSubscriptionPositionFused GduTest_FlightControlGetValueOfPositionFused(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduFcSubscriptionPositionFused positionFused = {0};
+    T_GduDataTimestamp positionFusedTimestamp = {0};
+
+    gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_POSITION_FUSED,
+                                                      (uint8_t *) &positionFused,
+                                                      sizeof(T_GduFcSubscriptionPositionFused),
+                                                      &positionFusedTimestamp);
+
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get value of topic position fused error, error code: 0x%08X", gduStat);
+    } else {
+        USER_LOG_DEBUG("Timestamp: millisecond %u microsecond %u.", positionFusedTimestamp.millisecond,
+                       positionFusedTimestamp.microsecond);
+        USER_LOG_DEBUG("PositionFused: %f, %f,%f,%d.", positionFused.latitude, positionFused.longitude,
+                       positionFused.altitude, positionFused.visibleSatelliteNumber);
+    }
+
+    return positionFused;
+}
+
+gdu_f32_t GduTest_FlightControlGetValueOfRelativeHeight(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduFcSubscriptionAltitudeFused altitudeFused = 0;
+    T_GduFcSubscriptionAltitudeOfHomePoint homePointAltitude = 0;
+    gdu_f32_t relativeHeight = 0;
+    T_GduDataTimestamp relativeHeightTimestamp = {0};
+
+    gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_ALTITUDE_OF_HOMEPOINT,
+                                                      (uint8_t *) &homePointAltitude,
+                                                      sizeof(T_GduFcSubscriptionAltitudeOfHomePoint),
+                                                      &relativeHeightTimestamp);
+
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get value of topic altitude of home point error, error code: 0x%08X", gduStat);
+        return -1;
+    } else {
+        USER_LOG_DEBUG("Timestamp: millisecond %u microsecond %u.", relativeHeightTimestamp.millisecond,
+                       relativeHeightTimestamp.microsecond);
+    }
+
+    gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_ALTITUDE_FUSED,
+                                                      (uint8_t *) &altitudeFused,
+                                                      sizeof(T_GduFcSubscriptionAltitudeFused),
+                                                      &relativeHeightTimestamp);
+
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get value of topic altitude fused error, error code: 0x%08X", gduStat);
+        return -1;
+    } else {
+        USER_LOG_DEBUG("Timestamp: millisecond %u microsecond %u.", relativeHeightTimestamp.millisecond,
+                       relativeHeightTimestamp.microsecond);
+    }
+
+    relativeHeight = altitudeFused - homePointAltitude;
+
+    return relativeHeight;
+}
+
+bool GduTest_FlightControlMotorStartedCheck(void)
+{
+    int motorsNotStarted = 0;
+    int timeoutCycles = 20;
+
+    while (GduTest_FlightControlGetValueOfFlightStatus() != GDU_FC_SUBSCRIPTION_FLIGHT_STATUS_ON_GROUND &&
+           GduTest_FlightControlGetValueOfDisplayMode() != GDU_FC_SUBSCRIPTION_DISPLAY_MODE_ENGINE_START &&
+           motorsNotStarted < timeoutCycles) {
+        motorsNotStarted++;
+        s_osalHandler->TaskSleepMs(100);
+    }
+    return motorsNotStarted != timeoutCycles ? true : false;
+}
+
+bool GduTest_FlightControlTakeOffInAirCheck(void)
+{
+    int stillOnGround = 0;
+    int timeoutCycles = 110;
+
+    while (GduTest_FlightControlGetValueOfFlightStatus() != GDU_FC_SUBSCRIPTION_FLIGHT_STATUS_IN_AIR &&
+           (GduTest_FlightControlGetValueOfDisplayMode() != GDU_FC_SUBSCRIPTION_DISPLAY_MODE_ASSISTED_TAKEOFF ||
+            GduTest_FlightControlGetValueOfDisplayMode() != GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_TAKEOFF) &&
+           stillOnGround < timeoutCycles) {
+        stillOnGround++;
+        s_osalHandler->TaskSleepMs(100);
+    }
+
+    return stillOnGround != timeoutCycles ? true : false;
+}
+
+bool takeoffFinishedCheck(void)
+{
+    while (GduTest_FlightControlGetValueOfDisplayMode() == GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_TAKEOFF ||
+           GduTest_FlightControlGetValueOfDisplayMode() == GDU_FC_SUBSCRIPTION_DISPLAY_MODE_ASSISTED_TAKEOFF) {
+        s_osalHandler->TaskSleepMs(1000);
+    }
+
+    return (GduTest_FlightControlGetValueOfDisplayMode() == GDU_FC_SUBSCRIPTION_DISPLAY_MODE_P_GPS ||
+            GduTest_FlightControlGetValueOfDisplayMode() == GDU_FC_SUBSCRIPTION_DISPLAY_MODE_ATTITUDE) ? true : false;
+}
+
+bool GduTest_FlightControlLandFinishedCheck(void)
+{
+    while (GduTest_FlightControlGetValueOfDisplayMode() == GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_LANDING ||
+           GduTest_FlightControlGetValueOfFlightStatus() == GDU_FC_SUBSCRIPTION_FLIGHT_STATUS_IN_AIR) {
+        s_osalHandler->TaskSleepMs(1000);
+    }
+
+    return (GduTest_FlightControlGetValueOfDisplayMode() != GDU_FC_SUBSCRIPTION_DISPLAY_MODE_P_GPS ||
+            GduTest_FlightControlGetValueOfDisplayMode() != GDU_FC_SUBSCRIPTION_DISPLAY_MODE_ATTITUDE) ? true : false;
+}
+
+bool GduTest_FlightControlCheckActionStarted(E_GduFcSubscriptionDisplayMode mode)
+{
+    int actionNotStarted = 0;
+    int timeoutCycles = 20;
+
+    while (GduTest_FlightControlGetValueOfDisplayMode() != mode && actionNotStarted < timeoutCycles) {
+        actionNotStarted++;
+        s_osalHandler->TaskSleepMs(100);
+    }
+
+    if (actionNotStarted == timeoutCycles) {
+        USER_LOG_ERROR("%s start failed, now flight is in %s.",
+                       s_flightControlDisplayModeStr[GduTest_FlightControlGetDisplayModeIndex(mode)].displayModeStr,
+                       s_flightControlDisplayModeStr[GduTest_FlightControlGetDisplayModeIndex(
+                           GduTest_FlightControlGetValueOfDisplayMode())].displayModeStr);
+        return false;
+    } else {
+        USER_LOG_INFO("Now flight is in %s.",
+                      s_flightControlDisplayModeStr[GduTest_FlightControlGetDisplayModeIndex(mode)].displayModeStr);
+        return true;
+    }
+}
+
+bool GduTest_FlightControlMonitoredTakeoff(void)
+{
+    T_GduReturnCode gduStat;
+
+    //! Start takeoff
+    gduStat = GduFlightController_StartTakeoff();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Request to take off failed, error code: 0x%08X", gduStat);
+        return false;
+    }
+
+    //! Motors start check
+    if (!GduTest_FlightControlMotorStartedCheck()) {
+        USER_LOG_ERROR("Takeoff failed. Motors are not spinning.");
+        return false;
+    } else {
+        USER_LOG_INFO("Motors spinning...");
+    }
+    //! In air check
+    if (!GduTest_FlightControlTakeOffInAirCheck()) {
+        USER_LOG_ERROR("Takeoff failed. Aircraft is still on the ground, but the "
+                       "motors are spinning");
+        return false;
+    } else {
+        USER_LOG_INFO("Ascending...");
+    }
+    //! Finished takeoff check
+    if (!takeoffFinishedCheck()) {
+        USER_LOG_ERROR("Takeoff finished, but the aircraft is in an unexpected mode. "
+                       "Please connect GDU GO.");
+        return false;
+    }
+
+    return true;
+}
+
+bool GduTest_FlightControlMonitoredLanding(void)
+{
+    T_GduReturnCode gduStat;
+    /*! Step 1: Start landing */
+    gduStat = GduFlightController_StartLanding();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Start landing failed, error code: 0x%08X", gduStat);
+        return false;
+    }
+
+    /*! Step 2: check Landing start*/
+    if (!GduTest_FlightControlCheckActionStarted(GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_LANDING)) {
+        USER_LOG_ERROR("Fail to execute Landing action!");
+        return false;
+    } else {
+        /*! Step 3: check Landing finished*/
+        if (!GduTest_FlightControlLandFinishedCheck()) {
+            USER_LOG_ERROR("Landing finished, but the aircraft is in an unexpected mode. "
+                           "Please connect GDU Assistant.");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool GduTest_FlightControlGoHomeAndConfirmLanding(void)
+{
+    T_GduReturnCode gduStat;
+
+    /*! Step 1: Start go home */
+    USER_LOG_INFO("Start go home action");
+    gduStat = GduFlightController_StartGoHome();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Start to go home failed, error code: 0x%08X", gduStat);
+        return false;;
+    }
+
+    if (!GduTest_FlightControlCheckActionStarted(GDU_FC_SUBSCRIPTION_DISPLAY_MODE_NAVI_GO_HOME)) {
+        return false;
+    } else {
+        while (GduTest_FlightControlGetValueOfFlightStatus() == GDU_FC_SUBSCRIPTION_FLIGHT_STATUS_IN_AIR &&
+               GduTest_FlightControlGetValueOfDisplayMode() == GDU_FC_SUBSCRIPTION_DISPLAY_MODE_NAVI_GO_HOME) {
+            s_osalHandler->TaskSleepMs(1000);// waiting for this action finished
+        }
+    }
+
+    /*! Step 2: Start landing */
+    USER_LOG_INFO("Start landing action");
+    if (!GduTest_FlightControlCheckActionStarted(GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_LANDING)) {
+        USER_LOG_ERROR("Fail to execute Landing action");
+        return false;
+    } else {
+        while (GduTest_FlightControlGetValueOfDisplayMode() == GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_LANDING &&
+               GduTest_FlightControlGetValueOfFlightStatus() == GDU_FC_SUBSCRIPTION_FLIGHT_STATUS_IN_AIR) {
+            T_GduFcSubscriptionAvoidData avoidData = GduTest_FlightControlGetValueOfAvoidData();
+            s_osalHandler->TaskSleepMs(1000);
+            if (((gdu_f64_t) 0.65 < avoidData.down && avoidData.down < (gdu_f64_t) 0.75) &&
+                avoidData.downHealth == 1) {
+                break;
+            }
+        }
+    }
+
+    /*! Step 4: Confirm Landing */
+    USER_LOG_INFO("Start confirm Landing and avoid ground action");
+    gduStat = GduFlightController_StartConfirmLanding();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Fail to execute confirm landing avoid ground action, error code: 0x%08X", gduStat);
+        return false;
+    }
+
+    if (!GduTest_FlightControlCheckActionStarted(GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_LANDING)) {
+        return false;
+    } else {
+        while (GduTest_FlightControlGetValueOfFlightStatus() == GDU_FC_SUBSCRIPTION_FLIGHT_STATUS_IN_AIR &&
+               GduTest_FlightControlGetValueOfDisplayMode() == GDU_FC_SUBSCRIPTION_DISPLAY_MODE_AUTO_LANDING) {
+            s_osalHandler->TaskSleepMs(1000);
+        }
+    }
+
+    /*! Step 5: Landing finished check*/
+    if (GduTest_FlightControlGetValueOfDisplayMode() != GDU_FC_SUBSCRIPTION_DISPLAY_MODE_P_GPS ||
+        GduTest_FlightControlGetValueOfDisplayMode() != GDU_FC_SUBSCRIPTION_DISPLAY_MODE_ATTITUDE) {
+        USER_LOG_INFO("Successful landing");
+    } else {
+        USER_LOG_ERROR("Landing finished, but the aircraft is in an unexpected mode. "
+                       "Please connect GDU Assistant.");
+        return false;
+    }
+
+    return true;
+}
+
+T_GduTestFlightControlVector3f GduTest_FlightControlQuaternionToEulerAngle(const T_GduFcSubscriptionQuaternion quat)
+{
+    T_GduTestFlightControlVector3f eulerAngle;
+    double q2sqr = quat.q2 * quat.q2;
+    double t0 = -2.0 * (q2sqr + quat.q3 * quat.q3) + 1.0;
+    double t1 = (gdu_f64_t) 2.0 * (quat.q1 * quat.q2 + quat.q0 * quat.q3);
+    double t2 = -2.0 * (quat.q1 * quat.q3 - quat.q0 * quat.q2);
+    double t3 = (gdu_f64_t) 2.0 * (quat.q2 * quat.q3 + quat.q0 * quat.q1);
+    double t4 = -2.0 * (quat.q1 * quat.q1 + q2sqr) + 1.0;
+    t2 = (t2 > 1.0) ? 1.0 : t2;
+    t2 = (t2 < -1.0) ? -1.0 : t2;
+    eulerAngle.x = asin(t2);
+    eulerAngle.y = atan2(t3, t4);
+    eulerAngle.z = atan2(t1, t0);
+    return eulerAngle;
+}
+
+T_GduTestFlightControlVector3f
+GduTest_FlightControlLocalOffsetFromGpsAndFusedHeightOffset(const T_GduFcSubscriptionPositionFused target,
+                                                            const T_GduFcSubscriptionPositionFused origin,
+                                                            const gdu_f32_t targetHeight,
+                                                            const gdu_f32_t originHeight)
+{
+    T_GduTestFlightControlVector3f deltaNed;
+    double deltaLon = target.longitude - origin.longitude;
+    double deltaLat = target.latitude - origin.latitude;
+    deltaNed.x = deltaLat * s_earthCenter;
+    deltaNed.y = deltaLon * s_earthCenter * cos(target.latitude);
+    deltaNed.z = targetHeight - originHeight;
+
+    return deltaNed;
+}
+
+T_GduTestFlightControlVector3f
+GduTest_FlightControlVector3FSub(const T_GduTestFlightControlVector3f vectorA,
+                                 const T_GduTestFlightControlVector3f vectorB)
+{
+    T_GduTestFlightControlVector3f result;
+    result.x = vectorA.x - vectorB.x;
+    result.y = vectorA.y - vectorB.y;
+    result.z = vectorA.z - vectorB.z;
+    return result;
+}
+
+int GduTest_FlightControlSignOfData(gdu_f32_t data)
+{
+    return data < 0 ? -1 : 1;
+}
+
+void GduTest_FlightControlHorizCommandLimit(gdu_f32_t speedFactor, gdu_f32_t *commandX, gdu_f32_t *commandY)
+{
+    if (fabs(*commandX) > speedFactor)
+        *commandX = speedFactor * GduTest_FlightControlSignOfData(*commandX);
+    if (fabs(*commandY) > speedFactor)
+        *commandY = speedFactor * GduTest_FlightControlSignOfData(*commandY);
+}
+
+gdu_f32_t GduTest_FlightControlVectorNorm(T_GduTestFlightControlVector3f v)
+{
+    return sqrt(pow(v.x, 2) + pow(v.y, 2) + pow(v.z, 2));
+}
+
+bool
+GduTest_FlightControlMoveByPositionOffset(const T_GduTestFlightControlVector3f offsetDesired, float yawDesiredInDeg,
+                                          float posThresholdInM, float yawThresholdInDeg)
+{
+    int timeoutInMilSec = 20000;
+    int controlFreqInHz = 50;  // Hz
+    int cycleTimeInMs = 1000 / controlFreqInHz;
+    int outOfControlBoundsTimeLimit = 10 * cycleTimeInMs;    // 10 cycles
+    int withinControlBoundsTimeReqmt = 100 * cycleTimeInMs;  // 100 cycles
+    int elapsedTimeInMs = 0;
+    int withinBoundsCounter = 0;
+    int outOfBounds = 0;
+    int brakeCounter = 0;
+    int speedFactor = 2;
+
+    //! get origin position and relative height(from home point)of aircraft.
+    T_GduFcSubscriptionPositionFused originGPSPosition = GduTest_FlightControlGetValueOfPositionFused();
+    gdu_f32_t originHeightBaseHomePoint = GduTest_FlightControlGetValueOfRelativeHeight();
+    if (originHeightBaseHomePoint == -1) {
+        USER_LOG_ERROR("Relative height is invalid!");
+        return false;
+    }
+
+    T_GduFlightControllerJoystickMode joystickMode = {
+        GDU_FLIGHT_CONTROLLER_HORIZONTAL_POSITION_CONTROL_MODE,
+        GDU_FLIGHT_CONTROLLER_VERTICAL_POSITION_CONTROL_MODE,
+        GDU_FLIGHT_CONTROLLER_YAW_ANGLE_CONTROL_MODE,
+        GDU_FLIGHT_CONTROLLER_HORIZONTAL_GROUND_COORDINATE,
+        GDU_FLIGHT_CONTROLLER_STABLE_CONTROL_MODE_ENABLE,
+    };
+    GduFlightController_SetJoystickMode(joystickMode);
+
+    while (elapsedTimeInMs < timeoutInMilSec) {
+        T_GduFcSubscriptionPositionFused currentGPSPosition = GduTest_FlightControlGetValueOfPositionFused();
+        T_GduFcSubscriptionQuaternion currentQuaternion = GduTest_FlightControlGetValueOfQuaternion();
+        gdu_f32_t currentHeight = GduTest_FlightControlGetValueOfRelativeHeight();
+        if (originHeightBaseHomePoint == -1) {
+            USER_LOG_ERROR("Relative height is invalid!");
+            return false;
+        }
+
+        float yawInRad = GduTest_FlightControlQuaternionToEulerAngle(currentQuaternion).z;
+        //! get the vector between aircraft and origin point.
+
+        T_GduTestFlightControlVector3f localOffset = GduTest_FlightControlLocalOffsetFromGpsAndFusedHeightOffset(
+            currentGPSPosition,
+            originGPSPosition,
+            currentHeight,
+            originHeightBaseHomePoint);
+        //! get the vector between aircraft and target point.
+        T_GduTestFlightControlVector3f offsetRemaining = GduTest_FlightControlVector3FSub(offsetDesired, localOffset);
+
+        T_GduTestFlightControlVector3f positionCommand = offsetRemaining;
+        GduTest_FlightControlHorizCommandLimit(speedFactor, &positionCommand.x, &positionCommand.y);
+
+        T_GduFlightControllerJoystickCommand joystickCommand = {positionCommand.x, positionCommand.y,
+                                                                offsetDesired.z + originHeightBaseHomePoint,
+                                                                yawDesiredInDeg};
+        GduFlightController_ExecuteJoystickAction(joystickCommand);
+
+        if (GduTest_FlightControlVectorNorm(offsetRemaining) < posThresholdInM &&
+            fabs(yawInRad / s_degToRad - yawDesiredInDeg) < yawThresholdInDeg) {
+            //! 1. We are within bounds; start incrementing our in-bound counter
+            withinBoundsCounter += cycleTimeInMs;
+        } else {
+            if (withinBoundsCounter != 0) {
+                //! 2. Start incrementing an out-of-bounds counter
+                outOfBounds += cycleTimeInMs;
+            }
+        }
+        //! 3. Reset withinBoundsCounter if necessary
+        if (outOfBounds > outOfControlBoundsTimeLimit) {
+            withinBoundsCounter = 0;
+            outOfBounds = 0;
+        }
+        //! 4. If within bounds, set flag and break
+        if (withinBoundsCounter >= withinControlBoundsTimeReqmt) {
+            break;
+        }
+        s_osalHandler->TaskSleepMs(cycleTimeInMs);
+        elapsedTimeInMs += cycleTimeInMs;
+    }
+
+    while (brakeCounter < withinControlBoundsTimeReqmt) {
+        s_osalHandler->TaskSleepMs(cycleTimeInMs);
+        brakeCounter += cycleTimeInMs;
+    }
+
+    if (elapsedTimeInMs >= timeoutInMilSec) {
+        USER_LOG_ERROR("Task timeout!");
+        return false;
+    }
+
+    return true;
+}
+
+void GduTest_FlightControlVelocityAndYawRateCtrl(const T_GduTestFlightControlVector3f offsetDesired, float yawRate,
+                                                 uint32_t timeMs)
+{
+    uint32_t originTime = 0;
+    uint32_t currentTime = 0;
+    uint32_t elapsedTimeInMs = 0;
+    s_osalHandler->GetTimeMs(&originTime);
+    s_osalHandler->GetTimeMs(&currentTime);
+    elapsedTimeInMs = currentTime - originTime;
+    T_GduFlightControllerJoystickMode joystickMode = {
+        GDU_FLIGHT_CONTROLLER_HORIZONTAL_VELOCITY_CONTROL_MODE,
+        GDU_FLIGHT_CONTROLLER_VERTICAL_VELOCITY_CONTROL_MODE,
+        GDU_FLIGHT_CONTROLLER_YAW_ANGLE_RATE_CONTROL_MODE,
+        GDU_FLIGHT_CONTROLLER_HORIZONTAL_GROUND_COORDINATE,
+        GDU_FLIGHT_CONTROLLER_STABLE_CONTROL_MODE_ENABLE,
+    };
+
+    GduFlightController_SetJoystickMode(joystickMode);
+    T_GduFlightControllerJoystickCommand joystickCommand = {offsetDesired.x, offsetDesired.y, offsetDesired.z,
+                                                            yawRate};
+
+    while (elapsedTimeInMs <= timeMs) {
+        GduFlightController_ExecuteJoystickAction(joystickCommand);
+        s_osalHandler->TaskSleepMs(2);
+        s_osalHandler->GetTimeMs(&currentTime);
+        elapsedTimeInMs = currentTime - originTime;
+    }
+}
+
+T_GduReturnCode
+GduTest_FlightControlJoystickCtrlAuthSwitchEventCallback(T_GduFlightControllerJoystickCtrlAuthorityEventInfo eventData)
+{
+    switch (eventData.joystickCtrlAuthoritySwitchEvent) {
+        case GDU_FLIGHT_CONTROLLER_MSDK_GET_JOYSTICK_CTRL_AUTH_EVENT: {
+            if (eventData.curJoystickCtrlAuthority == GDU_FLIGHT_CONTROLLER_JOYSTICK_CTRL_AUTHORITY_MSDK) {
+                USER_LOG_INFO("[Event]Msdk request to obtain joystick ctrl authority\r\n");
+            } else {
+                USER_LOG_INFO("[Event]Msdk request to release joystick ctrl authority\r\n");
+            }
+            break;
+        }
+        case GDU_FLIGHT_CONTROLLER_INTERNAL_GET_JOYSTICK_CTRL_AUTH_EVENT: {
+            if (eventData.curJoystickCtrlAuthority == GDU_FLIGHT_CONTROLLER_JOYSTICK_CTRL_AUTHORITY_INTERNAL) {
+                USER_LOG_INFO("[Event]Internal request to obtain joystick ctrl authority\r\n");
+            } else {
+                USER_LOG_INFO("[Event]Internal request to release joystick ctrl authority\r\n");
+            }
+            break;
+        }
+        case GDU_FLIGHT_CONTROLLER_OSDK_GET_JOYSTICK_CTRL_AUTH_EVENT: {
+            if (eventData.curJoystickCtrlAuthority == GDU_FLIGHT_CONTROLLER_JOYSTICK_CTRL_AUTHORITY_OSDK) {
+                USER_LOG_INFO("[Event]Osdk request to obtain joystick ctrl authority\r\n");
+            } else {
+                USER_LOG_INFO("[Event]Osdk request to release joystick ctrl authority\r\n");
+            }
+            break;
+        }
+        case GDU_FLIGHT_CONTROLLER_RC_LOST_GET_JOYSTICK_CTRL_AUTH_EVENT :
+            USER_LOG_INFO("[Event]Current joystick ctrl authority is reset to rc due to rc lost\r\n");
+            break;
+        case GDU_FLIGHT_CONTROLLER_RC_NOT_P_MODE_RESET_JOYSTICK_CTRL_AUTH_EVENT :
+            USER_LOG_INFO("[Event]Current joystick ctrl authority is reset to rc for rc is not in P mode\r\n");
+            break;
+        case GDU_FLIGHT_CONTROLLER_RC_SWITCH_MODE_GET_JOYSTICK_CTRL_AUTH_EVENT :
+            USER_LOG_INFO("[Event]Current joystick ctrl authority is reset to rc due to rc switching mode\r\n");
+            break;
+        case GDU_FLIGHT_CONTROLLER_RC_PAUSE_GET_JOYSTICK_CTRL_AUTH_EVENT :
+            USER_LOG_INFO("[Event]Current joystick ctrl authority is reset to rc due to rc pausing\r\n");
+            break;
+        case GDU_FLIGHT_CONTROLLER_RC_REQUEST_GO_HOME_GET_JOYSTICK_CTRL_AUTH_EVENT :
+            USER_LOG_INFO("[Event]Current joystick ctrl authority is reset to rc due to rc request for return\r\n");
+            break;
+        case GDU_FLIGHT_CONTROLLER_LOW_BATTERY_GO_HOME_RESET_JOYSTICK_CTRL_AUTH_EVENT :
+            USER_LOG_INFO("[Event]Current joystick ctrl authority is reset to rc for low battery return\r\n");
+            break;
+        case GDU_FLIGHT_CONTROLLER_LOW_BATTERY_LANDING_RESET_JOYSTICK_CTRL_AUTH_EVENT :
+            USER_LOG_INFO("[Event]Current joystick ctrl authority is reset to rc for low battery land\r\n");
+            break;
+        case GDU_FLIGHT_CONTROLLER_OSDK_LOST_GET_JOYSTICK_CTRL_AUTH_EVENT:
+            USER_LOG_INFO("[Event]Current joystick ctrl authority is reset to rc due to osdk lost\r\n");
+            break;
+        case GDU_FLIGHT_CONTROLLER_NERA_FLIGHT_BOUNDARY_RESET_JOYSTICK_CTRL_AUTH_EVENT :
+            USER_LOG_INFO("[Event]Current joystick ctrl authority is reset to rc due to near boundary\r\n");
+            break;
+        default:
+            USER_LOG_INFO("[Event]Unknown joystick ctrl authority event\r\n");
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/****************** (C) COPYRIGHT GDU Innovations *****END OF FILE****/

+/**
+ ********************************************************************
+ * @file    test_flight_control.h
+ * @brief   This is the header file for "test_flight_control.c", defining the structure and
+ * (exported) function prototypes.
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef TEST_FLIGHT_CONTROL_H
+#define TEST_FLIGHT_CONTROL_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "gdu_typedef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Exported constants --------------------------------------------------------*/
+typedef enum {
+    E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_TAKE_OFF_LANDING,
+    E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_TAKE_OFF_POSITION_CTRL_LANDING,
+    E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_TAKE_OFF_GO_HOME_FORCE_LANDING,
+    E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_TAKE_OFF_VELOCITY_CTRL_LANDING,
+    E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_ARREST_FLYING,
+    E_GDU_TEST_FLIGHT_CTRL_SAMPLE_SELECT_SET_GET_PARAM,
+} E_GduTestFlightCtrlSampleSelect;
+
+/* Exported types ------------------------------------------------------------*/
+
+/* Exported functions --------------------------------------------------------*/
+T_GduReturnCode GduTest_FlightControlRunSample(E_GduTestFlightCtrlSampleSelect flightCtrlSampleSelect);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TEST_FLIGHT_CONTROL_H
+/************************ (C) COPYRIGHT GDU Innovations *******END OF FILE******/

+/**
+ ********************************************************************
+ * @file    test_payload_gimbal_emu.c
+ * @brief
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include "math.h"
+#include <gdu_gimbal.h>
+#include "test_payload_gimbal_emu.h"
+//#include "gdu_fc_subscription.h"
+#include "gdu_logger.h"
+#include "gdu_platform.h"
+#include "utils/util_misc.h"
+
+/* Private constants ---------------------------------------------------------*/
+#define PAYLOAD_GIMBAL_EMU_TASK_STACK_SIZE  (2048)
+#define PAYLOAD_GIMBAL_TASK_FREQ            1000
+#define PAYLOAD_GIMBAL_CALIBRATION_TIME_MS  2000
+
+/* Private types -------------------------------------------------------------*/
+typedef enum {
+    TEST_GIMBAL_CONTROL_TYPE_UNKNOWN = 0,
+    TEST_GIMBAL_CONTROL_TYPE_SPEED = 1,
+    TEST_GIMBAL_CONTROL_TYPE_ANGLE = 2,
+} E_TestGimbalControlType;
+
+/* Private functions declaration ---------------------------------------------*/
+static void *UserGimbal_Task(void *arg);
+static T_GduReturnCode GetSystemState(T_GduGimbalSystemState *systemState);
+static T_GduReturnCode GetAttitudeInformation(T_GduGimbalAttitudeInformation *attitudeInformation);
+static T_GduReturnCode GetCalibrationState(T_GduGimbalCalibrationState *calibrationState);
+static T_GduReturnCode GetRotationSpeed(T_GduAttitude3d *rotationSpeed);
+static T_GduReturnCode GetJointAngle(T_GduAttitude3d *jointAngle);
+static T_GduReturnCode StartCalibrate(void);
+static T_GduReturnCode SetControllerSmoothFactor(uint8_t smoothingFactor, E_GduGimbalAxis axis);
+static T_GduReturnCode SetPitchRangeExtensionEnabled(bool enabledFlag);
+static T_GduReturnCode SetControllerMaxSpeedPercentage(uint8_t maxSpeedPercentage, E_GduGimbalAxis axis);
+static T_GduReturnCode RestoreFactorySettings(void);
+static T_GduReturnCode SetMode(E_GduGimbalMode mode);
+static T_GduReturnCode Reset(E_GduGimbalResetMode mode);
+static T_GduReturnCode FineTuneAngle(T_GduAttitude3d fineTuneAngle);
+static T_GduReturnCode GduTest_GimbalAngleLegalization(T_GduAttitude3f *attitude, T_GduAttitude3d aircraftAttitude,
+                                                       T_GduGimbalReachLimitFlag *reachLimitFlag);
+static T_GduReturnCode
+GduTest_GimbalCalculateSpeed(T_GduAttitude3d originalAttitude, T_GduAttitude3d targetAttitude, uint16_t actionTime,
+                             T_GduAttitude3d *speed);
+static void GduTest_GimbalSpeedLegalization(T_GduAttitude3d *speed);
+//static T_GduReturnCode GduTest_GimbalCalculateGroundAttitudeBaseQuaternion(T_GduFcSubscriptionQuaternion quaternion,
+//                                                                           T_GduAttitude3d *attitude);
+
+/* Private variables ---------------------------------------------------------*/
+static T_GduTaskHandle s_userGimbalThread;
+static T_GduGimbalCommonHandler s_commonHandler = {0};
+static T_GduGimbalSystemState s_systemState = {0};
+static bool s_rotatingFlag = false;
+static T_GduMutexHandle s_commonMutex = {0};
+
+static T_GduGimbalAttitudeInformation s_attitudeInformation = {0}; // unit: 0.1 degree, ground coordination
+static T_GduAttitude3f s_attitudeHighPrecision = {0}; // unit: 0.1 degree, ground coordination
+static T_GduGimbalCalibrationState s_calibrationState = {0};
+static T_GduAttitude3d s_targetAttitude = {0}; // unit: 0.1 degree, ground coordination
+static T_GduAttitude3d s_speed = {0}; // unit: 0.1 degree/s, ground coordination
+static T_GduAttitude3d s_aircraftAttitude = {0}; // unit: 0.1 degree, ground coordination
+static T_GduAttitude3d s_lastAircraftAttitude = {0}; // unit: 0.1 degree, ground coordination
+static E_TestGimbalControlType s_controlType = TEST_GIMBAL_CONTROL_TYPE_UNKNOWN;
+static const T_GduAttitude3d s_jointAngleLimitMin = {-1200, -100, -1800}; // unit: 0.1 degree
+static const T_GduAttitude3d s_jointAngleLimitMax = {300, 100, 1800}; // unit: 0.1 degree
+static const T_GduAttitude3d s_eulerAngleLimitMin = {-900, -100, -1800}; // unit: 0.1 degree
+static const T_GduAttitude3d s_eulerAngleLimitMax = {100, 100, 1800}; // unit: 0.1 degree
+static const int32_t s_pitchEulerAngleExtensionMin = -1200; // unit: 0.1 degree
+static const int32_t s_pitchEulerAngleExtensionMax = 300; // unit: 0.1 degree
+static const T_GduAttitude3d s_speedLimit = {1800, 1800, 1800}; // unit: 0.1 degree/s
+static uint32_t s_calibrationStartTime = 0; // unit: ms
+static T_GduMutexHandle s_attitudeMutex = NULL;
+static T_GduMutexHandle s_calibrationMutex = NULL;
+
+/* Exported functions definition ---------------------------------------------*/
+/**
+ * @brief
+ * @note Gimbal sample rely on aircraft quaternion.
+ * @return
+ */
+T_GduReturnCode GduTest_GimbalStartService(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    s_systemState.resettingFlag = false;
+    s_systemState.mountedUpward = false;
+    s_systemState.blockingFlag = false;
+    s_systemState.pitchRangeExtensionEnabledFlag = false;
+
+    s_calibrationState.calibratingFlag = false;
+    s_calibrationState.lastCalibrationResult = true;
+
+    s_commonHandler.GetSystemState = GetSystemState;//
+    s_commonHandler.GetAttitudeInformation = GetAttitudeInformation;//获取云台姿态信息
+    s_commonHandler.GetCalibrationState = GetCalibrationState;//获取校准状态
+    s_commonHandler.GetRotationSpeed = GetRotationSpeed;//获取云台转动速度
+    s_commonHandler.GetJointAngle = GetJointAngle;//获取云台关节角度
+    s_commonHandler.Rotate = GduTest_GimbalRotate;//控制云台转动
+    s_commonHandler.StartCalibrate = StartCalibrate;//启动校准
+    s_commonHandler.SetControllerSmoothFactor = SetControllerSmoothFactor;//设置控制器平滑因子
+    s_commonHandler.SetPitchRangeExtensionEnabled = SetPitchRangeExtensionEnabled;//范围扩展启动，设置俯仰范围***
+    s_commonHandler.SetControllerMaxSpeedPercentage = SetControllerMaxSpeedPercentage; //设置最大速度控制百分比
+    s_commonHandler.RestoreFactorySettings = RestoreFactorySettings;//恢复出厂设置
+    s_commonHandler.SetMode = SetMode;
+    s_commonHandler.Reset = Reset;
+    s_commonHandler.FineTuneAngle = FineTuneAngle;//姿态微调角度
+
+    if (osalHandler->MutexCreate(&s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex create error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (osalHandler->MutexCreate(&s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex create error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (osalHandler->MutexCreate(&s_calibrationMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex create error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    gduStat = GduGimbal_RegCommonHandler(&s_commonHandler);
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("gimbal register common handler error: 0x%08llX", gduStat);
+    }
+
+    gduStat = GduGimbal_Init();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("init gimbal module error: 0x%08llX", gduStat);
+    }
+
+    if (osalHandler->TaskCreate("user_gimbal_task", UserGimbal_Task,
+                                PAYLOAD_GIMBAL_EMU_TASK_STACK_SIZE, NULL, &s_userGimbalThread) !=
+        GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("user gimbal task create error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+T_GduReturnCode GduTest_GimbalDeInit(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    gduStat = osalHandler->TaskDestroy(s_userGimbalThread);
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Destroy test gimbal thread error: 0x%08llX.", gduStat);
+        return gduStat;
+    }
+
+    gduStat = GduGimbal_DeInit();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Deinit gimbal module error: 0x%08llX.", gduStat);
+        return gduStat;
+    }
+
+    if (osalHandler->MutexDestroy(s_calibrationMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex destroy error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (osalHandler->MutexDestroy(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex destroy error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (osalHandler->MutexDestroy(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex destroy error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+T_GduReturnCode GduTest_GimbalRotate(E_GduGimbalRotationMode rotationMode,
+                                     T_GduGimbalRotationProperty rotationProperty,
+                                     T_GduAttitude3d rotationValue)
+{
+    T_GduReturnCode gduStat;
+    T_GduReturnCode returnCode = GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+    T_GduAttitude3d targetAttitudeDTemp = {0};
+    T_GduAttitude3f targetAttitudeFTemp = {0};
+    T_GduAttitude3d speedTemp = {0};
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+//    USER_LOG_DEBUG("gimbal rotation value invalid flag: pitch %d, roll %d, yaw %d.",
+//                   rotationProperty.rotationValueInvalidFlag.pitch,
+//                   rotationProperty.rotationValueInvalidFlag.roll,
+//                   rotationProperty.rotationValueInvalidFlag.yaw);
+
+    if (osalHandler->MutexLock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        returnCode = GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+        goto out2;
+    }
+
+    switch (rotationMode) {
+        case GDU_GIMBAL_ROTATION_MODE_RELATIVE_ANGLE:
+            USER_LOG_INFO("gimbal relative rotate angle: pitch %d, roll %d, yaw %d.", rotationValue.pitch,
+                          rotationValue.roll, rotationValue.yaw);
+            USER_LOG_DEBUG("gimbal relative rotate action time: %d.",
+                           rotationProperty.relativeAngleRotation.actionTime);
+
+            if (s_rotatingFlag == true) {
+                USER_LOG_WARN("gimbal is rotating.");
+                goto out1;
+            }
+
+            targetAttitudeDTemp.pitch =
+                rotationProperty.rotationValueInvalidFlag.pitch == true ? s_attitudeInformation.attitude.pitch : (
+                    s_attitudeInformation.attitude.pitch + rotationValue.pitch);
+            targetAttitudeDTemp.roll =
+                rotationProperty.rotationValueInvalidFlag.roll == true ? s_attitudeInformation.attitude.roll : (
+                    s_attitudeInformation.attitude.roll + rotationValue.roll);
+            targetAttitudeDTemp.yaw =
+                rotationProperty.rotationValueInvalidFlag.yaw == true ? s_attitudeInformation.attitude.yaw : (
+                    s_attitudeInformation.attitude.yaw + rotationValue.yaw);
+
+            targetAttitudeFTemp.pitch = targetAttitudeDTemp.pitch;
+            targetAttitudeFTemp.roll = targetAttitudeDTemp.roll;
+            targetAttitudeFTemp.yaw = targetAttitudeDTemp.yaw;
+            GduTest_GimbalAngleLegalization(&targetAttitudeFTemp, s_aircraftAttitude, NULL);
+            targetAttitudeDTemp.pitch = targetAttitudeFTemp.pitch;
+            targetAttitudeDTemp.roll = targetAttitudeFTemp.roll;
+            targetAttitudeDTemp.yaw = targetAttitudeFTemp.yaw;
+
+            s_targetAttitude = targetAttitudeDTemp;
+            s_rotatingFlag = true;
+            s_controlType = TEST_GIMBAL_CONTROL_TYPE_ANGLE;
+
+            gduStat = GduTest_GimbalCalculateSpeed(s_attitudeInformation.attitude, s_targetAttitude,
+                                                   rotationProperty.relativeAngleRotation.actionTime, &s_speed);
+            if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+                USER_LOG_ERROR("calculate gimbal rotation speed error: 0x%08llX.", gduStat);
+                returnCode = gduStat;
+                goto out1;
+            }
+
+            break;
+        case GDU_GIMBAL_ROTATION_MODE_ABSOLUTE_ANGLE:
+            USER_LOG_INFO("gimbal absolute rotate angle: pitch %d, roll %d, yaw %d.", rotationValue.pitch,
+                          rotationValue.roll, rotationValue.yaw);
+            USER_LOG_DEBUG("gimbal absolute rotate action time: %d.",
+                           rotationProperty.absoluteAngleRotation.actionTime);
+            if (rotationProperty.absoluteAngleRotation.jointAngleValid) {
+                USER_LOG_DEBUG("gimbal joint angles: pitch %d, roll %d, yaw %d.",
+                               rotationProperty.absoluteAngleRotation.jointAngle.pitch,
+                               rotationProperty.absoluteAngleRotation.jointAngle.roll,
+                               rotationProperty.absoluteAngleRotation.jointAngle.yaw);
+            }
+
+            if (s_rotatingFlag == true) {
+                USER_LOG_WARN("gimbal is rotating.");
+                goto out1;
+            }
+
+            targetAttitudeDTemp.pitch =
+                rotationProperty.rotationValueInvalidFlag.pitch == true ? s_attitudeInformation.attitude.pitch
+                                                                        : rotationValue.pitch;
+            targetAttitudeDTemp.roll =
+                rotationProperty.rotationValueInvalidFlag.roll == true ? s_attitudeInformation.attitude.roll
+                                                                       : rotationValue.roll;
+            targetAttitudeDTemp.yaw =
+                rotationProperty.rotationValueInvalidFlag.yaw == true ? s_attitudeInformation.attitude.yaw
+                                                                      : rotationValue.yaw;
+
+            targetAttitudeFTemp.pitch = targetAttitudeDTemp.pitch;
+            targetAttitudeFTemp.roll = targetAttitudeDTemp.roll;
+            targetAttitudeFTemp.yaw = targetAttitudeDTemp.yaw;
+            GduTest_GimbalAngleLegalization(&targetAttitudeFTemp, s_aircraftAttitude, NULL);
+            targetAttitudeDTemp.pitch = targetAttitudeFTemp.pitch;
+            targetAttitudeDTemp.roll = targetAttitudeFTemp.roll;
+            targetAttitudeDTemp.yaw = targetAttitudeFTemp.yaw;
+
+            s_targetAttitude = targetAttitudeDTemp;
+            s_rotatingFlag = true;
+            s_controlType = TEST_GIMBAL_CONTROL_TYPE_ANGLE;
+
+            gduStat = GduTest_GimbalCalculateSpeed(s_attitudeInformation.attitude, s_targetAttitude,
+                                                   rotationProperty.absoluteAngleRotation.actionTime, &s_speed);
+            if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+                USER_LOG_ERROR("calculate gimbal rotation speed error: 0x%08llX.", gduStat);
+                returnCode = gduStat;
+                goto out1;
+            }
+
+            break;
+        case GDU_GIMBAL_ROTATION_MODE_SPEED:
+//            USER_LOG_INFO("gimbal rotate speed: pitch %d, roll %d, yaw %d.", rotationValue.pitch,
+//                          rotationValue.roll, rotationValue.yaw);
+
+            if (s_rotatingFlag == true && s_controlType == TEST_GIMBAL_CONTROL_TYPE_ANGLE) {
+                USER_LOG_WARN("gimbal is rotating.");
+                goto out1;
+            }
+
+            memcpy(&speedTemp, &rotationValue, sizeof(T_GduAttitude3d));
+            GduTest_GimbalSpeedLegalization(&speedTemp);
+            s_speed = speedTemp;
+
+            if (rotationValue.pitch != 0 || rotationValue.roll != 0 || rotationValue.yaw != 0) {
+                s_rotatingFlag = true;
+                s_controlType = TEST_GIMBAL_CONTROL_TYPE_SPEED;
+            } else {
+                s_rotatingFlag = false;
+            }
+
+            break;
+        default:
+            USER_LOG_ERROR("gimbal rotation mode invalid: %d.", rotationMode);
+            returnCode = GDU_ERROR_SYSTEM_MODULE_CODE_NONSUPPORT;
+            goto out1;
+    }
+
+out1:
+    if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        returnCode = GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+        goto out2;
+    }
+
+out2:
+    if (osalHandler->MutexUnlock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return returnCode;
+}
+
+/* Private functions definition-----------------------------------------------*/
+#ifndef __CC_ARM
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-noreturn"
+#pragma GCC diagnostic ignored "-Wreturn-type"
+#endif
+
+static void *UserGimbal_Task(void *arg)
+{
+    T_GduReturnCode gduStat;
+    static uint32_t step = 0;
+    //T_GduFcSubscriptionQuaternion quaternion = {0};
+    T_GduDataTimestamp timestamp = {0};
+    T_GduAttitude3f nextAttitude = {0};
+    T_GduAttitude3f attitudeFTemp = {0};
+    uint32_t currentTime = 0;
+    uint32_t progressTemp = 0;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    USER_UTIL_UNUSED(arg);
+
+    while (1) {
+        osalHandler->TaskSleepMs(1000 / PAYLOAD_GIMBAL_TASK_FREQ);
+        step++;
+
+        if (osalHandler->MutexLock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("mutex lock error");
+            continue;
+        }
+
+        if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("mutex lock error");
+            goto out2;
+        }
+
+        if (USER_UTIL_IS_WORK_TURN(step, 1, PAYLOAD_GIMBAL_TASK_FREQ)) {
+            USER_LOG_DEBUG("gimbal attitude: pitch %d, roll %d, yaw %d.", s_attitudeInformation.attitude.pitch,
+                           s_attitudeInformation.attitude.roll, s_attitudeInformation.attitude.yaw);
+
+            USER_LOG_DEBUG("gimbal fine tune: pitch %d, roll %d, yaw %d.", s_systemState.fineTuneAngle.pitch,
+                           s_systemState.fineTuneAngle.roll, s_systemState.fineTuneAngle.yaw);
+        }
+      
+#if 0
+        // update aircraft attitude
+        if (USER_UTIL_IS_WORK_TURN(step, 50, PAYLOAD_GIMBAL_TASK_FREQ)) {
+            gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_QUATERNION,
+                                                              (uint8_t *) &quaternion,
+                                                              sizeof(T_GduFcSubscriptionQuaternion),
+                                                              &timestamp);
+            if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+                USER_LOG_ERROR("get topic quaternion value error.");
+            }
+
+            gduStat = GduTest_GimbalCalculateGroundAttitudeBaseQuaternion(quaternion, &s_aircraftAttitude);
+            if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+                USER_LOG_ERROR("calculate and update aircraft attitude error.");
+            }
+        }
+#endif
+
+        // stable control
+        switch (s_systemState.gimbalMode) {
+            case GDU_GIMBAL_MODE_FREE:
+                break;
+            case GDU_GIMBAL_MODE_FPV:
+                s_attitudeInformation.attitude.roll += (s_aircraftAttitude.roll - s_lastAircraftAttitude.roll);
+                s_attitudeInformation.attitude.yaw += (s_aircraftAttitude.yaw - s_lastAircraftAttitude.yaw);
+
+                s_attitudeHighPrecision.roll += (float) (s_aircraftAttitude.roll - s_lastAircraftAttitude.roll);
+                s_attitudeHighPrecision.yaw += (float) (s_aircraftAttitude.yaw - s_lastAircraftAttitude.yaw);
+
+                if (s_rotatingFlag == true && s_controlType == TEST_GIMBAL_CONTROL_TYPE_ANGLE) {
+                    s_targetAttitude.roll += (s_aircraftAttitude.roll - s_lastAircraftAttitude.roll);
+                    s_targetAttitude.yaw += (s_aircraftAttitude.yaw - s_lastAircraftAttitude.yaw);
+                }
+                break;
+            case GDU_GIMBAL_MODE_YAW_FOLLOW:
+                s_attitudeInformation.attitude.yaw += (s_aircraftAttitude.yaw - s_lastAircraftAttitude.yaw);
+
+                s_attitudeHighPrecision.yaw += (float) (s_aircraftAttitude.yaw - s_lastAircraftAttitude.yaw);
+
+                if (s_rotatingFlag == true && s_controlType == TEST_GIMBAL_CONTROL_TYPE_ANGLE) {
+                    s_targetAttitude.yaw += (s_aircraftAttitude.yaw - s_lastAircraftAttitude.yaw);
+                }
+                break;
+            default:
+                USER_LOG_ERROR("gimbal mode invalid: %d.", s_systemState.gimbalMode);
+        }
+        s_lastAircraftAttitude = s_aircraftAttitude;
+
+        attitudeFTemp.pitch = s_attitudeInformation.attitude.pitch;
+        attitudeFTemp.roll = s_attitudeInformation.attitude.roll;
+        attitudeFTemp.yaw = s_attitudeInformation.attitude.yaw;
+        GduTest_GimbalAngleLegalization(&attitudeFTemp, s_aircraftAttitude, &s_attitudeInformation.reachLimitFlag);
+        s_attitudeInformation.attitude.pitch = attitudeFTemp.pitch;
+        s_attitudeInformation.attitude.roll = attitudeFTemp.roll;
+        s_attitudeInformation.attitude.yaw = attitudeFTemp.yaw;
+
+        GduTest_GimbalAngleLegalization(&s_attitudeHighPrecision, s_aircraftAttitude, NULL);
+
+        attitudeFTemp.pitch = s_targetAttitude.pitch;
+        attitudeFTemp.roll = s_targetAttitude.roll;
+        attitudeFTemp.yaw = s_targetAttitude.yaw;
+        GduTest_GimbalAngleLegalization(&attitudeFTemp, s_aircraftAttitude, NULL);
+        s_targetAttitude.pitch = attitudeFTemp.pitch;
+        s_targetAttitude.roll = attitudeFTemp.roll;
+        s_targetAttitude.yaw = attitudeFTemp.yaw;
+
+        // rotation
+        if (s_rotatingFlag != true)
+            goto out1;
+
+        nextAttitude.pitch =
+            (float) s_attitudeHighPrecision.pitch + (float) s_speed.pitch / (float) PAYLOAD_GIMBAL_TASK_FREQ;
+        nextAttitude.roll =
+            (float) s_attitudeHighPrecision.roll + (float) s_speed.roll / (float) PAYLOAD_GIMBAL_TASK_FREQ;
+        nextAttitude.yaw = (float) s_attitudeHighPrecision.yaw + (float) s_speed.yaw / (float) PAYLOAD_GIMBAL_TASK_FREQ;
+
+        if (s_controlType == TEST_GIMBAL_CONTROL_TYPE_ANGLE) {
+            nextAttitude.pitch =
+                (nextAttitude.pitch - s_targetAttitude.pitch) * s_speed.pitch >= 0 ? s_targetAttitude.pitch
+                                                                                   : nextAttitude.pitch;
+            nextAttitude.roll = (nextAttitude.roll - s_targetAttitude.roll) * s_speed.roll >= 0 ? s_targetAttitude.roll
+                                                                                                : nextAttitude.roll;
+            nextAttitude.yaw =
+                (nextAttitude.yaw - s_targetAttitude.yaw) * s_speed.yaw >= 0 ? s_targetAttitude.yaw : nextAttitude.yaw;
+        }
+
+        GduTest_GimbalAngleLegalization(&nextAttitude, s_aircraftAttitude, &s_attitudeInformation.reachLimitFlag);
+        s_attitudeInformation.attitude.pitch = nextAttitude.pitch;
+        s_attitudeInformation.attitude.roll = nextAttitude.roll;
+        s_attitudeInformation.attitude.yaw = nextAttitude.yaw;
+
+        s_attitudeHighPrecision.pitch = nextAttitude.pitch;
+        s_attitudeHighPrecision.roll = nextAttitude.roll;
+        s_attitudeHighPrecision.yaw = nextAttitude.yaw;
+
+        if (s_controlType == TEST_GIMBAL_CONTROL_TYPE_ANGLE) {
+            if (memcmp(&s_attitudeInformation.attitude, &s_targetAttitude, sizeof(T_GduAttitude3d)) == 0) {
+                s_rotatingFlag = false;
+            }
+        } else if (s_controlType == TEST_GIMBAL_CONTROL_TYPE_SPEED) {
+            if ((s_attitudeInformation.reachLimitFlag.pitch == true || s_speed.pitch == 0) &&
+                (s_attitudeInformation.reachLimitFlag.roll == true || s_speed.roll == 0) &&
+                (s_attitudeInformation.reachLimitFlag.yaw == true || s_speed.yaw == 0)) {
+                s_rotatingFlag = false;
+            }
+        }
+
+out1:
+        if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("mutex unlock error");
+            goto out2;
+        }
+
+out2:
+        if (osalHandler->MutexUnlock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("mutex unlock error");
+            continue;
+        }
+
+        gduStat = osalHandler->GetTimeMs(&currentTime);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get current time error: 0x%08llX.", gduStat);
+            continue;
+        }
+
+        if (osalHandler->MutexLock(s_calibrationMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("mutex lock error");
+            continue;
+        }
+
+        // calibration
+        if (s_calibrationState.calibratingFlag != true)
+            goto unlockCalibrationMutex;
+
+        progressTemp = (currentTime - s_calibrationStartTime) * 100 / PAYLOAD_GIMBAL_CALIBRATION_TIME_MS;
+        if (progressTemp >= 100) {
+            s_calibrationState.calibratingFlag = false;
+            s_calibrationState.currentCalibrationProgress = 100;
+            s_calibrationState.currentCalibrationStage = GDU_GIMBAL_CALIBRATION_STAGE_COMPLETE;
+        }
+
+unlockCalibrationMutex:
+        if (osalHandler->MutexUnlock(s_calibrationMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("mutex unlock error");
+            continue;
+        }
+    }
+}
+
+#ifndef __CC_ARM
+#pragma GCC diagnostic pop
+#endif
+
+static T_GduReturnCode GetSystemState(T_GduGimbalSystemState *systemState)
+{
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    *systemState = s_systemState;
+
+    if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode GetAttitudeInformation(T_GduGimbalAttitudeInformation *attitudeInformation)
+{
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    if (osalHandler->MutexLock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    *attitudeInformation = s_attitudeInformation;
+
+    if (osalHandler->MutexUnlock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode GetCalibrationState(T_GduGimbalCalibrationState *calibrationState)
+{
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    if (osalHandler->MutexLock(s_calibrationMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    *calibrationState = s_calibrationState;
+
+    if (osalHandler->MutexUnlock(s_calibrationMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode GetRotationSpeed(T_GduAttitude3d *rotationSpeed)
+{
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    if (osalHandler->MutexLock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    *rotationSpeed = s_speed;
+
+    if (osalHandler->MutexUnlock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode GetJointAngle(T_GduAttitude3d *jointAngle)
+{
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    if (osalHandler->MutexLock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    jointAngle->pitch = s_attitudeInformation.attitude.pitch - s_aircraftAttitude.pitch;
+    jointAngle->roll = s_attitudeInformation.attitude.roll - s_aircraftAttitude.roll;
+    jointAngle->yaw = s_attitudeInformation.attitude.yaw - s_aircraftAttitude.yaw;
+
+    printf("云台角度:%d ,%d ,%d\n",jointAngle->pitch,jointAngle->roll,jointAngle->yaw);
+    
+    if (osalHandler->MutexUnlock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode StartCalibrate(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    USER_LOG_INFO("start calibrate gimbal.");
+
+    gduStat = osalHandler->GetTimeMs(&s_calibrationStartTime);
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("get start time error: 0x%08llX.", gduStat);
+    }
+
+    if (osalHandler->MutexLock(s_calibrationMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    s_calibrationState.calibratingFlag = true;
+    s_calibrationState.currentCalibrationProgress = 0;
+    s_calibrationState.currentCalibrationStage = GDU_GIMBAL_CALIBRATION_STAGE_PROCRESSING;
+
+    if (osalHandler->MutexUnlock(s_calibrationMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode SetControllerSmoothFactor(uint8_t smoothingFactor, E_GduGimbalAxis axis)
+{
+    USER_LOG_INFO("set gimbal controller smooth factor: factor %d, axis %d.", smoothingFactor, axis);
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (axis == GDU_GIMBAL_AXIS_PITCH)
+        s_systemState.smoothFactor.pitch = smoothingFactor;
+    else if (axis == GDU_GIMBAL_AXIS_YAW)
+        s_systemState.smoothFactor.yaw = smoothingFactor;
+    else
+        USER_LOG_ERROR("axis is not supported.");
+
+    if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode SetPitchRangeExtensionEnabled(bool enabledFlag)
+{
+    USER_LOG_INFO("set gimbal pitch range extension enable flag: %d.", enabledFlag);
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    s_systemState.pitchRangeExtensionEnabledFlag = enabledFlag;
+
+    if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode SetControllerMaxSpeedPercentage(uint8_t maxSpeedPercentage, E_GduGimbalAxis axis)
+{
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    USER_LOG_INFO("set gimbal controller max speed: max speed %d, axis %d.", maxSpeedPercentage, axis);
+
+    if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (axis == GDU_GIMBAL_AXIS_PITCH)
+        s_systemState.maxSpeedPercentage.pitch = maxSpeedPercentage;
+    else if (axis == GDU_GIMBAL_AXIS_YAW)
+        s_systemState.maxSpeedPercentage.yaw = maxSpeedPercentage;
+    else
+        USER_LOG_ERROR("axis is not supported.");
+
+    if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode RestoreFactorySettings(void)
+{
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    USER_LOG_INFO("restore gimbal factory settings.");
+
+    if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    s_systemState.pitchRangeExtensionEnabledFlag = false;
+    s_systemState.gimbalMode = GDU_GIMBAL_MODE_FREE;
+    memset(&s_systemState.fineTuneAngle, 0, sizeof(s_systemState.fineTuneAngle));
+    memset(&s_systemState.smoothFactor, 0, sizeof(s_systemState.smoothFactor));
+    s_systemState.maxSpeedPercentage.pitch = 1;
+    s_systemState.maxSpeedPercentage.yaw = 1;
+
+    if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode SetMode(E_GduGimbalMode mode)
+{
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    USER_LOG_INFO("set gimbal mode: %d.", mode);
+
+    if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    s_systemState.gimbalMode = mode;
+
+    if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static T_GduReturnCode Reset(E_GduGimbalResetMode mode)
+{
+    T_GduReturnCode gduReturnCode = GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+    T_GduAttitude3f attitudeFTemp = {0};
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    USER_LOG_INFO("reset gimbal: %d.", mode);
+
+    if (osalHandler->MutexLock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        gduReturnCode = GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+        goto unlock2;
+    }
+
+    switch (mode) {
+        case GDU_GIMBAL_RESET_MODE_YAW:
+            s_attitudeInformation.attitude.yaw = s_aircraftAttitude.yaw + s_systemState.fineTuneAngle.yaw;
+
+            s_attitudeHighPrecision.yaw = s_aircraftAttitude.yaw + s_systemState.fineTuneAngle.yaw;
+            break;
+        case GDU_GIMBAL_RESET_MODE_PITCH_AND_YAW:
+            s_attitudeInformation.attitude.pitch = s_systemState.fineTuneAngle.pitch;
+            s_attitudeInformation.attitude.yaw = s_aircraftAttitude.yaw + s_systemState.fineTuneAngle.yaw;
+
+            s_attitudeHighPrecision.pitch = s_systemState.fineTuneAngle.pitch;
+            s_attitudeHighPrecision.yaw = s_aircraftAttitude.yaw + s_systemState.fineTuneAngle.yaw;
+            break;
+        case GDU_GIMBAL_RESET_MODE_PITCH_DOWNWARD_UPWARD_AND_YAW:
+            s_attitudeInformation.attitude.pitch =
+                s_systemState.fineTuneAngle.pitch + (s_systemState.mountedUpward ? 900 : -900);
+            s_attitudeInformation.attitude.yaw = s_aircraftAttitude.yaw + s_systemState.fineTuneAngle.yaw;
+
+            s_attitudeHighPrecision.pitch =
+                s_systemState.fineTuneAngle.pitch + (s_systemState.mountedUpward ? 900 : -900);
+            s_attitudeHighPrecision.yaw = s_aircraftAttitude.yaw + s_systemState.fineTuneAngle.yaw;
+            break;
+        case GDU_GIMBAL_RESET_MODE_PITCH_DOWNWARD_UPWARD:
+            s_attitudeInformation.attitude.pitch =
+                s_systemState.fineTuneAngle.pitch + (s_systemState.mountedUpward ? 900 : -900);
+
+            s_attitudeHighPrecision.pitch =
+                s_systemState.fineTuneAngle.pitch + (s_systemState.mountedUpward ? 900 : -900);
+            break;
+        default:
+            USER_LOG_ERROR("reset mode is invalid: %d.", mode);
+            gduReturnCode = GDU_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+            goto unlock1;
+    }
+
+    attitudeFTemp.pitch = s_attitudeInformation.attitude.pitch;
+    attitudeFTemp.roll = s_attitudeInformation.attitude.roll;
+    attitudeFTemp.yaw = s_attitudeInformation.attitude.yaw;
+    GduTest_GimbalAngleLegalization(&attitudeFTemp, s_aircraftAttitude, &s_attitudeInformation.reachLimitFlag);
+    s_attitudeInformation.attitude.pitch = attitudeFTemp.pitch;
+    s_attitudeInformation.attitude.roll = attitudeFTemp.roll;
+    s_attitudeInformation.attitude.yaw = attitudeFTemp.yaw;
+    GduTest_GimbalAngleLegalization(&s_attitudeHighPrecision, s_aircraftAttitude, NULL);
+
+    s_rotatingFlag = false;
+
+unlock1:
+    if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        gduReturnCode = GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+        goto unlock2;
+    }
+
+unlock2:
+    if (osalHandler->MutexUnlock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return gduReturnCode;
+}
+
+static T_GduReturnCode FineTuneAngle(T_GduAttitude3d fineTuneAngle)
+{
+    T_GduReturnCode gduReturnCode = GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+    T_GduGimbalReachLimitFlag attitudeReachLimitFlag = {0};
+    T_GduGimbalReachLimitFlag fineTuneAngleReachLimitFlag = {0};
+    T_GduAttitude3d aircraftAttitudeResetted = {0};
+    T_GduAttitude3f attitudeFTemp = {0};
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    USER_LOG_INFO("gimbal fine tune angle: pitch %d, roll %d, yaw %d.", fineTuneAngle.pitch,
+                  fineTuneAngle.roll, fineTuneAngle.yaw);
+
+    if (osalHandler->MutexLock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    s_attitudeInformation.attitude.pitch += fineTuneAngle.pitch;
+    s_attitudeInformation.attitude.roll += fineTuneAngle.roll;
+    s_attitudeInformation.attitude.yaw += fineTuneAngle.yaw;
+    attitudeFTemp.pitch = s_attitudeInformation.attitude.pitch;
+    attitudeFTemp.roll = s_attitudeInformation.attitude.roll;
+    attitudeFTemp.yaw = s_attitudeInformation.attitude.yaw;
+    GduTest_GimbalAngleLegalization(&attitudeFTemp, s_aircraftAttitude, &attitudeReachLimitFlag);
+    s_attitudeInformation.attitude.pitch = attitudeFTemp.pitch;
+    s_attitudeInformation.attitude.roll = attitudeFTemp.roll;
+    s_attitudeInformation.attitude.yaw = attitudeFTemp.yaw;
+
+    s_attitudeHighPrecision.pitch += fineTuneAngle.pitch;
+    s_attitudeHighPrecision.roll += fineTuneAngle.roll;
+    s_attitudeHighPrecision.yaw += fineTuneAngle.yaw;
+    GduTest_GimbalAngleLegalization(&s_attitudeHighPrecision, s_aircraftAttitude, NULL);
+
+    if (osalHandler->MutexLock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex lock error");
+        gduReturnCode = GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+        goto unlock;
+    }
+
+    s_systemState.fineTuneAngle.pitch += fineTuneAngle.pitch;
+    s_systemState.fineTuneAngle.roll += fineTuneAngle.roll;
+    s_systemState.fineTuneAngle.yaw += fineTuneAngle.yaw;
+    attitudeFTemp.pitch = s_systemState.fineTuneAngle.pitch;
+    attitudeFTemp.roll = s_systemState.fineTuneAngle.roll;
+    attitudeFTemp.yaw = s_systemState.fineTuneAngle.yaw;
+    GduTest_GimbalAngleLegalization(&attitudeFTemp, aircraftAttitudeResetted, &fineTuneAngleReachLimitFlag);
+    s_systemState.fineTuneAngle.pitch = attitudeFTemp.pitch;
+    s_systemState.fineTuneAngle.roll = attitudeFTemp.roll;
+    s_systemState.fineTuneAngle.yaw = attitudeFTemp.yaw;
+
+    if (osalHandler->MutexUnlock(s_commonMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        gduReturnCode = GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+        goto unlock;
+    }
+
+unlock:
+    if (osalHandler->MutexUnlock(s_attitudeMutex) != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("mutex unlock error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (((attitudeReachLimitFlag.pitch == true || fineTuneAngleReachLimitFlag.pitch == true) &&
+         fineTuneAngle.pitch != 0) ||
+        ((attitudeReachLimitFlag.roll == true || fineTuneAngleReachLimitFlag.roll == true) &&
+         fineTuneAngle.roll != 0) ||
+        ((attitudeReachLimitFlag.yaw == true || fineTuneAngleReachLimitFlag.yaw == true) && fineTuneAngle.yaw != 0)) {
+        return GDU_ERROR_SYSTEM_MODULE_CODE_OUT_OF_RANGE;
+    }
+
+    return gduReturnCode;
+}
+
+/**
+ * @brief
+ * @param attitude: in ground coordinate
+ * @param aircraftAttitude: in ground coordinate
+ * @param reachLimitFlag
+ * @return
+ */
+static T_GduReturnCode GduTest_GimbalAngleLegalization(T_GduAttitude3f *attitude, T_GduAttitude3d aircraftAttitude,
+                                                       T_GduGimbalReachLimitFlag *reachLimitFlag)
+{
+    T_GduAttitude3d eulerAngleLimitMin;
+    T_GduAttitude3d eulerAngleLimitMax;
+    T_GduAttitude3d angleLimitInBodyCoordinateFromEulerLimitMin = {0};
+    T_GduAttitude3d angleLimitInBodyCoordinateFromEulerLimitMax = {0};
+    T_GduAttitude3d finalAngleLimitInBodyCoordinateMin = {0};
+    T_GduAttitude3d finalAngleLimitInBodyCoordinateMax = {0};
+    T_GduAttitude3f attitudeInBodyCoordinate = {0};
+
+    if (attitude == NULL) {
+        USER_LOG_ERROR("input pointer is null.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
+    // calculate euler angle limit
+    eulerAngleLimitMin = s_eulerAngleLimitMin;
+    eulerAngleLimitMax = s_eulerAngleLimitMax;
+    if (s_systemState.pitchRangeExtensionEnabledFlag == true) {
+        eulerAngleLimitMin.pitch = s_pitchEulerAngleExtensionMin;
+        eulerAngleLimitMax.pitch = s_pitchEulerAngleExtensionMax;
+    }
+
+    // transfer euler angle limit to angle limit in body coordinate
+    angleLimitInBodyCoordinateFromEulerLimitMin.pitch = eulerAngleLimitMin.pitch - aircraftAttitude.pitch;
+    angleLimitInBodyCoordinateFromEulerLimitMin.roll = eulerAngleLimitMin.roll - aircraftAttitude.roll;
+    angleLimitInBodyCoordinateFromEulerLimitMin.yaw = eulerAngleLimitMin.yaw - aircraftAttitude.yaw;
+    angleLimitInBodyCoordinateFromEulerLimitMax.pitch = eulerAngleLimitMax.pitch - aircraftAttitude.pitch;
+    angleLimitInBodyCoordinateFromEulerLimitMax.roll = eulerAngleLimitMax.roll - aircraftAttitude.roll;
+    angleLimitInBodyCoordinateFromEulerLimitMax.yaw = eulerAngleLimitMax.yaw - aircraftAttitude.yaw;
+
+    // calculate final angle limit in body coordinate based on euler angle limit and joint angle limit
+    finalAngleLimitInBodyCoordinateMin.pitch = USER_UTIL_MAX(angleLimitInBodyCoordinateFromEulerLimitMin.pitch,
+                                                             s_jointAngleLimitMin.pitch);
+    finalAngleLimitInBodyCoordinateMin.roll = USER_UTIL_MAX(angleLimitInBodyCoordinateFromEulerLimitMin.roll,
+                                                            s_jointAngleLimitMin.roll);
+    finalAngleLimitInBodyCoordinateMin.yaw = USER_UTIL_MAX(angleLimitInBodyCoordinateFromEulerLimitMin.yaw,
+                                                           s_jointAngleLimitMin.yaw);
+    finalAngleLimitInBodyCoordinateMax.pitch = USER_UTIL_MIN(angleLimitInBodyCoordinateFromEulerLimitMax.pitch,
+                                                             s_jointAngleLimitMax.pitch);
+    finalAngleLimitInBodyCoordinateMax.roll = USER_UTIL_MIN(angleLimitInBodyCoordinateFromEulerLimitMax.roll,
+                                                            s_jointAngleLimitMax.roll);
+    finalAngleLimitInBodyCoordinateMax.yaw = USER_UTIL_MIN(angleLimitInBodyCoordinateFromEulerLimitMax.yaw,
+                                                           s_jointAngleLimitMax.yaw);
+
+    // calculate gimbal attitude in body coordinate
+    attitudeInBodyCoordinate.pitch = attitude->pitch - (float) aircraftAttitude.pitch;
+    attitudeInBodyCoordinate.roll = attitude->roll - (float) aircraftAttitude.roll;
+    attitudeInBodyCoordinate.yaw = attitude->yaw - (float) aircraftAttitude.yaw;
+
+    // modify attitude based on final angle limit
+    attitudeInBodyCoordinate.pitch = USER_UTIL_MIN(attitudeInBodyCoordinate.pitch,
+                                                   (float) finalAngleLimitInBodyCoordinateMax.pitch);
+    attitudeInBodyCoordinate.pitch = USER_UTIL_MAX(attitudeInBodyCoordinate.pitch,
+                                                   (float) finalAngleLimitInBodyCoordinateMin.pitch);
+    attitudeInBodyCoordinate.roll = USER_UTIL_MIN(attitudeInBodyCoordinate.roll,
+                                                  (float) finalAngleLimitInBodyCoordinateMax.roll);
+    attitudeInBodyCoordinate.roll = USER_UTIL_MAX(attitudeInBodyCoordinate.roll,
+                                                  (float) finalAngleLimitInBodyCoordinateMin.roll);
+    attitudeInBodyCoordinate.yaw = USER_UTIL_MIN(attitudeInBodyCoordinate.yaw,
+                                                 (float) finalAngleLimitInBodyCoordinateMax.yaw);
+    attitudeInBodyCoordinate.yaw = USER_UTIL_MAX(attitudeInBodyCoordinate.yaw,
+                                                 (float) finalAngleLimitInBodyCoordinateMin.yaw);
+
+    // calculate gimbal attitude in ground coordinate
+    attitude->pitch = attitudeInBodyCoordinate.pitch + (float) aircraftAttitude.pitch;
+    attitude->roll = attitudeInBodyCoordinate.roll + (float) aircraftAttitude.roll;
+    attitude->yaw = attitudeInBodyCoordinate.yaw + (float) aircraftAttitude.yaw;
+
+    // calculate reach limit flag, please note reach limit flag only specifies whether gimbal attitude reach joint angle limit
+    if (reachLimitFlag != NULL) {
+        reachLimitFlag->pitch = (attitudeInBodyCoordinate.pitch >= s_jointAngleLimitMax.pitch ||
+                                 attitudeInBodyCoordinate.pitch <= s_jointAngleLimitMin.pitch) ? true : false;
+        reachLimitFlag->roll = (attitudeInBodyCoordinate.roll >= s_jointAngleLimitMax.roll ||
+                                attitudeInBodyCoordinate.roll <= s_jointAngleLimitMin.roll) ? true : false;
+        reachLimitFlag->yaw = (attitudeInBodyCoordinate.yaw >= s_jointAngleLimitMax.yaw ||
+                               attitudeInBodyCoordinate.yaw <= s_jointAngleLimitMin.yaw) ? true : false;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/**
+ * @brief
+ * @param originalAttitude: unit: 0.1degree.
+ * @param targetAttitude: unit: 0.1degree.
+ * @param actionTime: unit: 0.01s.
+ * @param speed: unit: 0.1degree/s.
+ * @return
+ */
+static T_GduReturnCode
+GduTest_GimbalCalculateSpeed(T_GduAttitude3d originalAttitude, T_GduAttitude3d targetAttitude, uint16_t actionTime,
+                             T_GduAttitude3d *speed)
+{
+    float pitchSpeedTemp = 0;
+    float rollSpeedTemp = 0;
+    float yawSpeedTemp = 0;
+
+    if (speed == NULL) {
+        USER_LOG_ERROR("input pointer is null.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
+    pitchSpeedTemp = (float) (targetAttitude.pitch - originalAttitude.pitch) / (float) actionTime * 100;
+    rollSpeedTemp = (float) (targetAttitude.roll - originalAttitude.roll) / (float) actionTime * 100;
+    yawSpeedTemp = (float) (targetAttitude.yaw - originalAttitude.yaw) / (float) actionTime * 100;
+
+    speed->pitch = pitchSpeedTemp >= 0.0f ? (int32_t) (pitchSpeedTemp + 1) : (int32_t) (pitchSpeedTemp - 1);
+    speed->roll = rollSpeedTemp >= 0.0f ? (int32_t) (rollSpeedTemp + 1) : (int32_t) (rollSpeedTemp - 1);
+    speed->yaw = yawSpeedTemp >= 0.0f ? (int32_t) (yawSpeedTemp + 1) : (int32_t) (yawSpeedTemp - 1);
+
+    GduTest_GimbalSpeedLegalization(speed);
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+static void GduTest_GimbalSpeedLegalization(T_GduAttitude3d *speed)
+{
+    speed->pitch = speed->pitch > s_speedLimit.pitch ? s_speedLimit.pitch : speed->pitch;
+    speed->roll = speed->roll > s_speedLimit.roll ? s_speedLimit.roll : speed->roll;
+    speed->yaw = speed->yaw > s_speedLimit.yaw ? s_speedLimit.yaw : speed->yaw;
+
+    speed->pitch = speed->pitch < (0 - s_speedLimit.pitch) ? (0 - s_speedLimit.pitch) : speed->pitch;
+    speed->roll = speed->roll < (0 - s_speedLimit.roll) ? (0 - s_speedLimit.roll) : speed->roll;
+    speed->yaw = speed->yaw < (0 - s_speedLimit.yaw) ? (0 - s_speedLimit.yaw) : speed->yaw;
+}
+
+#if 0
+/**
+ * @brief
+ * @param quaternion
+ * @param attitude Unit: 0.1 degree.
+ * @return
+ */
+static T_GduReturnCode GduTest_GimbalCalculateGroundAttitudeBaseQuaternion(T_GduFcSubscriptionQuaternion quaternion,
+                                                                           T_GduAttitude3d *attitude)
+{
+    double aircraftPitchInRad;
+    double aircraftRollInRad;
+    double aircraftYawInRad;
+
+    if (attitude == NULL) {
+        USER_LOG_ERROR("Input argument is null.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
+    aircraftPitchInRad = asin(2 * ((double) quaternion.q0 * quaternion.q2 - (double) quaternion.q3 * quaternion.q1));
+    attitude->pitch = aircraftPitchInRad * 180 / GDU_PI * 10;
+
+    aircraftRollInRad = atan2(2 * ((double) quaternion.q0 * quaternion.q1 + (double) quaternion.q2 * quaternion.q3),
+                              (double) 1 -
+                              2 * ((double) quaternion.q1 * quaternion.q1 + (double) quaternion.q2 * quaternion.q2));
+    attitude->roll = aircraftRollInRad * 180 / GDU_PI * 10;
+
+    aircraftYawInRad = atan2(2 * ((double) quaternion.q0 * quaternion.q3 + (double) quaternion.q1 * quaternion.q2),
+                             (double) 1 -
+                             2 * ((double) quaternion.q2 * quaternion.q2 + (double) quaternion.q3 * quaternion.q3));
+    attitude->yaw = aircraftYawInRad * 180 / GDU_PI * 10;
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+#endif
+
+/****************** (C) COPYRIGHT GDU Innovations *****END OF FILE****/

+/**
+ ********************************************************************
+ * @file    test_payload_gimbal_emu.h
+ * @brief   This is the header file for "test_payload_gimbal_emu.c", defining the structure and
+ * (exported) function prototypes.
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef TEST_PAYLOAD_GIMBAL_EMU_H
+#define TEST_PAYLOAD_GIMBAL_EMU_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "gdu_typedef.h"
+#include "gdu_gimbal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Exported constants --------------------------------------------------------*/
+
+
+/* Exported types ------------------------------------------------------------*/
+
+
+/* Exported functions --------------------------------------------------------*/
+T_GduReturnCode GduTest_GimbalStartService(void);
+
+T_GduReturnCode GduTest_GimbalDeInit(void);
+T_GduReturnCode GduTest_GimbalRotate(E_GduGimbalRotationMode rotationMode,
+                                     T_GduGimbalRotationProperty rotationProperty,
+                                     T_GduAttitude3d rotationValue); // unit if angle control: 0.1 degree, unit if speed control: 0.1 degree/s
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TEST_PAYLOAD_GIMBAL_EMU_H
+
+/************************ (C) COPYRIGHT GDU Innovations *******END OF FILE******/

+/**
+ ********************************************************************
+ * @file    test_hms.c
+ * @brief
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Includes ------------------------------------------------------------------*/
+#include "test_hms.h"
+#include "gdu_hms.h"
+#include "gdu_hms_info_table.h"
+#include "gdu_logger.h"
+#include "gdu_platform.h"
+#include "gdu_fc_subscription.h"
+
+/* Private constants ---------------------------------------------------------*/
+#define MAX_HMS_PRINT_COUNT 150
+#define MAX_BUFFER_LEN 256
+#define MIN_HMS_ERROR_LEVEL 0
+#define MID_HMS_ERROR_LEVEL 3
+#define MAX_HMS_ERROR_LEVEL 6
+/* Private types -------------------------------------------------------------*/
+
+/* Private values -------------------------------------------------------------*/
+static const char *oldReplaceAlarmIdStr = "%alarmid";
+static const char *oldReplaceIndexStr = "%index";
+static const char *oldReplaceComponentIndexStr = "%component_index";
+
+/* Private functions declaration ---------------------------------------------*/
+static T_GduReturnCode GduTest_HmsInit(void);
+static T_GduReturnCode GduTest_HmsDeInit(void);
+static T_GduFcSubscriptionFlightStatus GduTest_GetValueOfFlightStatus(void);
+static bool GduTest_ReplaceStr(char *buffer, uint32_t bufferMaxLen, const char *target, const char *dest);
+static bool GduTest_MarchErrCodeInfoTable(T_GduHmsInfoTable hmsInfoTable);
+static T_GduReturnCode GduTest_HmsInfoCallback(T_GduHmsInfoTable hmsInfoTable);
+
+/* Exported functions definition ---------------------------------------------*/
+T_GduReturnCode GduTest_HmsRunSample(void)
+{
+    T_GduReturnCode returnCode;
+    T_GduOsalHandler *osalHandler;
+
+    USER_LOG_INFO("Hms Sample Start");
+    GduTest_WidgetLogAppend("Hms Sample Start");
+
+    USER_LOG_INFO("--> Step 1: Init hms sample");
+    GduTest_WidgetLogAppend("--> Step 1: Init hms sample");
+    returnCode = GduTest_HmsInit();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Hms sample init error, error code:0x%08llX", returnCode);
+        goto out;
+    }
+
+    osalHandler = GduPlatform_GetOsalHandler();
+    USER_LOG_INFO("--> Step 2: Register callback function of push HMS information");
+    GduTest_WidgetLogAppend("--> Step 2: Register callback function of push HMS information");
+    returnCode = GduHms_RegHmsInfoCallback(GduTest_HmsInfoCallback);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Register callback function of push HMS information failed, error code:0x%08llX", returnCode);
+        goto out;
+    }
+	else
+	{
+		return returnCode;
+	}
+
+    //osalHandler->TaskSleepMs(10000);
+
+out:
+    USER_LOG_INFO("--> Step 3: Deinit hms sample");
+    GduTest_WidgetLogAppend("--> Step 3: Deinit hms sample");
+    returnCode = GduTest_HmsDeInit();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Hms sample deinit error, error code:0x%08llX", returnCode);
+    }
+
+    USER_LOG_INFO("Hms Sample End");
+    GduTest_WidgetLogAppend("Hms Sample End");
+
+    return returnCode;
+}
+
+/* Private functions definition-----------------------------------------------*/
+static T_GduReturnCode GduTest_HmsInit(void)
+{
+    T_GduReturnCode returnCode;
+
+    returnCode = GduFcSubscription_Init();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Hms sample init data subscription module failed, error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    /*! subscribe fc data */
+    returnCode = GduFcSubscription_SubscribeTopic(GDU_FC_SUBSCRIPTION_TOPIC_STATUS_FLIGHT,
+                                                  GDU_DATA_SUBSCRIPTION_TOPIC_10_HZ,
+                                                  NULL);
+
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("HMS sample subscribe topic flight status error, error code:0x%08llX", returnCode);
+        return returnCode;
+    }
+
+    return GduHms_Init();
+}
+
+static T_GduReturnCode GduTest_HmsDeInit(void)
+{
+    T_GduReturnCode returnCode;
+
+    returnCode = GduFcSubscription_DeInit();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Deinit data subscription module failed, error code:0x%08llX",
+                       returnCode);
+        return returnCode;
+    }
+
+    return GduHms_DeInit();
+}
+
+static T_GduFcSubscriptionFlightStatus GduTest_GetValueOfFlightStatus(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduFcSubscriptionFlightStatus flightStatus;
+    T_GduDataTimestamp flightStatusTimestamp = {0};
+
+    gduStat = GduFcSubscription_GetLatestValueOfTopic(GDU_FC_SUBSCRIPTION_TOPIC_STATUS_FLIGHT,
+                                                      (uint8_t *) &flightStatus,
+                                                      sizeof(T_GduFcSubscriptionFlightStatus),
+                                                      &flightStatusTimestamp);
+
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get value of topic flight status failed, error code:0x%08llX", gduStat);
+        flightStatus = 0;
+    } else {
+        USER_LOG_DEBUG("Timestamp: millisecond %u microsecond %u.", flightStatusTimestamp.millisecond,
+                       flightStatusTimestamp.microsecond);
+        USER_LOG_DEBUG("Flight status: %d.", flightStatus);
+    }
+
+    return flightStatus;
+}
+
+static bool GduTest_ReplaceStr(char *buffer, uint32_t bufferMaxLen, const char *target, const char *dest)
+{
+    char printBuffHeader[MAX_BUFFER_LEN] = {0};
+    uint32_t printBuffHeaderCpyCnt = 0;
+    char printBuffTail[MAX_BUFFER_LEN] = {0};
+    uint32_t printBuffTailCpyCnt = 0;
+    char *targetOffset = NULL;
+
+    targetOffset = strstr(buffer, target);
+    if (!targetOffset) {
+        return false;
+    }
+
+    printBuffHeaderCpyCnt = targetOffset - buffer;
+    if (printBuffHeaderCpyCnt > sizeof(printBuffHeader)) {
+        printBuffHeaderCpyCnt = sizeof(printBuffHeader);
+    }
+    memcpy(printBuffHeader, buffer, printBuffHeaderCpyCnt);
+
+    printBuffTailCpyCnt = strlen(targetOffset + strlen(target));
+    if (printBuffTailCpyCnt > sizeof(printBuffTail)) {
+        printBuffTailCpyCnt = sizeof(printBuffTail);
+    }
+    memcpy(printBuffTail, targetOffset + strlen(target), printBuffTailCpyCnt);
+
+    snprintf(buffer, bufferMaxLen, "%s%s%s", printBuffHeader, dest, printBuffTail);
+    return true;
+}
+
+
+static bool GduTest_MarchErrCodeInfoTable(T_GduHmsInfoTable hmsInfoTable)
+{
+    char alarmIdStr[20] = {0};
+    char sensorIdStr[20] = {0};
+    char componentIdStr[20] = {0};
+    char printBuff[256] = {0};
+    const char *originalAlarmInfo = NULL;
+    uint8_t hmsCodeMatchFlag = 0;
+
+    if (!hmsInfoTable.hmsInfo) {
+        USER_LOG_ERROR("Hms info table is null");
+        return false;
+    }
+
+    for (int i = 0; i < hmsInfoTable.hmsInfoNum; i++) {
+        hmsCodeMatchFlag = 0;
+        for (int j = 0; j < sizeof(hmsErrCodeInfoTbl) / sizeof(T_GduHmsErrCodeInfo); j++) {
+            if (hmsInfoTable.hmsInfo[i].errorCode == hmsErrCodeInfoTbl[j].alarmId) {
+                hmsCodeMatchFlag = 1;
+                snprintf(alarmIdStr, sizeof(alarmIdStr), "%u", hmsInfoTable.hmsInfo[i].errorCode);
+                //note:sensor_idx:[0,5].In order to be consistent with the display of pilot, add one.
+                snprintf(sensorIdStr, sizeof(sensorIdStr), "%d", hmsInfoTable.hmsInfo[i].componentIndex + 1);
+                snprintf(componentIdStr, sizeof(componentIdStr), "0x%02X", hmsInfoTable.hmsInfo[i].componentIndex + 1);
+                if (GduTest_GetValueOfFlightStatus() == GDU_FC_SUBSCRIPTION_FLIGHT_STATUS_IN_AIR) {
+                    originalAlarmInfo = hmsErrCodeInfoTbl[j].flyAlarmInfo;
+                } else {
+                    originalAlarmInfo = hmsErrCodeInfoTbl[j].groundAlarmInfo;
+                }
+                originalAlarmInfo = hmsErrCodeInfoTbl[j].groundAlarmInfo;
+                if (strlen(originalAlarmInfo)) {
+                    snprintf(printBuff, sizeof(printBuff), "%s", originalAlarmInfo);
+                    GduTest_ReplaceStr(printBuff, sizeof(printBuff), oldReplaceAlarmIdStr, alarmIdStr);
+                    GduTest_ReplaceStr(printBuff, sizeof(printBuff), oldReplaceIndexStr, sensorIdStr);
+                    GduTest_ReplaceStr(printBuff, sizeof(printBuff), oldReplaceComponentIndexStr, componentIdStr);
+                    if (hmsInfoTable.hmsInfo[i].errorLevel > MIN_HMS_ERROR_LEVEL &&
+                        hmsInfoTable.hmsInfo[i].errorLevel < MID_HMS_ERROR_LEVEL) {
+                        USER_LOG_WARN("[ErrorCode:0x%2x] %s", hmsInfoTable.hmsInfo[i].errorCode, printBuff);
+                    } else if (hmsInfoTable.hmsInfo[i].errorLevel >= MID_HMS_ERROR_LEVEL &&
+                               hmsInfoTable.hmsInfo[i].errorLevel < MAX_HMS_ERROR_LEVEL) {
+                        USER_LOG_ERROR("[ErrorCode:0x%2x] %s", hmsInfoTable.hmsInfo[i].errorCode, printBuff);
+                    }
+                }
+            }
+        }
+        if (!hmsCodeMatchFlag) {
+            USER_LOG_WARN("[ErrorCode:0x%2x] There are no matching documents in the current hmsErrCodeInfoTbl for now.",
+                          hmsInfoTable.hmsInfo[i].errorCode);
+        }
+    }
+
+    return true;
+}
+
+static T_GduReturnCode GduTest_HmsInfoCallback(T_GduHmsInfoTable hmsInfoTable)
+{
+    if (!GduTest_MarchErrCodeInfoTable(hmsInfoTable)) {
+        USER_LOG_ERROR("March HMS Information failed.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (hmsInfoTable.hmsInfoNum == 0) {
+        USER_LOG_INFO("All systems of drone are running well now.");
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/****************** (C) COPYRIGHT GDU Innovations *****END OF FILE****/

+/**
+ ********************************************************************
+ * @file    test_hms.h
+ * @brief   This is the header file for "test_hms.c", defining the structure and
+ * (exported) function prototypes.
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef TEST_HMS_H
+#define TEST_HMS_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "gdu_typedef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Exported constants --------------------------------------------------------*/
+
+/* Exported types ------------------------------------------------------------*/
+
+/* Exported functions --------------------------------------------------------*/
+T_GduReturnCode GduTest_HmsRunSample(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TEST_HMS_H
+/************************ (C) COPYRIGHT GDU Innovations *******END OF FILE******/

+/**
+ ********************************************************************
+ * @file    test_positioning.c
+ * @brief
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+
+/* Includes ------------------------------------------------------------------*/
+#include <fc_subscription/test_fc_subscription.h>
+#include "test_positioning.h"
+#include "gdu_positioning.h"
+#include "gdu_logger.h"
+#include "utils/util_misc.h"
+#include "gdu_platform.h"
+#include "time_sync/test_time_sync.h"
+
+/* Private constants ---------------------------------------------------------*/
+#define POSITIONING_TASK_FREQ                     (1)
+#define POSITIONING_TASK_STACK_SIZE               (2048)
+
+#define GDU_TEST_POSITIONING_EVENT_COUNT          (5)
+#define GDU_TEST_TIME_INTERVAL_AMONG_EVENTS_US    (1000)
+
+/* Private types -------------------------------------------------------------*/
+
+
+/* Private functions declaration ---------------------------------------------*/
+static void *GduTest_PositioningTask(void *arg);
+
+/* Private variables ---------------------------------------------------------*/
+static T_GduTaskHandle s_userPositioningThread;
+static int32_t s_eventIndex = 0;
+
+/* Exported functions definition ---------------------------------------------*/
+T_GduReturnCode GduTest_PositioningStartService(void)
+{
+    T_GduReturnCode gduStat;
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+
+    gduStat = GduPositioning_Init();
+    if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("positioning module init error.");
+        return gduStat;
+    }
+
+    USER_LOG_DEBUG("positioning start service");
+    GduPositioning_SetTaskIndex(0);
+
+    if (osalHandler->TaskCreate("user_positioning_task", GduTest_PositioningTask,
+                                POSITIONING_TASK_STACK_SIZE, NULL, &s_userPositioningThread) !=
+        GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("user positioning task create error.");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/* Private functions definition-----------------------------------------------*/
+#ifndef __CC_ARM
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-noreturn"
+#pragma GCC diagnostic ignored "-Wreturn-type"
+#endif
+
+static void *GduTest_PositioningTask(void *arg)
+{
+    int32_t i = 0;
+    T_GduReturnCode gduStat;
+    uint64_t ppsNewestTriggerTimeUs = 0;
+	uint64_t posTime = 0;
+    uint32_t currentTimeMs = 0;
+	uint64_t currentTimeUs = 0;
+    T_GduPositioningEventInfo eventInfo[GDU_TEST_POSITIONING_EVENT_COUNT] = {0};
+    T_GduPositioningPositionInfo positionInfo[GDU_TEST_POSITIONING_EVENT_COUNT] = {0};
+    T_GduTimeSyncAircraftTime aircraftTime = {0};
+    T_GduOsalHandler *osalHandler = GduPlatform_GetOsalHandler();
+    uint8_t totalSatelliteNumber = 0;
+	uint32_t beforeTime = 0, afterTime = 0;
+
+    USER_UTIL_UNUSED(arg);
+
+    while (1) {
+        osalHandler->TaskSleepMs(1000 / POSITIONING_TASK_FREQ);
+
+        gduStat = GduTest_FcSubscriptionGetTotalSatelliteNumber(&totalSatelliteNumber);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get total satellite number error: 0x%08llX.", gduStat);
+            continue;
+        }
+
+        gduStat = GduTest_TimeSyncGetNewestPpsTriggerLocalTimeUs(&ppsNewestTriggerTimeUs);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get newest pps trigger time error: 0x%08llX.", gduStat);
+            continue;
+        }
+
+        gduStat = osalHandler->GetTimeMs(&currentTimeMs);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get current time error: 0x%08llX.", gduStat);
+            continue;
+        }
+
+        for (i = 0; i < GDU_TEST_POSITIONING_EVENT_COUNT; ++i) {
+            eventInfo[i].eventSetIndex = s_eventIndex;
+            eventInfo[i].targetPointIndex = i;
+
+			currentTimeUs = ((uint64_t)currentTimeMs - (i+1) * 300) * 1000;
+            gduStat = GduTimeSync_TransferToAircraftTime(currentTimeUs, &aircraftTime);
+            if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+                USER_LOG_ERROR("transfer to aircraft time error: 0x%08llX.", gduStat);
+                continue;
+            }
+
+            eventInfo[i].eventTime = aircraftTime;
+        }
+
+        gduStat = GduPositioning_GetPositionInformationSync(GDU_TEST_POSITIONING_EVENT_COUNT, eventInfo, positionInfo);
+        if (gduStat != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+            USER_LOG_ERROR("get position information error. error code is 0x%08llX", gduStat);
+            continue;
+        }
+
+        USER_LOG_DEBUG("request position of target points success.");
+        USER_LOG_DEBUG("detail position information:*************");
+        for (i = 0; i < GDU_TEST_POSITIONING_EVENT_COUNT; ++i) {
+            USER_LOG_DEBUG("position solution property: %d. eventTime:(%d-%d-%d %d:%d:%d:%d)", positionInfo[i].positionSolutionProperty, eventInfo[i].eventTime.year, eventInfo[i].eventTime.month, eventInfo[i].eventTime.day, \
+																								eventInfo[i].eventTime.hour, eventInfo[i].eventTime.minute , eventInfo[i].eventTime.second, eventInfo[i].eventTime.microsecond);
+//            USER_LOG_DEBUG("pitchAttitudeAngle: %d\trollAttitudeAngle: %d\tyawAttitudeAngle: %d",
+//                           positionInfo[i].uavAttitude.pitch, positionInfo[i].uavAttitude.roll,
+//                           positionInfo[i].uavAttitude.yaw);
+//            USER_LOG_DEBUG("northPositionOffset: %d\tearthPositionOffset: %d\tdownPositionOffset: %d",
+//                           positionInfo[i].offsetBetweenMainAntennaAndTargetPoint.x,
+//                           positionInfo[i].offsetBetweenMainAntennaAndTargetPoint.y,
+//                           positionInfo[i].offsetBetweenMainAntennaAndTargetPoint.z);
+           USER_LOG_DEBUG("longitude: %.8f\tlatitude: %.8f\theight: %.8f",
+                          positionInfo[i].targetPointPosition.longitude,
+                          positionInfo[i].targetPointPosition.latitude,
+                           positionInfo[i].targetPointPosition.height);
+//            USER_LOG_DEBUG(
+//                "longStandardDeviation: %.8f\tlatStandardDeviation: %.8f\thgtStandardDeviation: %.8f",
+//                positionInfo[i].targetPointPositionStandardDeviation.longitude,
+//                positionInfo[i].targetPointPositionStandardDeviation.latitude,
+//                positionInfo[i].targetPointPositionStandardDeviation.height);
+        }
+		
+        s_eventIndex++;
+    }
+}
+
+#ifndef __CC_ARM
+#pragma GCC diagnostic pop
+#endif
+
+/****************** (C) COPYRIGHT GDU Innovations *****END OF FILE****/

+/**
+ ********************************************************************
+ * @file    test_positioning.h
+ * @brief   This is the header file for "test_positioning.c", defining the structure and
+ * (exported) function prototypes.
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef TEST_POSITIONING_H
+#define TEST_POSITIONING_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "gdu_typedef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Exported constants --------------------------------------------------------*/
+
+
+/* Exported types ------------------------------------------------------------*/
+
+
+/* Exported functions --------------------------------------------------------*/
+T_GduReturnCode GduTest_PositioningStartService(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TEST_POSITIONING_H
+
+/************************ (C) COPYRIGHT GDU Innovations *******END OF FILE******/

+/**
+ ********************************************************************
+ * @file    test_power_management.c
+ * @brief
+ *
+ * @copyright (c) 2021 GDU. All rights reserved.
+ *
+ * All information contained herein is, and remains, the property of GDU.
+ * The intellectual and technical concepts contained herein are proprietary
+ * to GDU and may be covered by U.S. and foreign patents, patents in process,
+ * and protected by trade secret or copyright law.  Dissemination of this
+ * information, including but not limited to data and other proprietary
+ * material(s) incorporated within the information, in any form, is strictly
+ * prohibited without the express written consent of GDU.
+ *
+ * If you receive this source code without GDU’s authorization, you may not
+ * further disseminate the information, and you must immediately remove the
+ * source code and notify GDU of its removal. GDU reserves the right to pursue
+ * legal actions against you for any loss(es) or damage(s) caused by your
+ * failure to do so.
+ *
+ *********************************************************************
+ */
+
+
+/* Includes ------------------------------------------------------------------*/
+#include "test_power_management.h"
+#include "gdu_logger.h"
+#include "gdu_aircraft_info.h"
+
+/* Private constants ---------------------------------------------------------*/
+
+/* Private types -------------------------------------------------------------*/
+
+/* Private functions declaration ---------------------------------------------*/
+static T_GduReturnCode GduTest_PowerOffNotificationCallback(bool *powerOffPreparationFlag);
+
+/* Private variables ---------------------------------------------------------*/
+static T_GduTestApplyHighPowerHandler s_applyHighPowerHandler;
+
+/* Exported functions definition ---------------------------------------------*/
+/**
+ * @brief Register handler function for applying high power. This function have to be called before calling
+ * GduTest_PowerManagementInit(), except for in Linux, because GduTest_PowerManagementInit() do not apply high power
+ * in Linux OS.
+ * @param applyHighPowerHandler: pointer to handler function for applying high power.
+ * @return Execution result.
+ */
+T_GduReturnCode GduTest_RegApplyHighPowerHandler(T_GduTestApplyHighPowerHandler *applyHighPowerHandler)
+{
+    if (applyHighPowerHandler->pinInit == NULL) {
+        USER_LOG_ERROR("reg apply high power handler pinInit error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
+    if (applyHighPowerHandler->pinWrite == NULL) {
+        USER_LOG_ERROR("reg apply high power handler pinWrite error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
+    }
+
+    memcpy(&s_applyHighPowerHandler, applyHighPowerHandler, sizeof(T_GduTestApplyHighPowerHandler));
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/**
+ * @brief Initialise power management module, including apply high power (only RTOS) and register power off notification
+ * callback function.
+ * @note GDU development board 1.0 can not accept high power, so do not call this function in GDU development board
+ * 1.0 project.
+ * @return Execution result.
+ */
+T_GduReturnCode GduTest_PowerManagementStartService(void)
+{
+    T_GduReturnCode returnCode;
+    T_GduAircraftInfoBaseInfo baseInfo = {0};
+
+    returnCode = GduPowerManagement_Init();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("power management init error: 0x%08llX.", returnCode);
+        return returnCode;
+    }
+
+    returnCode = GduAircraftInfo_GetBaseInfo(&baseInfo);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("Get aircraft base info error: 0x%08llX.", returnCode);
+        return returnCode;
+    }
+    
+    // register power off notification callback function
+    returnCode = GduPowerManagement_RegPowerOffNotificationCallback(GduTest_PowerOffNotificationCallback);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("register power off notification callback function error");
+        return returnCode;
+    }
+
+    // apply high power
+    if (s_applyHighPowerHandler.pinInit == NULL) {
+        USER_LOG_ERROR("apply high power pin init interface is NULL error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    if (s_applyHighPowerHandler.pinWrite == NULL) {
+        USER_LOG_ERROR("apply high power pin write interface is NULL error");
+        return GDU_ERROR_SYSTEM_MODULE_CODE_UNKNOWN;
+    }
+
+    returnCode = s_applyHighPowerHandler.pinInit();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("apply high power pin init error");
+        return returnCode;
+    }
+
+    returnCode = GduPowerManagement_RegWriteHighPowerApplyPinCallback(s_applyHighPowerHandler.pinWrite);
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("register WriteHighPowerApplyPinCallback error.");
+        return returnCode;
+    }
+
+    returnCode = GduPowerManagement_ApplyHighPowerSync();
+    if (returnCode != GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS) {
+        USER_LOG_ERROR("apply high power error");
+        return returnCode;
+    }
+	else
+	{
+		USER_LOG_DEBUG("apply high power success");
+	}
+
+   
+
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/* Private functions definition-----------------------------------------------*/
+static T_GduReturnCode GduTest_PowerOffNotificationCallback(bool *powerOffPreparationFlag)
+{   
+      T_GduReturnCode gduStat;
+    USER_LOG_INFO("----------------------------------------aircraft will power off soon.");
+   
+     usleep(4500*1000);
+    *powerOffPreparationFlag = true;
+    
+     
+    return GDU_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
+}
+
+/****************** (C) COPYRIGHT GDU Innovations *****END OF FILE****/