review comments updated

docs/_sidebar.md

@@ -9,11 +9,12 @@
 - [**Quick Start**](quick_start/overview.md)
 
   - [Configuring RoCS for Simulated Robot](quick_start/setup_for_simulated_robot.md)
-  - [Configuring RoCS for Physical Robot.](quick_start/setup_for_physical_robot.md)
-- [**Client_SDK Reference Guide**](client_sdk/overview.md)
+  - [Configuring RoCS for Physical Robot](quick_start/setup_for_physical_robot.md)
+- [**SDK Reference Guide**](client_sdk/overview.md)
 
-  - [Python](https://fftai.github.io/rocs_client_py/index.html)
-  - [Nodejs](https://fftai.github.io/rocs_client_js/index.html)
+  - [Client Python](https://fftai.github.io/rocs_client_py/index.html)
+  - [Client JavaScript/TypeScript](https://fftai.github.io/rocs_client_js/index.html)
+  - [Server API](https://fftai.github.io/server_api/RoCS_Server_API.html)
 - [**Remote Control App Developer Guide**](demo_app/overview.md)
 
   - [Connecting to Robot](demo_app/connnecting_to_robot.md)
@@ -22,7 +23,6 @@
     - [Controlling Robot Movements](demo_app/control_robot_movements.md)
     - [Accessing and Modifying Settings](demo_app/settings.md)
   - [Build Your Own Remote Control App](demo_app/app_project_setup.md)
-- [**Server API**](server_api/ServerAPI.md)
 - [**Autonomy**](autonomy/overview.md)
 - [**Motion Library**](motion_library/overview.md)
 
@@ -35,7 +35,9 @@
   - [Tremble Fingers](motion_library/tremble_fingers.md)
 - [**Release Notes**](release/overview.md)
 
-  - [Release V0.1](release/v0.1.md)
-  - [Release V0.2](release/v0.2.md)
+  - [Release V1.3](release/v1.3.md)
+  - [Release V1.2](release/v1.2.md)
   - [Release V1.1](release/v1.1.md)
+  - [Release V0.2](release/v0.2.md)
+  - [Release V0.1](release/v0.1.md)
 - [**Feedback**](feedback/overview.md)

docs/client_sdk/overview.md

@@ -1,7 +1,7 @@
 # Overview
 
-The SDK operates based on the concept of encapsulation, neatly organizing essential robot functions into separate classes, each equipped with specialized methods. Developers can make use of these encapsulated capabilities through provided interfaces, making it easy to create customized applications seamlessly. Whether you need to fine-tune low-level motor operations, coordinate complex high-level motion sequences, manage audio/video transmission, implement SLAM for mapping, or monitor odometry, the SDK's modular structure ensures flexibility and simplicity for developers to customize their solutions.
+The SDK operates based on the concept of encapsulation, neatly organizing essential robot functions into separate classes, each equipped with specialized methods. Developers can make use of these encapsulated capabilities through provided interfaces, making it easy to create customized applications seamlessly. Whether you need to fine-tune low-level motor operations, coordinate complex high-level motion sequences, manage audio/video transmission, implement SLAM for mapping, or monitor odometry, the SDK's modular structure ensures flexibility and simplicity for developers to customize your solutions.
 
 This reference guide is designed to assist you in navigating the various modules and classes, demonstrating how they can be effectively employed in application development. It serves as a fundamental resource for developers.
 
-!> Please note that we assume you have already installed your preferred SDK packages. If you haven't done so yet, please refer to [Setting Up Python Client SDK](quick_start/setup_for_physical_robot?id=setting-up-python-client-sdk) or [Setting Up JavaScript/TypeScript Client SDK](quick_start/setup_for_physical_robot?id=setting-up-javascripttypescript-client-sdk) section for installation instructions.
+!> Please note that we assume you have already installed your preferred language SDK package. If you haven't done so yet, please refer to [Setting Up Python Client SDK](quick_start/setup_for_physical_robot?id=setting-up-python-client-sdk) or [Setting Up JavaScript/TypeScript Client SDK](quick_start/setup_for_physical_robot?id=setting-up-javascripttypescript-client-sdk) section for installation instructions.

docs/client_sdk/understanding.md

@@ -6,13 +6,13 @@ This guide will help you understand the programming principles that drive the ro
 
 ### Understanding the "IP"
 
-The IP address of the GR-1 robot is used to uniquely identify and locate the robot on a network. The IP address allows other devices or applications to send data, commands, or requests to the GR-1 robot and receive responses in return. It is a fundamental component for establishing network connectivity and enabling communication with the GR-1 robot.
+The IP address of the GR robot is used to uniquely identify and locate the robot on a network. The IP address allows other devices or applications to send data, commands, or requests to the GR robot and receive responses in return. It is a fundamental component for establishing network connectivity and enabling communication with the GR robot.
 
 For how to configure the IP and set up connection to the robot, refer to chapter [Network Communication](https://fftai.github.io/#/networking?id=network-communication).
 
-## How to Setup and Command GR-1 to Move
+## How to Setup and Command GR Robot to Move
 
-To gain a fundamental understanding of how to command GR-1 robot, follow these steps:
+To gain a fundamental understanding of how to command GR robot, follow these steps:
 
 1. **Open a Python Interpreter:** Start by launching a Python interpreter in your preferred environment. Ensure that you have Python installed on your system.
    ```python

docs/concepts/faults.md

@@ -20,21 +20,27 @@ If the upper limb posture appears abnormal or if the motors have been replaced,
    ![1703213432655](image/operation_instruction/1703213432655.png)![1703213495926](image/operation_instruction/1703213495926.png)
 3. Connect the embedded robot computer to a monitor through the extension dock. Plug in a keyboard and a mouse into the extension dock as well.
 4. Release the Emergency Stop switch and power on the embedded robot computer. The login password is `fftai2015`.
-5. Open a terminal and input the following command:
-
-   ```powershell
-   cd ~/Documents/server_app/bin/pythonscripts/
-   python3 abs_run.py
-
-   ```
-   If prompted with `get abs angle complete!`, it indicates successful completion.
-   6.Run the following commands:
-
-   ```powershell
-   python3 checkabsjson.py
-   python3 setmotorzeropos.py
-   ```
-   If prompted with `Set Motor Zero Position Success`, it signifies successful zero-point setting.
-6. Shut down the embedded robot computer.
-7. Press down the Emergency Stop switch.
-8. Remove the calibration tools. Ensure that all calibration tools have been removed before proceeding with other operations.
+
+5. Open a terminal and do the following:
+
+   Run the following command:
+
+      ```powershell
+      cd ~/Documents/server_app/bin/pythonscripts/
+      python3 abs_run.py
+
+      ```
+
+      If prompted with `get abs angle complete!`, it indicates  getting absolute angle successfully.
+
+   Run the following commands:
+
+      ```powershell
+      python3 checkabsjson.py
+      python3 setmotorzeropos.py
+      ```
+
+      If prompted with `Set Motor Zero Position Success`, it signifies successful zero-point setting.
+5. Shut down the embedded robot computer.
+6. Press down the Emergency Stop switch.
+7. Remove the calibration tools. Ensure that all calibration tools have been removed before proceeding with other operations.

docs/concepts/network.md

@@ -32,9 +32,9 @@ async def connect_to_gr1():
 
     async with websockets.connect(uri) as websocket:
         # Perform WebSocket operations here
-        await websocket.send("Hello, GR-1!")
+        await websocket.send("Hello, GR!")
         response = await websocket.recv()
-        print(f"GR-1 says: {response}")
+        print(f"GR says: {response}")
 
 if __name__ == "__main__":
     asyncio.get_event_loop().run_until_complete(connect_to_gr1())

docs/concepts/overview.md

@@ -1,3 +1,12 @@
 # Overview
 
 In this section, we delve into the fundamental concepts of the RoCS and Fourier General Robot Series to facilitate your understanding. We explore topics like network configuration, software architecture, and the core operations of the robot, providing a solid foundation for your continued exploration of the subsequent sections.
+
+Following topics are covered:
+
+* [Introduction to Fourier GR Robot](concepts/about_gr1)
+* [Fourier GR Robot Operation Instruction](concepts/operation_instruction.md)
+* [Introduction to RoCS](concepts/about_rocs.md)
+* [Networking](concepts/network.md)
+* [Software Architecture](concepts/software_architecture.md)
+* [Troubleshooting](concepts/faults.md)

docs/demo_app/app_project_setup.md

@@ -20,16 +20,16 @@ Following topics are covered:
 
 To ensure a smooth development process, the following libraries and frameworks are essential:
 
-1. **Vue.js** : The core framework. Ensure you have the latest stable version.
-2. **Vuex** : For state management within Vue.js.
-3. **Vue Router** : For managing navigation within the application.
-4. **Axios** : For making HTTP requests to the API.
-5. **Node.js** : The runtime environment for executing JavaScript code server-side.
-6. **Webpack** : For module bundling.
-7. **Babel** : For JavaScript compilation.
-8. **ESLint** : For code linting and maintaining coding standards.
-9. **Jest** : For unit testing.
-10. **Sass** : For advanced styling capabilities.
+- **Vue.js** : The core framework. Ensure you have the latest stable version.
+- **Vuex** : For state management within Vue.js.
+- **Vue Router** : For managing navigation within the application.
+- **Axios** : For making HTTP requests to the API.
+- **Node.js** : The runtime environment for executing JavaScript code server-side.
+- **Webpack** : For module bundling.
+- **Babel** : For JavaScript compilation.
+- **ESLint** : For code linting and maintaining coding standards.
+- **Jest** : For unit testing.
+- **Sass** : For advanced styling capabilities.
 
 ### Environment Setup
 
@@ -90,19 +90,19 @@ To run the application locally:
 - Execute `npm run serve` in the terminal. This command starts a local development server.
 - The application will be hosted at `http://localhost:8080` by default. You can access it using a web browser.
 
-1. **Live Reloading** :
+2. **Live Reloading** :
 
 - The local server comes with hot-reloading. Any changes made to the source code will automatically refresh the application in the browser.
 
-1. **Accessing Application Features** :
+3. **Accessing Application Features** :
 
 - Test different features like robot control and system settings as they would function in the production environment.
 
-1. **Running Unit Tests** :
+4. **Running Unit Tests** :
 
 - Execute `npm run test` to run unit tests. This ensures your local changes haven't broken existing functionalities.
 
-1. **Linting Code** :
+5. **Linting Code** :
 
 - Run `npm run lint` to identify and fix linting issues, ensuring code consistency.
 
@@ -214,19 +214,19 @@ Vuex plays a pivotal role in maintaining the state of the application. The centr
 - Method: GET
 - Data Flow: Triggered in `RobotStartup.vue`, this API call starts the robot. The response is monitored to update the UI accordingly.
 
-1. **System Settings** :
+2. **System Settings** :
 
 - Endpoint: `/robot/control_svr_status`
 - Purpose: Checks the status of the robot server.
 - Method: GET
 - Usage: In `Login.vue`, this endpoint determines if the robot server is active before proceeding.
 
-1. **Shut Down Robot** :
+3. **Shut Down Robot** :
 
 - Endpoint: `/robot/control_svr_close`
 - Purpose: To shut down the robot server.
 - Method: GET
-- Implementation: Used in `RobotStartup.vue` to turn off the robot.
+- Implementation: Used in `RobotStartup.vue` and `Login.vue` to turn off the robot.
 
 # Data Flow
 
@@ -235,12 +235,12 @@ Vuex plays a pivotal role in maintaining the state of the application. The centr
 - The application starts with `Startup.vue`, displaying the initial logo and then navigating to `Login.vue`.
 - `Login.vue` checks the robot server status before allowing users to proceed.
 
-1. **Robot Operation Flow** :
+2. **Robot Operation Flow** :
 
 - `Controller.vue` takes user inputs for robot control. These inputs are sent to the robot through API calls.
 - Responses from the robot are received and processed to update the UI or handle errors.
 
-1. **Settings and Information** :
+3. **Settings and Information** :
 
 - `Setting.vue` fetches and displays system information and settings.
 - Users can update settings, and changes are sent to the server via API calls.

docs/demo_app/control_robot_movements.md

@@ -8,7 +8,7 @@ Following topics are covered:
   - [Gait Motion](#gait-motion)
   - [Stationary Motion](#stationary-motion)
   - [Stand Motion](#stand-motion)
-  - [End Effector Motion](#end-effector-motion)
+  - [Grasping Motion](#end-effector-motion)
 
 ## Gait Motion
 
@@ -49,14 +49,14 @@ To engage the robot in Stand Mode:
 
 !> Avoid keeping robot in the stand position for an extended period, as it can cause damage to ankle actuators due to overloading.
 
-## End Effector Motion
+## Grasping Motion
 
-End Effector Motion Mode introduces a specialized mode for controlling the robot's end effector grasping actions. This mode is designed for tasks involving object manipulation, adding a unique capability to the robot.
+Grasping motion mode introduces a specialized mode for controlling the robot's end effector grasping actions. This mode is designed for tasks involving object manipulation, adding a unique capability to the robot.
 
-To control the robot in End Effector Motion Mode:
+To control the robot in Grasping motion mode:
 
 1. Click `Start Exploring` in the Remote Control APP.
-2. Select End Effector Motion Mode.
+2. Select Grasping motion mode.
 
    ![1702625405510](image/control_robot_movements/1702625405510.png)
 3. Use the controls to command the robot's end effector, allowing for precise grasping actions.

docs/demo_app/login.md

@@ -1,6 +1,6 @@
 # Login Interface
 
-The login interface is a Vue.js component with interactive elements, including a header, an image of GR-1 robot, a `Start Exploring` button, and a prompt box appearing based on certain user interactions.
+The login interface is a Vue.js component with interactive elements, including a header, an image of GR robot, a `Start Exploring` button, and a prompt box appearing based on certain user interactions.
 
 It communicates with a Vuex store to retrieve and manage data related to the connection status and robot information. Users can initiate exploration and interact with the application through the provided UI elements.
 
@@ -34,7 +34,7 @@ The interaction between the `startExplore()` method, the `control_svr_status` me
 
 ### 3. Network Icon
 
-Indicates the connection to the GR-1 is sucessful.
+Indicates the connection to the GR is sucessful.
 
 ### 4. System Setting Icon
 

docs/demo_app/overview.md

@@ -6,8 +6,8 @@ The RoCS Control App is designed for developers seeking precise control over rob
 
 **Key Functions:**
 
-* **Remote Control**: Developers can effortlessly command the robot to execute a variety of actions, including walking, running, waving hands etc. The app offers a straightforward and intuitive interface for these basic remote control functionalities.
-* **User-Friendly Interface:** The app provides an intuitive graphical interface, streamlining interactions between developers and robotic systems. Developers can effortlessly control, monitor, and customize robot movements through a seamless interface.
+* **Remote Control**: Developers can effortlessly command the robot to execute a variety of actions, including walking, running, waving hands etc.
+* **User-Friendly Interface:** The app provides an intuitive graphical interface, streamlining interactions between developers and robotic systems. 
 * **Data View:** Real-time display of diverse sensor data is a core feature. This includes crucial information such as joint states and postions. The Data View feature enhances the developer's ability to monitor and fine-tune the robot's behavior in real-time.
 
 Unlike consumer-oriented products, this app is not designed for end-users; instead, it functions as an extensive reference. It provides detailed insights into the app's functionalities and the underlying logic that governs its operations.

docs/demo_app/overview_of_control_features.md

@@ -15,8 +15,8 @@ The fundamental movements are categorized into four modes:
 * **Gait Motion Mode:** In this mode, users can control the robot's forward, backward, left, and right movements, offering a dynamic and directional approach.
 * **Stationary Motion Mode:** Offering control over the robot's movements while stationed, this mode facilitates dynamic action demonstrations in a fixed position.
 * **Standing Mode:** The robot maintains a static standing posture in this mode, suitable for scenarios requiring a stationary robot presence.
-* **End Effector Motion Mode:** Introducing a specialized mode, users can engage the robot in end effector grasping actions, providing a unique capability for tasks involving object manipulation.
+* **Grasping Mode:** Introducing a specialized mode, users can engage the robot in end effector grasping actions, providing a unique capability for tasks involving object manipulation.
 
-Each mode serves distinct purposes, providing flexibility for various applications. The Gait Motion Mode facilitates directional movements, the Stationary Motion Mode allows for on-the-spot actions, and the Standing Mode maintains a static standing position. the End Effector MotionMode **e**xpands the robot's capabilities by allowing users to control additional end effector movements.
+Each mode serves distinct purposes, providing flexibility for various applications. The Gait Motion Mode facilitates directional movements, the Stationary Motion Mode allows for on-the-spot actions, and the Standing Mode maintains a static standing position. the Grasping  Motion Mode **e**xpands the robot's capabilities by allowing users to control additional end effector movements.
 
 These features enhance the user experience by offering a versatile range of control options, catering to both standard and advanced users' preferences.

docs/home_page.html

@@ -48,6 +48,12 @@
                 '/zh-cn/': '#/zh-cn/',
                 '/': '#/'
             },
+            pagination: {
+                previousText: 'Previous',
+                nextText: 'Next',
+                crossChapter: false,
+                crossChapterText: false,
+            },
             search: {
                 noData: {
                     '/es/': '¡No hay resultados!',
@@ -105,6 +111,8 @@
     <script src="//unpkg.com/docsify-router@latest"></script>
 
     <script src="//unpkg.com/docsify-sidebar-collapse/dist/docsify-sidebar-collapse.js"></script>
+    <script src="./style/pagination.js"></script>
+
     <script>
         document.querySelectorAll('.sidebar-nav a').forEach(function (link) {
             link.addEventListener('click', function () {

docs/motion_library/start.md

@@ -1,6 +1,6 @@
 # Start
 
-To activate the GR-1 robot and establish a connection, you can use the `start()` function from the `rocs_client` library.
+To activate the GR robot and establish a connection, you can use the `start()` function from the `rocs_client` library.
 
 The `start` method in the Motion Library initiates the remote control mode for the robot, allowing external systems or programs to send control commands to the robot. After calling `start`, it's advisable to wait for a brief period (e.g., 10 seconds) to allow the robot's control system to stabilize. Following the `start` call, you can issue various motion commands or control instructions to the robot.