add docs and fix some bug

README.md

@@ -2,46 +2,49 @@
 
 ### [![LOGO](./docs/source/_static/logo150x150.png)](https://github.com/kubeedge/robosdk)
 
+Welcome to RoboSDK, an open-source cloud-native robotics toolchain designed to empower developers in building cutting-edge robotics applications. This README provides an overview of the project and its objectives, guiding developers on how to get started, and encouraging community engagement.
 
-### What is RoboSDK
+**Table of Contents**
+1. [Introduction](#introduction)
+2. [Features](#features)
+3. [Architecture](#architecture)
+4. [Getting Started](#getting-started)
+5. [Usage Examples](#usage-examples)
+6. [Community](#community)
+7. [Cite Us](#cite-us)
+8. [Roadmap](#roadmap)
+9. [Contributing](#contributing)
+10. [License](#license)
 
-`RoboSDK` is a light weight, high-level interface which provides hardware independent APIs for robotic control and perception.
-The goal of this project is to abstract away the low-level controls for developing APPs that runs on an industrial robot in an easy-to-use way.
+
+### Introduction
+
+`RoboSDK` is a cloud-native robotics development platform that aims to simplify and democratize the creation of sophisticated robotics applications. It provides a hardware-agnostic environment and middleware-based approach to seamlessly integrate cloud services with various robot operating systems. 
+
+`RoboSDK` empowers developers of all skill levels to innovate and unleash the potential of cloud-native robotics in diverse industries.
+
+The goal of this project is to abstract away the low-level controls for developing APPs that runs on robots in an easy-to-use way.
 
 ### Features
 
-`RoboSDK` provide the following features:
+- **Hardware Abstraction**: Bridge the gap between diverse robot hardware and simplify integration with standardized interfaces.
+- **Middleware Compatibility**: Seamlessly interact with various robot operating systems, including [ROS 1](https://wiki.ros.org/), [ROS 2](http://docs.ros.org/), and [OpenHarmony](https://www.openharmony.cn/).
+- **Cloud Integration**: Access powerful cloud resources for advanced robotics functionalities, such as `Object Storage Service` and `Real-Time Communication`.
+- **Simulators Interfacing**: Interact with simulators such as [Gazebo](http://gazebosim.org/) and [Pybullet](https://pybullet.org/wordpress/).
+- **Factory Registry**: Encourage modular contributions by providing a user-friendly development experience.
 
-- Defining the Running World
-    - A `World` represent an environment which the robot launch, such as interactive maps, active objects and scenarios.
-    - `simulator`: it provides some predefined scenarios such as Gazebo, and the reusable wheels for building new `World`.
-
-- Sensor-Based Control for Registered Robots
-    - Object-oriented, unified interface for equivalent sensors, such as : `Camera`, `Lidar`, `IMU` and `Audio`. 
-      Therefore, they are guaranteed to have the same interface defined by the base class, for example, 
-      `Camera` would have `get_rgb`, `get_depth` as its member function, and their behavior would be the same across hardware.
-    - A `Robot` instance consists of multiple components of sensors which were extended the `BaseClass` respectively. `Robot` and `Sensor` is one-to-many.
-    - A `Robot` is controlled by invoking the `Sensor` interface. The robots are managed by combining multiple configurations of each sensor.
-    - Interconnection with Vendor-defined interface, like: socket-base gait change.
-
-- Plug-in-and-play Algorithms
-    - Localize
-    - Perception
-    - Navigation
-    - Cloud-Edge Service
-
-- Robot Operating System Backend mapping
-  ```text
-  It provides a full-stack abstraction for Robot Operating System, such as message manager.
-  ```
-
-  - Ros1 [stable]
-  - Ros2 [rc]
-  - openHarmony [alpha]
+
+### Architecture
+
+![Architecture](./docs/source/_static/architecture.png)
 
 
-### Installation
+### Getting Started
+
+Let’s walk through setting up a robot with a camera to complete a simple application development based on `RoboSDK`.
 
+<details>
+<summary>Installation</summary>
 - Prerequisites
   - Robot Operating System: such as [Ros noetic](http://wiki.ros.org/noetic/installation/ubuntu) 
 
@@ -67,7 +70,7 @@ The goal of this project is to abstract away the low-level controls for developi
     .\robo_venv\Scripts\activate
     ```
 
-- Install RoboSDK
+- Install `RoboSDK`
 
     ```sh
   # Git Clone the whole source code.
@@ -79,23 +82,102 @@ The goal of this project is to abstract away the low-level controls for developi
   # Install the pip package 
   pip3 install dist/robosdk*.whl
   ```
-
-### Show Cases
+</details>
+
+<details>
+<summary>Simple application development</summary>
+
+#### Transmitting Robot's vision to the cloud
+
+- Step 1: Configure Robot with yaml file
+
+  ```yaml
+  # demo.yaml
+  name: "demo"
+  environment:
+    backend: "ros1"
+    requirement:
+      - rospy
+      - rostopic
+      - roslib
+  sensors:
+    camera:
+      - name: "cam1"
+        config: "simplecamera"
+        rgb:
+          target: "/usb_cam_1/image_raw"
+          actual_hz: 10
+          origin_hz: 30
+          is_compressed: false
+        info:
+          target: "/usb_cam_1/camera_info"
+  control:
+    - motion:
+      name: "ros_cmd_vel"
+      config: "cmd_vel"
+  ```
+
+- Step 2: Write a simple application
+
+  ```python
+  # demo.py
+
+  import cv2
+  import time
+
+  from robosdk.core.robot import Robot
+  from robosdk.common.fileops import FileOps
+
+
+  def main():
+      robot = Robot(name="my_robot", config="demo")
+      robot.connect()
+
+      total_img = 10
+      wait_time = .2
+      upload_target = "s3://test"
+
+      while total_img:
+          time.sleep(wait_time)
+
+          rgb, timer = robot.camera.get_rgb()
+          if rgb is None:
+              continue
+
+          _ = cv2.imwrite(f"./{timer}.png", rgb)
+          FileOps.upload(f"./{timer}.png", f"{upload_target}/{timer}.png")
+
+          total_img -= 1
+  ```
+
+- Step 3: Run the application
+
+  ```sh
+
+  source ./robo_venv/bin/activate
+  source /opt/ros/noetic/setup.bash
+
+  python3 demo.py
+  ```
+</details>
+
+### Usage Examples
 
 - Case I - [Legged-Robot Auto Gait Change](./examples/ysc_x20/auto_gait_change)
 - Case II - [Arm-Robot Teleoperation](./examples/scout_arm/teleoperation)
 
 
-### Supported
+### Community
 
-As we are currently fully tested in the following Robots/sensors, which is considered to be well supported :
+Join the KubeEdge Sig Robotics community! Engage in discussions, share ideas, and collaborate with like-minded developers. Feel free to reach out to us through [this documents](https://github.com/kubeedge/community/tree/master/sig-robotics).
 
-#### Robot
- - [x20](https://www.deeprobotics.cn/products_jy_3.html)
- - [scout](https://global.agilex.ai/products/scout-mini)
 
 ### [Cite Us](./CITATION)
 
+### [Roadmap](./docs/source/proposals/roadmap.md)
+
+### [Contributing](./CONTRIBUTING.md)
+
 ### License
 
 Copyright 2021 The KubeEdge Authors. All rights reserved.

docs/source/proposals/README.md

@@ -0,0 +1,21 @@
+**RoboSDK - Empowering Cloud-Native Robotics Development**
+
+![RoboSDK Logo](../_static/logo150x150.png)
+
+Welcome to `RoboSDK`, an open-source cloud-native robotics toolchain designed to empower developers in building cutting-edge robotics applications. This README provides an overview of the project and its objectives, guiding developers on how to get started, and encouraging community engagement.
+
+`RoboSDK` aims to address these challenges and provide developers with a unified platform for cloud-native robotics development.
+
+Here provides a proposal to `RoboSDK`, comprises the following key sections:
+
+1. **Introduction:** An overview to `RoboSDK`, goals, significance and concepts in our project.
+
+2. **Project Design:** An in-depth explanation of `RoboSDK`'s architecture, highlighting its hardware abstraction layer, cloud service integration, and support for different robot operating systems.
+
+3. **Comparison:** A detailed comparison between `RoboSDK` and the existing reference work, emphasizing the advantages and innovations `RoboSDK` brings to the field.
+
+4. **Value Description:** A breakdown of the value `RoboSDK` brings to the cloud computing, robotics industry, and developers of all levels of expertise.
+
+5. **Roadmap:** A forward-looking plan outlining the project's goals, upcoming features, and enhancements for `RoboSDK`.
+
+6. **References:** A list of references used in our project.

docs/source/proposals/comparison.md

@@ -0,0 +1,64 @@
+# Detailed Comparison: RoboSDK vs. Existing Reference Works
+
+In this section, we will conduct a comprehensive comparison between `RoboSDK` and three prominent existing reference works: [NVIDIA Isaac SDK](https://developer.nvidia.com/isaac-sdk), [AWS IoT SDK](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sdks.html), and [rospy](http://wiki.ros.org/rospy). By highlighting the advantages and innovations that `RoboSDK` brings to the field, we aim to demonstrate its unique position in the cloud-native robotics landscape.
+
+## 1. NVIDIA Isaac SDK
+
+### Hardware Abstraction
+- NVIDIA Isaac SDK provides hardware abstraction for NVIDIA-specific robotic platforms, offering optimized performance for their hardware ecosystem.
+- In contrast, RoboSDK offers a more generic hardware abstraction layer, enabling seamless integration with a wide range of robot platforms, not limited to any specific hardware vendor.
+
+### Cloud Service Integration
+- NVIDIA Isaac SDK primarily focuses on integration with NVIDIA's cloud services and edge computing solutions.
+- RoboSDK, on the other hand, adopts a middleware-based approach to integrate with a broader array of cloud services, including the ability to seamlessly interface with RoboArtisan's cloud offerings (RoboOMS and RoboSS).
+
+### Support for Robot Operating Systems
+- NVIDIA Isaac SDK is optimized for ROS 2 and tightly coupled with the NVIDIA Jetson platform.
+- RoboSDK takes a platform-agnostic approach, supporting both ROS 1 and ROS 2, as well as other robot operating systems, such as Harmony, to cater to the diverse needs of developers.
+
+### Advantages of RoboSDK
+- RoboSDK's generic hardware abstraction layer ensures compatibility with various robot platforms, enabling developers to deploy their applications across a wider range of robots.
+- The middleware-based cloud service integration facilitates seamless utilization of RoboArtisan's cloud resources, streamlining task management and data storage.
+- Support for multiple robot operating systems allows developers to leverage RoboSDK's capabilities regardless of their preferred robot framework.
+
+## 2. AWS IoT SDK
+
+### Cloud-Native Capabilities
+- AWS IoT SDK is a comprehensive toolkit for cloud-native development, designed primarily for IoT applications.
+- RoboSDK, being tailored for robotics, focuses on addressing the specific challenges and requirements in the cloud-native robotics domain, providing dedicated robot-centric features.
+
+### Robot-Specific Abstraction
+- AWS IoT SDK offers general-purpose abstractions for IoT devices, but it lacks specialized features for robots' unique characteristics.
+- RoboSDK's hardware abstraction layer is specifically designed to cater to robot-specific needs, providing interfaces for robot actuators, sensors, and communication channels.
+
+### Middleware for RoboArtisan Cloud Services
+- While AWS IoT SDK offers cloud service integration, it does not have built-in middleware for integrating with RoboArtisan's cloud services, limiting its direct compatibility with RoboOMS and RoboSS.
+- RoboSDK's middleware-based approach bridges this gap, enabling developers to interact seamlessly with RoboArtisan's cloud resources.
+
+### Advantages of RoboSDK
+- RoboSDK's specialized focus on cloud-native robotics ensures a more tailored and optimized development experience for robot applications.
+- The robot-specific abstraction layer enhances the efficiency of robot operations, enabling developers to focus on creating sophisticated robot behaviors.
+- Middleware integration with RoboArtisan cloud services enhances data management and task coordination, streamlining the development process.
+
+## 3. rospy
+
+### ROS-Centric Approach
+- rospy is a Python library and part of the ROS ecosystem, offering a Python interface for ROS nodes.
+- RoboSDK, while supporting ROS 1 and ROS 2, provides a higher-level interface that abstracts away the complexities of ROS, simplifying the development process for developers who are not deeply familiar with ROS.
+
+### Cloud Service Integration
+- rospy does not natively integrate with cloud services, requiring developers to implement their own integration solutions.
+- RoboSDK's middleware-based cloud service integration provides a unified interface for utilizing cloud resources, including RoboArtisan's cloud offerings.
+
+### Hardware Abstraction
+- rospy does not offer a dedicated hardware abstraction layer, leaving developers to deal with hardware integration challenges themselves.
+- RoboSDK's hardware abstraction layer provides a consistent and easy-to-use interface for accessing robot hardware, regardless of the underlying robot platform.
+
+### Advantages of RoboSDK
+- RoboSDK's higher-level interface abstracts away the complexities of ROS, making it accessible to developers from various backgrounds.
+- The middleware-based cloud service integration simplifies the utilization of cloud resources, making it more convenient for developers to leverage cloud-native capabilities.
+- The hardware abstraction layer saves development time and effort by providing a consistent and unified API for interacting with diverse robot hardware.
+
+## Conclusion
+
+RoboSDK stands out as a dedicated, cloud-native robotics framework that offers a unique set of advantages compared to existing reference works such as NVIDIA Isaac SDK, AWS IoT SDK, and rospy. Its generic hardware abstraction, middleware-based cloud service integration, and support for various robot operating systems set it apart as an innovative solution for cloud-native robot application development. By leveraging RoboSDK's capabilities, developers can unlock new possibilities in the field of cloud-native robotics and build cutting-edge applications that transform industries and drive the future of robotics.

docs/source/proposals/introduction.md

@@ -0,0 +1,37 @@
+# Introduction
+
+`RoboSDK` is an open-source project that aims to democratize robotics development by providing developers with convenient access to robot datasets, cloud resources, and hardware abstraction. Our mission is to lower the barriers to entry in the robotics domain and enable ambitious projects at all levels of expertise. By leveraging the power of cloud-native technologies, `RoboSDK` enhances the capabilities of robots and opens up new possibilities for applications in various industries, including manufacturing, healthcare, logistics, and more.
+
+## Significance
+
+Cloud-native robotics is revolutionizing the robotics industry, enabling robots to adapt and learn from real-world experiences continuously. With `RoboSDK`, we seek to drive this transformation by providing a comprehensive and user-friendly framework for cloud-native robotics application development.
+
+Cloud-native robotics is a cutting-edge approach that leverages cloud computing and services to enhance the capabilities of robots. By offloading computation and data storage to the cloud, robots can access vast amounts of data, powerful machine learning algorithms, and computational resources, enabling them to perform complex tasks and make data-driven decisions. This approach revolutionizes the robotics industry, enabling robots to adapt and learn from real-world scenarios continuously.
+
+## Challenges Faced by Developers
+
+Integrating cloud services with robots has traditionally been a daunting task for developers due to various challenges:
+
+- **Hardware Diversity:** Robots and sensors come in various Protocols and Drivers, making hardware integration complex and time-consuming.
+
+- **Robot Operating System (ROS) Compatibility:** ROS versions and standards may differ across platforms, causing compatibility issues.
+
+- **Cloud Service Integration:** Integrating cloud services often requires deep knowledge of specific APIs and complex configurations.
+
+- **Across Component Integration:** To achieve complete application development, we require a common API and research platform for sharing code, data, and models across services, control, algorithms, and data processing modules. However, despite its long history and extensive capabilities, `ROS` can be challenging for new users without the necessary expertise or time to fully understand the software stack.
+
+## Concepts
+
+Conceptual overviews provide relatively high-level, general background information about key aspects of `RoboSDK`.
+
+`RoboSDK` is a middleware on top of the robot operating system (ROS). It provides a consistent set of hardware-independent mid-level APIs to control different robots. These are the concepts that will help you get started understanding the basics of `RoboSDK`.
+
+- **ROS**: The Robot Operating System (ROS) is a set of software libraries and tools that help you build robot applications. From drivers to state-of-the-art algorithms, and with powerful developer tools, ROS has what you need for your next robotics project. Representative work includes: [ROS 1](https://wiki.ros.org/), [ROS 2](http://docs.ros.org/), and [OpenHarmony](https://www.openharmony.cn/).
+
+- **RoboArtisan**: `RoboArtisan` is a series of cloud-native robotics solutions that aims to simplify and democratize the research of sophisticated robotics scenes. Representative work includes: `RoboOMS`, `RoboSS`, `RoboAI`.
+
+- **RoboOMS**: The Robot Operation Management Service (RoboOMS) is a cloud-native robotics solution built on [KubeEdge](https://github.com/kubeedge/kubeedge). It provides a foundation for managing robot-cloud-edge communication, facilitating multi-robot collaboration, deploying applications, and conducting operations.
+
+- **RoboSS**: The Robot Simulation Service (RoboSS) is a cloud-native robotics solution built on [O3DE](https://github.com/o3de/o3de). It provides a simulation framework for cloud-native scenarios, allowing users to simulate robot scenarios, generate data, train skills, and experiment with digital twins using open-source simulators.
+
+- **RoboAI**: The Robot Artificial Intelligence Service (RoboAI) is a cloud-native robotics solution for building and deploying AI solutions. Representative work includes: [sedna](https://github.com/kubeedge/sedna).