\ No newline at end of file
diff --git a/content/developing-with-reachy-2/advanced-tutos/2-reachy-the-mime.md b/content/developing-with-reachy-2/advanced-tutos/2-reachy-the-mime.md
new file mode 100644
index 00000000..0861fe24
--- /dev/null
+++ b/content/developing-with-reachy-2/advanced-tutos/2-reachy-the-mime.md
@@ -0,0 +1,29 @@
+---
+title: "Reachy the Mime"
+description: ""
+lead: "Synchronize head, arm and mobile base movements"
+date: 2023-07-26T08:05:23+02:00
+lastmod: 2023-07-26T08:05:23+02:00
+draft: false
+images: []
+type: docs
+menu:
+ developing-with-reachy-2:
+ parent: "Advanced tutorials"
+weight: 310
+toc: true
+---
+
+In [this tutorial](https://github.com/pollen-robotics/reachy2-tutorials/blob/main/2_Reachy_the_mime.ipynb), we will transform Reachy into a mime who pulls an invisible rope.
+
+
+
+What you will learn :
+
+- How to use the **mobile base**,
+- How to **synchronize** arms and mobile base movements,
+- How and when to use **blocking** gotos,
+- How to follow a particular **trajectory** with the end effector.
+
+
+
\ No newline at end of file
diff --git a/content/developing-with-reachy-2/advanced-tutos/3-reachy-the-greengrocer.md b/content/developing-with-reachy-2/advanced-tutos/3-reachy-the-greengrocer.md
new file mode 100644
index 00000000..810cde78
--- /dev/null
+++ b/content/developing-with-reachy-2/advanced-tutos/3-reachy-the-greengrocer.md
@@ -0,0 +1,29 @@
+---
+title: "Reachy the Greengrocer"
+description: ""
+lead: "Use pollen_vision to plug an vision model with the SDK for fruit detection and manipulation"
+date: 2023-07-26T08:05:23+02:00
+lastmod: 2023-07-26T08:05:23+02:00
+draft: false
+images: []
+type: docs
+menu:
+ developing-with-reachy-2:
+ parent: "Advanced tutorials"
+weight: 320
+toc: true
+---
+
+
\ No newline at end of file
diff --git a/content/developing-with-reachy-2/advanced-tutos/_index.md b/content/developing-with-reachy-2/advanced-tutos/_index.md
index bf8ad40e..fcf44f0b 100644
--- a/content/developing-with-reachy-2/advanced-tutos/_index.md
+++ b/content/developing-with-reachy-2/advanced-tutos/_index.md
@@ -11,3 +11,23 @@ menu:
developing-with-reachy-2:
weight: 30
---
+
+
+
+Now, you’ve learned the **basics behaviours** available with reachy2_sdk. But how to use them to **build your own program** may still seem a little abstract.
+
+That's why we've created a series of **practical tutorials** to guide you step-by-step through the process of thinking about and building different programs that will help you understand the mechanics involved in creating **your own behaviour**!
+
+For the moment, there are **three tutorials** available, ranging from the simplest to the most complex, to help you get to grips with different Reachy functions.
+
+The first two use only the **SDK Client**, and the last one adds object detection with AI model from **pollen-vision.**
+
+You will find the GitHub repository just [there](https://github.com/pollen-robotics/reachy2-tutorials), and to make the third tutorial with pollen-vision, you need to install the library on your virtual environment :
+
+```python
+pip install --user --no-warn-script-location "pollen-vision[vision] @ git+https://github.com/pollen-robotics/pollen-vision.git@develop"
+pip install depthai
+```
+
+Now that you're all set up, have fun !
+
diff --git a/content/developing-with-reachy-2/advanced-tutos/reachy-awakening.md b/content/developing-with-reachy-2/advanced-tutos/reachy-awakening.md
deleted file mode 100644
index 47750c31..00000000
--- a/content/developing-with-reachy-2/advanced-tutos/reachy-awakening.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: "Reachy's Awakening"
-description: ""
-lead: "Your first tracking with head using arm kinematics"
-date: 2023-07-26T08:05:23+02:00
-lastmod: 2023-07-26T08:05:23+02:00
-draft: false
-images: []
-type: docs
-menu:
- developing-with-reachy-2:
- parent: "Advanced tutorials"
-weight: 300
-toc: true
----
-
-*Page in progress*
\ No newline at end of file
diff --git a/content/developing-with-reachy-2/advanced-tutos/reachy-the-greengrocer.md b/content/developing-with-reachy-2/advanced-tutos/reachy-the-greengrocer.md
deleted file mode 100644
index 218b35ab..00000000
--- a/content/developing-with-reachy-2/advanced-tutos/reachy-the-greengrocer.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: "Reachy the Greengrocer"
-description: ""
-lead: "Use pollen_vision to plug an vision model with the SDK for fruit detection and manipulation"
-date: 2023-07-26T08:05:23+02:00
-lastmod: 2023-07-26T08:05:23+02:00
-draft: false
-images: []
-type: docs
-menu:
- developing-with-reachy-2:
- parent: "Advanced tutorials"
-weight: 320
-toc: true
----
-
-*Page in progress*
\ No newline at end of file
diff --git a/content/developing-with-reachy-2/advanced-tutos/reachy-the-mime.md b/content/developing-with-reachy-2/advanced-tutos/reachy-the-mime.md
deleted file mode 100644
index bb114f8b..00000000
--- a/content/developing-with-reachy-2/advanced-tutos/reachy-the-mime.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: "Reachy the Mime"
-description: ""
-lead: "Synchronize head, arm and mobile base movements"
-date: 2023-07-26T08:05:23+02:00
-lastmod: 2023-07-26T08:05:23+02:00
-draft: false
-images: []
-type: docs
-menu:
- developing-with-reachy-2:
- parent: "Advanced tutorials"
-weight: 310
-toc: true
----
-
-*Page in progress*
\ No newline at end of file
diff --git a/content/developing-with-reachy-2/basics/1-hello-world.md b/content/developing-with-reachy-2/basics/1-hello-world.md
index 92c2da71..e9250451 100644
--- a/content/developing-with-reachy-2/basics/1-hello-world.md
+++ b/content/developing-with-reachy-2/basics/1-hello-world.md
@@ -12,22 +12,110 @@ menu:
parent: "SDK basics"
weight: 200
toc: true
+slug: "1-hello-world"
+url: "/developing-with-reachy-2/basics/1-hello-world/"
---
+## Materials
+
+To guide you through the SDK's functionalities, you can follow this written documentation (which is more complete), as well as the notebooks provided, so you can learn as you interact with your robot.
+
+#### Find the notebooks
+- {{< video "videos/sdk/goto.mp4" "80%" >}} -
+> Read next section on [Use arm kinematics]({{< ref "developing-with-reachy-2/basics/4-use-arm-kinematics" >}}) to better understand the use of the `goto` method. -Don't forget to put the right arm's joints back to the compliant mode. Place your hand below the right arm's gripper to prevent the arm from falling hard on the table. -```python -reachy.r_arm.turn_off() -``` - -> To find out whether you have to send positive or negative angles, read next section on the arm kinematics. +### translate_by() and rotate_by() -### goto_matrix() +To simplify your life, you have access to functions to easily compute translation or rotation, in the robot or gripper frame, in **cartesian space**. +For example you can use the `translate_by(...)` method to send the gripper up, asking for a translation 10cm up in Reachy's frame (+0.1m on Reachy's z axis), and a rotation of 20° around the z axis of the gripper : -The **`goto_matrix()`** method takes a 4x4 matrix expressing the target pose of Reachy 2's end effector in Reachy 2 coordinate system. +```python +reachy.r_arm.translate_by(x=0, y=0, z=0.1, frame="robot") +reachy.r_arm.rotate_by(roll=0, pitch=0, yaw=20, frame="gripper") +``` -> Read next section on [Use arm kinematics]({{< ref "developing-with-reachy-2/basics/4-use-arm-kinematics" >}}) to better understand the use of the `goto_matrix()` method. ## Gripper control @@ -177,9 +196,10 @@ The opening value corresponds to a **percentage of opening**, which means: - 0 is close - 100 is open -You can read the opening of the gripper through the opening attribute: +You can read the opening of the gripper : + ```python -reachy.r_arm.gripper.opening +reachy.r_arm.gripper.get_current_opening() >>> 20 # almost closed ``` @@ -190,14 +210,24 @@ Send your custom opening value, still between 0 and 100, to the gripper with: reachy.r_arm.gripper.set_opening(50) # half-opened ``` +Those actions are non-blocking, meaning that the rest of your program won't wait the end of the action to continue. +You can use the boolean `is_moving()` for that : + +```python +reachy.r_arm.gripper.close() +while reachy.r_arm.gripper.is_moving() : + time.sleep(0.1) +reachy.r_arm.gripper.open() +``` + > Note that there is an smart gripper control that will avoid the gripper from reaching the opening position if an object has been detected while closing the gripper. ## Read arm position -### get_joints_position() +### In joint space : get_current_positions() -You can retrieve the values from each **arm joints** using the **`get_joints_position()`** method. +You can retrieve the values from each **arm joints** using the **`get_current_positions()`** method. This method returns a seven-elements-long list, with the angles in this order: - r_arm.shoulder.pitch @@ -211,24 +241,23 @@ This method returns a seven-elements-long list, with the angles in this order: > Angles are returned in **degrees** by default. ```python -reachy.l_arm.rotate_to(20, 30, -10) - -reachy.head.get_joints_position() ->>> [7, 10, 4, -50, 4, 5, 7] +reachy.goto_posture() +reachy.r_arm.get_current_positions() +>>> [0, 10, -10, 0, 0, 0, 0] -# r_arm.shoulder.pitch=7, +# r_arm.shoulder.pitch=0, # r_arm.shoulder.roll=10, -# r_arm.elbow.yaw=4, -# r_arm.elbow.pitch=-50, -# r_arm.wrist.roll=4, -# r_arm.wrist.pitch=5, -# r_arm.wrist.yaw=7, +# r_arm.elbow.yaw=-10, +# r_arm.elbow.pitch=0, +# r_arm.wrist.roll=0, +# r_arm.wrist.pitch=0, +# r_arm.wrist.yaw=0 ``` -### End effector position +### In cartesian space : forward_kinematics() -You can get the end effector position of Reachy 2 in Reachy 2 coordinate system using forward kinematics. +You can get the end effector position of Reachy in Reachy 2 coordinate system using forward kinematics. Call: ```python diff --git a/content/developing-with-reachy-2/basics/4-use-arm-kinematics.md b/content/developing-with-reachy-2/basics/4-use-arm-kinematics.md index 9e5c4383..107b64e2 100644 --- a/content/developing-with-reachy-2/basics/4-use-arm-kinematics.md +++ b/content/developing-with-reachy-2/basics/4-use-arm-kinematics.md @@ -18,18 +18,18 @@ toc: true ### Joint coordinates -If you remember the [`goto_joint()` function]({{< ref "developing-with-reachy-2/basics/3-basic-arm-control#goto_joints" >}}), to generate a trajectory for the arm, you need to pass a list of joints with the requested position as argument. +If you remember the [`goto()` function]({{< ref "developing-with-reachy-2/basics/3-basic-arm-control#goto" >}}), to generate a trajectory for the arm, you need to pass a list of joints with the requested position as argument. For example, to place the right arm in a right angled position, we defined the following list: ```python -right_angled_position = [0, 0, 0, -90, 0, 0, 0] +right_angled_position = [0, 10, -10, -90, 0, 0, 0] ``` and then call the function with is: ```python -reachy.r_arm.goto_joints(right_angled_position) +reachy.r_arm.goto(right_angled_position) ``` In this basic arm control, we used what is called **joint coordinates** to move Reachy. This means that we controlled each joint separately. @@ -40,7 +40,7 @@ Controlling a robot in joint coordinates can be hard and is often far from what The **kinematic model** describes the motion of a robot in mathematical form without considering the forces and torque affecting it. It only focuses on the geometric relationship between elements. -We have defined the whole kinematic model of the arm. This means the translation and rotation required to go from one joint to the next one. On a right arm equipped with a gripper this actually look like this: +We have defined the whole kinematic model of the arm. This means the translation and rotation required to go from one joint to the next one. On a right arm equipped with a gripper, this actually looks like this: |Motor|Translation|Rotation| |-----|-----------|--------| @@ -88,8 +88,8 @@ You can see the right and left end-effectors animated below. Forward and inverse kinematics are a way to go from one coordinates system to the other: -* **forward kinematics: joint coordinates –> cartesian coordinates**, -* **inverse kinematics: cartesian coordinates –> joint coordinates**. +* **forward kinematics**: joint coordinates –> cartesian coordinates , +* **inverse kinematics**: cartesian coordinates –> joint coordinates. ## Forward kinematics @@ -102,28 +102,28 @@ Each arm has a **`forward_kinematics()`** method. To use it, you first need to c ```python from reachy_sdk import ReachySDK -reachy = ReachySDK(host='192.168.0.42') # Replace with the actual IP +reachy = ReachySDK(host='10.0.0.201') # Replace with the actual IP reachy.r_arm.forward_kinematics() ->>> array([[ 0.04622308, -0.03799621, -0.99820825, 0.31144822], - [ 0.10976691, 0.99341829, -0.03273101, -0.19427524], - [ 0.99288199, -0.1080573 , 0.05008958, -0.4255104 ], - [ 0. , 0. , 0. , 1. ]]) +>>> array([[-0.015, 0.001, -1. , 0.384], + [ 0.086, 0.996, -0.001, -0.224], + [ 0.996, -0.086, -0.015, -0.273], + [ 0. , 0. , 0. , 1. ]]) ``` The method returns a 4x4 matrix indicating the position and orientation of the end effector in Reachy 2's coordinate system. > By specifying no argument, it will give the current 3D position and orientation of the end effector. -You can compute the forward kinematics of the arm for other joints positions, by giving as an argument a seven-element-long list, as for the `goto_joints()`method. The arm will not move, but you can get the target position and orientation of the arm in this configuration. +You can compute the forward kinematics of the arm for other joints positions, by giving as an argument a seven-element-long list, as for the `goto()`method. The arm will not move, but you can get the target position and orientation of the arm in this configuration. -For example, for the right arm right angled position: +For example, for the right arm right-angled-position: ```python reachy.r_arm.forward_kinematics([0, 0, 0, -90, 0, 0, 0]) ->>> array([[ 0.04622308, -0.03799621, -0.99820825, 0.31144822], - [ 0.10976691, 0.99341829, -0.03273101, -0.19427524], - [ 0.99288199, -0.1080573 , 0.05008958, -0.4255104 ], - [ 0. , 0. , 0. , 1. ]]) +>>> array([[-0.045, -0.168, -0.985, 0.387], + [ 0.255, 0.951, -0.174, -0.205], + [ 0.966, -0.259, -0. , -0.27 ], + [ 0. , 0. , 0. , 1. ]]) ``` ### Understand the result @@ -144,7 +144,7 @@ reachy.r_arm.forward_kinematics() returns the current pose of the right end-effector, based on the present position of every joint in the right arm. -You can also compute the pose for a given joints position, to do that just pass the list of position as argument of forward_kinematics. Be careful to respect the order of the position you give and to give all the joints in the arm kinematic chain (i.e. from *shoulder_pitch* to *wrist_roll*). +You can also compute the pose for a given joints position. To do that, just pass the list of position as argument of forward_kinematics. Be careful to respect the order of the position you give and to give all the joints in the arm kinematic chain (i.e. from *shoulder_pitch* to *wrist_roll*). For example, we can compute the forward kinematics for the right-angle position we defined earlier. @@ -168,7 +168,7 @@ $$\begin{bmatrix} 1 & 0 & 0 \end{bmatrix}$$ -We can use scipy to understand what this matrix represents. +We can use *scipy* to understand what this matrix represents. ```python from scipy.spatial.transform import Rotation as R @@ -179,30 +179,33 @@ R.from_matrix([ [0, 1, 0], [1, 0, 0], ]).as_euler('xyz', degrees=True) ->>> array([ 0. , -89.99999879, 0. ]) +>>> array([0., -90,0.]) ``` So scipy tells us that a rotation of -90° along the y axis has been made to get this matrix, which is coherent with the result because having the hand facing forward corresponds to this rotation according to Reachy's xyz axis that we saw above. ## Inverse kinematics -The inverse kinematics is the exact opposite of the forward kinematics. From a 4x4 pose in Reachy 2 coordinate system, it gives you a list of joints positions to reach this target. +The inverse kinematics is the exact opposite of the forward kinematics. From a 4x4 pose in Reachy 2 coordinate system, it gives a list of joints positions to reach this target. -Knowing where you arm is located in the 3D space can be useful but most of the time what you want is to move the arm in cartesian coordinates. You want to have the possibility to say: “move your hand to [x, y, z] with a 90° rotation around the Y axis”. This is what **`goto_matrix()`** +Knowing where you arm is located in the 3D space can be useful but most of the time what you want is to move the arm in cartesian coordinates. You want to have the possibility to say: +> “Move your hand to [x, y, z] with a 90° rotation around the Y axis”. + +This is what **`goto()`** does, if the input is a 4x4 matrix. ### inverse_kinematics() Each arm has an **`inverse_kinematics()`** method. To use it, you first need to connect to your Reachy. -You need to specify as an argument a target pose in Reachy coordinate system. +You need to specify a target pose in Reachy coordinate system as an argument. -Let's for example ask for the inverse kinematics of the current pose, using the forward kinematics. +Let's for example ask the inverse kinematics of the current pose, using the forward kinematics. ```python from reachy_sdk import ReachySDK -reachy = ReachySDK(host='192.168.0.42') # Replace with the actual IP +reachy = ReachySDK(host='10.0.0.201') # Replace with the actual IP reachy.r_arm.inverse_kinematics(reachy.r_arm.forward_kinematics()) ->>> [0, 0, 0, -90, 0, 0, 0] ?? +>>> [0, 10, -10, -90, 0, 0, 0] ``` The method returns a seven-element-long list indicating the position of each arm joint, in the usual order: @@ -214,20 +217,10 @@ The method returns a seven-element-long list indicating the position of each arm - r_arm.wrist.pitch - r_arm.wrist.yaw -Contrary to the forward kinematics which has a unique answer (giving all joints values will always put the end effector at the same target position), inverse kinematics can have an infinite number of answers (for a target position of the end effector, several combinations of joints angles are possible). - -#### Using a q0 value -The inverse kinematics returns one solution, but you may want to custom the position from which the computation is done to get another result. -To do so, specify a **q0** value when calling the `inverse_kinematics()` method. The **`q0`** argument must be a seven-element-long list as well: -```python -reachy.r_arm.inverse_kinematics( - reachy.r_arm.forward_kinematics(), - q0=[0, 0, 0, 0, 0, 0, 0]) ->>> [0, 0, 0, -90, 0, 0, 0] ?? -``` +Contrary to the forward kinematics which has a unique answer (giving all joints values will always put the end effector at the same target position), inverse kinematics can have an infinite number of answers (for a target position of the end effector, several combinations of joints angles are possible). -### Example: square movement with goto_matrix() +### Example: square movement in cartesian space #### Defining the poses @@ -241,72 +234,54 @@ For our starting corner A, let's imagine a point in front of the robot, on its r $$A = \begin{pmatrix}0.3 & -0.4 & -0.3\end{pmatrix}$$ -The coordinates of B should match A except the z component wich should be higher. Hence +The coordinates of B should match A except the z component which should be higher. Hence $$B = \begin{pmatrix}0.3 & -0.4 & 0.0\end{pmatrix}$$ -For the corner C, we want a point on the same z level as B in the inner space of Reachy and in the same plane as A and B so we only need to change the y component of B. We can take for example +For the corner C, we want a point on the same z level as B, in the inner space of Reachy and in the same plane as A and B. So we only need to change the y component of B. We can take for example : $$C = \begin{pmatrix}0.3 & -0.1 & 0.0\end{pmatrix}$$ -And to complete our corners we can deduce D from A and C. D coordinates should match C except its z component which must the same as A. Hence +And to complete our corners, we can deduce D from A and C. D coordinates should match C, except its z component, which must the same as A. Hence $$D = \begin{pmatrix}0.3 & -0.1 & -0.3\end{pmatrix}$$ -> **Remember that you always have to provide poses to the inverse kinematics that are actually reachable by the robot.** If you're not sure whether the 3D point that you defined is reachable by Reachy, you can move the arm with your hand in compliant mode, ask the forward kinematics and check the 3D translation component of the returned pose. +{{< warning icon="👉🏾" text="Remember that you always have to provide poses to the inverse kinematics that are actually reachable by the robot. If you're not sure whether the 3D point that you defined is reachable by Reachy, you can move the arm with your hand in compliant mode (meaning turned off), ask the forward kinematics and check the 3D translation component of the returned pose. " >}} -But having the 3D position is not enough to design a pose. You also need to provide the 3D orientation via a rotation matrix. The rotation matrix is often the tricky part when building a target pose matrix. +But having the 3D position is not enough to design a pose. You also need to provide the 3D orientation via a rotation matrix. It's often the tricky part when building a target pose matrix. Keep in mind that the identity rotation matrix corresponds to the zero position of the robot which is when the hand is facing toward the bottom. So if we want the hand facing forward when drawing our virtual square, we need to rotate it from -90° around the y axis, as we saw in the forward kinematics part. -We know from before which rotation matrix corresponds to this rotation, but we can use scipy again to generate the rotation matrix for given rotations. +We know from before which rotation matrix corresponds to this rotation, but we can use the SDK to get the 4x4 matrix from a position vector and the rotation given by the Euler angles : ```python -print(np.around(R.from_euler('y', np.deg2rad(-90)).as_matrix(), 3)) ->>> [[ 0. -0. -1.] - [ 0. 1. -0.] - [ 1. 0. 0.]] +from reachy2_sdk.utils.utils import get_pose_matrix +get_pose_matrix([0.3, -0.4, -0.3], [0,-90,0]) +>>> array([[ 0. , 0. , -1. , 0.3], + [ 0. , 1. , 0. , -0.4], + [ 1. , 0. , 0. , -0.3], + [ 0. , 0. , 0. , 1. ]]) + ``` -We got the rotation matrix that we expected! +We got the 4x4 matrix that we expected! -As mentionned, building the pose matrix can be hard, so don't hesitate to use scipy to build your rotation matrix. You can also move the arm with your hand where you want it to be and use the forward kinematics to get an approximation of the target pose matrix you would give to the inverse kinematics. +You can also move the arm with your hand where you want it to be and use the forward kinematics to get an approximation of the target pose matrix you would give to the inverse kinematics. Here, having the rotation matrix and the 3D positions for our points A and B, we can build both target pose matrices. -```python -A = np.array([ - [0, 0, -1, 0.3], - [0, 1, 0, -0.4], - [1, 0, 0, -0.3], - [0, 0, 0, 1], -]) - -B = np.array([ - [0, 0, -1, 0.3], - [0, 1, 0, -0.4], - [1, 0, 0, 0.0], - [0, 0, 0, 1], -]) - -C = np.array([ - [0, 0, -1, 0.3], - [0, 1, 0, -0.1], - [1, 0, 0, 0.0], - [0, 0, 0, 1], -]) - -D = np.array([ - [0, 0, -1, 0.3], - [0, 1, 0, -0.1], - [1, 0, 0, -0.3], - [0, 0, 0, 1], -]) -``` + +| **Matrix** | **Values** | +|------------|-------------------------------------------------| +| **A** | `np.array([[0, 0, -1, 0.3], [0, 1, 0, -0.4], [1, 0, 0, -0.3], [0, 0, 0, 1]])` | +| **B** | `np.array([[0, 0, -1, 0.3], [0, 1, 0, -0.4], [1, 0, 0, 0.0], [0, 0, 0, 1]])` | +| **C** | `np.array([[0, 0, -1, 0.3], [0, 1, 0, -0.1], [1, 0, 0, 0.0], [0, 0, 0, 1]])` | +| **D** | `np.array([[0, 0, -1, 0.3], [0, 1, 0, -0.1], [1, 0, 0, -0.3], [0, 0, 0, 1]])` | + #### Sending the movements commands -As before, we use the **`goto_matrix()`** to send moving instructions to the arm. +As before, we use the **`goto`** to send moving instructions to the arm. ```python @@ -314,19 +289,21 @@ import time # put the joints in stiff mode reachy.r_arm.turn_on() -# use the goto_matrix() method -reachy.r_arm.goto_matrix(A) -reachy.r_arm.goto_matrix(B) -reachy.r_arm.goto_matrix(C) -reachy.r_arm.goto_matrix(D) +# use the goto() method +reachy.r_arm.goto(A) +reachy.r_arm.goto(B) +reachy.r_arm.goto(C) +reachy.r_arm.goto(D) # put the joints back to compliant mode # use turn_off_smoothly to prevent the arm from falling hard -reachy.r_arm.turn_off() +reachy.r_arm.turn_off_smoothly() ``` The result should look like this:{{< video "videos/sdk/goto_ik.mp4" "80%" >}} -
\ No newline at end of file + + +Now, we are going to move the head ! \ No newline at end of file diff --git a/content/developing-with-reachy-2/basics/5-control-head.md b/content/developing-with-reachy-2/basics/5-control-head.md index b83720a0..f73e66d4 100644 --- a/content/developing-with-reachy-2/basics/5-control-head.md +++ b/content/developing-with-reachy-2/basics/5-control-head.md @@ -13,12 +13,16 @@ menu: weight: 240 toc: true --- ++ +> You can choose to follow our online documentation or to make your Reachy move by following the [notebook n°4](https://github.com/pollen-robotics/reachy2-sdk/blob/develop/src/examples/4_head_control.ipynb). ## Head presentation Reachy 2's head is mounted on an Orbita3D actuator, referred to as the **neck** actuator, giving 3 degrees of freedom to control the head orientation. -> Note : the antennas are not motorized for the moment + +> Note : the antennas control will be soon integrated in the SDK ! Stay tuned !
{{< video "videos/sdk/orbita.mp4" "80%" >}} @@ -30,10 +34,15 @@ Before starting to control it, connect to your Reachy and turn it on. As in the ```python from reachy2_sdk import ReachySDK -reachy = ReachySDK(host='192.168.0.42') # Replace with the actual IP +reachy = ReachySDK(host='10.0.0.201') # Replace with the actual IP reachy.head ->>>
+>>> +{{< video "videos/sdk/look.mp4" "80%" >}} @@ -84,93 +93,108 @@ look_front = reachy.head.look_at(x=0.5, y=0, z=0, duration=1.0) The best way to understand how to use the *look_at* is to play with it. Picture a position you would like Reachy's head to be in, guess a point which could match for the *look_at* and check if you got it right! -Another cool thing is that we can combine Reachy's kinematics with the *look_at* so that Reachy's head follows its hand! +Another cool thing is that we can combine Reachy's kinematics with the *look_at* so that Reachy's head follows its hand while you're moving it !
{{< video "videos/sdk/look_at_hand.mp4" "80%" >}}
```python -reachy.turn_on('head') - x, y, z = reachy.r_arm.forward_kinematics()[:3, -1] -reachy.head.look_at(x=x, y=y, z=z, duration=1.0) - -time.sleep(0.5) +reachy.head.look_at(x=x, y=y, z=z, duration=1.0, wait = True) while True: x, y, z = reachy.r_arm.forward_kinematics()[:3, -1] - reachy.head.look_at(x=x, y=y, z=z, duration=0.1) + reachy.head.look_at(x=x, y=y, z=z, duration=0.1, wait = True) ``` -What the code says is that we compute the [forward kinematics of Reachy's right arm]({{< ref "developing-with-reachy-2/basics/5-control-head#forward-kinematics" >}}), and the x, y, z of Reachy's right end-effector in the Reachy's coordinates system will be the coordinates of the point used by the *look_at*. +What the code says is that we compute the [forward kinematics of Reachy's right arm]({{< ref "developing-with-reachy-2/basics/5-control-head#forward-kinematics" >}}), and the x, y, z of Reachy's right end-effector in the Reachy's coordinates system will be the coordinates of the point used by the *look_at*. We use a loop with a blocking movement (*parameter wait=True*) to make the head follow the hand at a frequency of 10Hz. + + +### goto() + +The `goto()` function is another way to control the head. There is two ways to use it : +- from joints positions (in joint space) +- from the desired orientation as a quaternion (in cartesian space) -### rotate_to() +#### From joint positions -The `rotate_to()` function is another way to control the head. You directly control the joint of the neck, giving the roll, pitch and yaw angles in degrees. The rotation is made in the order: roll, pitch, yaw, in the Orbita3D coordinate system. + You directly control the joint of the neck, giving the roll, pitch and yaw angles in degrees. The rotation is made in the order: roll, pitch, yaw, in the Orbita3D coordinate system. {{< img-center "images/sdk/first-moves/orbita_rpy.png" 400x "" >}} To make the robot looks a little down: ```python -reachy.head.turn_on() # Don't forget to put the hand in stiff mode -reachy.head.rotate_to(roll=0, pitch=-10, yaw=0, duration=1.0) +reachy.head.turn_on() # Don't forget to put the head in stiff mode +reachy.head.goto([0, 10, 0], duration=1.0) ``` -### orient() +#### From quaternion -The last method to control the head is the `orient()` method. You can control the head with a quaternion. +You can control the head with a quaternion. You can use [pyquaternion library](https://kieranwynn.github.io/pyquaternion/) to create suitable quaternion for this method. + ```python from pyquaternion import Quaternion -q = Quaternion(axis=[1, 0, 0], angle=3.14159265) -reachy.head.turn_on() -reachy.head.orient(q) +q = Quaternion(axis=[1, 0, 0], angle=3.14159265 / 4) # tilt head about 45° to the right +reachy.head.goto(q) ``` -## Joint's goal_position +### Rotate_by() +You can also rotate the head from its current position, by using the *rotate_by* function and specifying angular degree values in roll, pitch, yaw, either in Reachy's or head's frame. -## Read head position -You can read the head orientation in two different ways: +```python +reachy.head.rotate_by(roll=0, pitch=0, yaw=20, frame='head') -- using the `get_orientation()` method, which returns a quaternion -- using the `get_joints_positions()` method, which the neck's roll, pitch and yaw present_position. +reachy.head.rotate_by(roll=-30, pitch=0, yaw=0, frame='robot') +``` -### get_orientation() -```python -q = reachy.head.get_orientation() -print(q) ->>> ?? -``` +## Joint's goal_position -### get_joints_positions() +The *goal_position* attribute of a joint can be used to set a new joint's target position to make it move. However, we recommend using the **goto()** method to move the motors which provides better control on the joint's trajectories. -In case you feel more comfortable using roll, pitch, yaw angles rather than working with quaternions, you can retrieve those values from the **neck joints**. +Using goal_position will make the motor move **as fast as it can**, so be careful when using it. ```python -reachy.head.rotate_to(20, 30, -10) -time.sleep(2) -reachy.head.get_joints_positions() ->>> [20, 30, -10] # roll=20, pitch=30, yaw=-10 +reachy.head.neck.roll.goal_position = 30 +reachy.send_goal_positions() ``` -Be careful that contrary to the quaternion that offers a unique representation of a rotation, it is not the case of the euler angles. Several angles combination can lead to the same orientation in space. For example: +:warning: goal_position must be written in **degrees**. + + +## Read head position + +You can read the head positions using : + +- Cartesian space : `get_current_orientation()` will give the head orientation as a quaternion according to the robot's frame + + +- Joint space : `get_current_positions()` will give the neck's roll, pitch and yaw present_position + +:warning: *Don't forget, there is a 10-degrees difference between the cartesian space and joint space, so we recommand you to not mix them.* + +### In cartesian space : ```python -reachy.head.rotate_to(70, -100, 80) # roll=70, pitch=-100, yaw=80 -time.sleep(2) -reachy.head.get_joints_positions() ->>> [-110, -80, -100] # roll=-110, pitch=-80, yaw=-100 +reachy.head.get_current_orientation() +>>> Quaternion(0.9794632485822068, 0.10189819035488734, -0.01081920496959773, 0.17364172391166605) ``` -The values are different, nevertheless it is the same final orientation. You can convince yourself doing: +### In joint space : + +In case you feel more comfortable using roll, pitch, yaw angles rather than working with quaternions, you can retrieve those values from the **neck joints**. + + ```python -reachy.head.rotate_to(-110, -80, -100) +reachy.head.get_current_positions() +>>> [11.881595589573665, -8.976164597791765, 22.07170507647743] ``` -The head won't move. \ No newline at end of file + +Now that we can move the head, let's focus on its cameras ! \ No newline at end of file diff --git a/content/developing-with-reachy-2/basics/6-get-images-from-cameras.md b/content/developing-with-reachy-2/basics/6-get-images-from-cameras.md index 85ae7030..fc7f1a51 100644 --- a/content/developing-with-reachy-2/basics/6-get-images-from-cameras.md +++ b/content/developing-with-reachy-2/basics/6-get-images-from-cameras.md @@ -13,36 +13,23 @@ menu: weight: 250 toc: true --- +-This section assumes that you went through the [Hello World]({{< ref "developing-with-reachy-2/getting-started-sdk/connect-reachy2" >}}) so that you know how to connect to the robot. +> You can choose to follow our online documentation or to see directly the images from your Reachy by following the [notebook n°5](https://github.com/pollen-robotics/reachy2-sdk/blob/develop/src/examples/5_cameras_images.ipynb). -Reachy 2 has 2 types of camera: -- the **teleop** cameras, with a right and left cameras, located in Reachy 2's head and used for the teleoperation -- the **SR** camera, which is a depth camera, located in Reachy 2's torso and mainly useful for manipulation tasks -Each camera can be accessed separately through *reachy.cameras*. They both have a right and left view, with the left and right sides considered from Reachy point of view. To be able to specify the view you want to get a frame from, you will need to import CameraView: +This section assumes that you went through the [Hello World]({{< ref "developing-with-reachy-2/basics/1-hello-world" >}}) so that you know how to connect to the robot. + +Reachy2 has 2 types of camera: +- the **teleop** cameras, with a left and right cameras, located in Reachy's head and used for the teleoperation +- the **depth** camera, equipped with a depth sensor, located in Reachy 2’s torso and mainly useful for manipulation tasks + +Each camera can be accessed separately through *reachy.cameras*. Teleop cameras have a right and left view, with the left and right sides considered from Reachy point of view, while the depth camera has a left (i.e. mono RGB) and depth view. To be able to specify the view you want to get a frame from, you will need to import CameraView: ```python from reachy2_sdk.media.camera import CameraView ``` -## Enable teleop cameras for the SDK - -### SR camera -The SR camera is unplugged by default. -If you want to use it, plug the SR camera on the robot's computer remaining USB port (2). - -{{< img-center "images/sdk/first-moves/plugged-sr.png" 400x "" >}} - -> Make sure to unplug it if you want to use the teleoperation. - -### Teleop cameras -The teleop cameras are shared between the teleop service and the SDK server, and can only be used by one at the same time. -In order to be able to use the teleop cameras with the SDK: -1. Go to the dashboard -2. Stop webrtc service in the services tab of the dashboard - -{{< img-center "images/sdk/first-moves/stop-webrtc-service.png" 600x "" >}} ## Get images @@ -51,94 +38,127 @@ First, connect to your Reachy. ```python from reachy_sdk import ReachySDK -reachy = ReachySDK(host='192.168.0.42') # Replace with the actual IP +reachy = ReachySDK(host='10.0.0.201') # Replace with the actual IP reachy.cameras ->>> ?? +>>>
You can easily record joint trajectories directly on Reachy, store and replay them later. This page will show you how to implement such mechanisms. @@ -23,20 +23,20 @@ In the following examples, we will assume that you are already connected to your ## Recording a trajectory -To record a trajectory, we will simply get the current position of individual motors at a predefiend frequency. We will first define a list of motors that we want to record. In this example, we will only record the joints from the right arm, but you can similarly record a single motor, or all motors of the robot at once. +To record a trajectory, we will simply get the current positions of individual motors at a predefined frequency. We will first define a list of motors that we want to record. In this example, we will only record the joints from the right arm, but you can similarly record a single motor, or all motors of the robot at once. ```python # assuming we run something like this before: -# reachy = ReachySDK(host='192.168.0.42') +# reachy = ReachySDK(host='10.0.0.201') recorded_joints = [ - reachy.r_arm.r_shoulder_pitch, - reachy.r_arm.r_shoulder_roll, - reachy.r_arm.r_arm_yaw, - reachy.r_arm.r_elbow_pitch, - reachy.r_arm.r_forearm_yaw, - reachy.r_arm.r_wrist_pitch, - reachy.r_arm.r_wrist_roll, + reachy.r_arm._shoulder.pitch, + reachy.r_arm._shoulder.roll, + reachy.r_arm._elbow.yaw, + reachy.r_arm._elbow.pitch, + reachy.r_arm._wrist.roll, + reachy.r_arm._wrist.pitch, + reachy.r_arm._wrist.yaw, ] ``` @@ -65,7 +65,7 @@ while (time.time() - start) < record_duration: ``` If you want to record a demonstration on the robot, first make sure the robot is compliant. Then, put it in the starting position. Run the code, and start moving the robot. After 5 seconds, the loop will stop and the movements you have made on Reachy will be recorded. -Depending on your uses, you can define another duration. You can also choose not to use a specify duration but maybe use start and stop event to record. In such case, the easy way is probably to run the loop within a thread or an asynchronous fonction, so it can run in background. +Depending on your uses, you can define another duration. You can also choose not to use a specify duration but maybe use start and stop event to record. In such case, the easiest way is probably to run the loop within a thread or an asynchronous fonction, so it can run in background. ## Visualise your recordings @@ -98,20 +98,17 @@ But before actually replaying the trajectory, there are a few key points that yo To avoid that, you can use the goto function to first go to the first point of your trajectories: ```python -from reachy_sdk.trajectory import goto - # Set all used joint stiff -for joint in recorded_joints: - joint.compliant = False +reachy.r_arm.turn_on() # Create a dict associating a joint to its first recorded position first_point = dict(zip(recorded_joints, trajectories[0])) # Goes to the start of the trajectory in 3s -goto(first_point, duration=3.0) +reachy.r_arm.goto(first_point, duration=3.0) ``` -Now that we are in position, we can actually play the trajectory. To do that, we simply loop over our recordings and set the goal position of each joints at the same frequency: +Now that we are in position, we can actually play the trajectory. To do that, we simply loop over our recordings and set the goal position of each joints then send all the commands at the same frequency: ```python import time @@ -119,6 +116,11 @@ import time for joints_positions in trajectories: for joint, pos in zip(recorded_joints, joints_positions): joint.goal_position = pos - + reachy.send_goal_positions(check_positions=False) time.sleep(1 / sampling_frequency) -``` \ No newline at end of file +``` + +> The check_positions parameter is used to check that the goal positions have been reached after the command has been sent, and that there has been no problem with an unreachable position. That process can take time et slow your replaying. Since it's a recording, all poses are necessarily reachable, so there's no need to waste process time on this check. + + +Now all we have to do is move the mobile base! \ No newline at end of file diff --git a/content/developing-with-reachy-2/basics/8-use-mobile-base.md b/content/developing-with-reachy-2/basics/8-use-mobile-base.md index d4f0223f..a06c0ae0 100644 --- a/content/developing-with-reachy-2/basics/8-use-mobile-base.md +++ b/content/developing-with-reachy-2/basics/8-use-mobile-base.md @@ -13,15 +13,40 @@ menu: weight: 270 toc: true --- +
+> You can choose to follow our online documentation or to see directly the images from your Reachy by following the [notebook n°6](https://github.com/pollen-robotics/reachy2-sdk/blob/develop/src/examples/6_mobile_base.ipynb). ## What is accessible on the mobile base The following elements are accessible with *reachy.mobile_base*: -* mobile base version, * battery level, * odometry of the base, +* lidar * control and drive modes, -* goto and set_speed methods to make the mobile base move. +* goto, translate_by/rotate_by and set_speed methods to make the mobile base move. + + +## Informations + +You can find the infos by calling the attribute mobile_base directly : +```python + reachy.mobile_base + >>>
-The last required step before being able to use your Reachy 2 is to find its IP address. +To be able to connect to your Reachy 2, you first need to be on the same network (either via Ethernet or WiFi). + +Then you need to find your robot's IP address. Unfortunately, you can't use its .local address for the SDK. You have two ways to do that : via the dashboard (the easiest way) or via the LCD screen. + +## Using the dashboard + +You can use your robot name to access the dashboard : for that, you type on a browser `reachy_name.local:8000/`. + +Once you are in the dashboard, you can click on **Network** and you will find the IP addresses of your robot (WiFi and Ethernet). -> Note: if you haven't connected Reachy to a network yet, please first follow the instructions ??? ## Using the LCD screen -If you haven't unplugged it, the LCD screen connected in Reachy's back should be diplaying its IP address. +If you are not able to access the dashboard, you can turn off completely your robot. Then, you can plug the supplied LCD screen on the USB port of the mobile base. -{{< img-center "images/sdk/getting-started/lcd-display.png" 400x "" >}} +Turn on your robot again, and it should display display the robot's IP addresses (alternately Ethernet and WiFi) : -If the LCD screen is not working or is unplugged, check out the page Find my IP section to learn other ways to get the IP address. +{{< img-center "images/sdk/getting-started/IP_address.jpg" 400x "" >}} -You can check that everything is working as expected by running the following Python code: +You can check that everything is working as expected by running the following Python code in a terminal on your virtual environment : -```python +``` +$ python3 from reachy_sdk import ReachySDK # Replace with the actual IP you've found. diff --git a/content/developing-with-reachy-2/getting-started-sdk/installation.md b/content/developing-with-reachy-2/getting-started-sdk/installation.md index c63948d1..87e68365 100644 --- a/content/developing-with-reachy-2/getting-started-sdk/installation.md +++ b/content/developing-with-reachy-2/getting-started-sdk/installation.md @@ -17,12 +17,19 @@ toc: true ## How to install the Python SDK -The Python SDK is a pure Python library. The installation should thus be rather straightforward. +The Python SDK is a pure Python library. The installation should thus be rather straightforward. It supports Python >= 3.10 (older versions will not work because of typing syntax). -It supports Python >= 3.10 (older versions will not work because of typing syntax). It works on Windows/Mac/Linux. +> For now, the library [pollen_vision](pollen-robotics/pollen-vision) used to do ["perception"]({{< ref "ai-with-reachy-2/perception/" >}}), needs Python 3.10, so you may want to have that version. + +It works on Windows/Mac/Linux. + +
+
+
+On Linux
We recommend to use [virtual environment](https://docs.python.org/3/tutorial/venv.html) for your development. They make the installation simple and avoid compatibility issues. They also come with their [pip](https://pip.pypa.io/en/stable/) command. +Inside your virtual environment, you can install the library either from Pypi, or by cloning all the repository : + ### From PyPi ```bash @@ -32,11 +39,72 @@ pip install reachy2-sdk ### From the source ```bash -git clone https://github.com/pollen-robotics/reachy2-sdk +git clone https://github.com/pollen-robotics/reachy2-sdk.git cd reachy2-sdk pip install -e reachy2-sdk ``` +
+ python=3.10 git`, for example `conda create -n reachy python=3.10 git` (to install the supported version of Python and Git with your new environment)
+
+ {{< img "images/sdk/getting-started/create_env.png" 800x "create venv">}}
+
+4. Then activate your virtual environment : `conda activate `
+
+ {{< img "images/sdk/getting-started/activate_env.png" 800x "activate venv">}}
+
+
+### Install the SDK Client :
+
+Inside your virtual environment, you can install the library either from Pypi, or by cloning all the repository :
+
+#### From Pypi
+```bash
+pip install reachy2-sdk
+```
+
+#### From source
+1. Create a folder (for example “Dev”)
+ > `mkdir Dev`
+2. Go in this folder
+ > `cd \Dev\`
+3. Clone the SDK repository in this folder
+ > `git clone https://github.com/pollen-robotics/reachy2-sdk.git`
+4. Go in this new subfolder
+ > `cd \reachy2-sdk\`
+5. Install the library
+ > `pip install -e` . *that command will install all the needed packages and libraries to make the SDK work on your virtual environment*
+
+
+
+
+
+On Windows
+ +We recommend you to use a virtual environment, that will allow you to have all the needed packages to control Reachy without any conflict with already existing packages on your computer. + +### Create the virtual environment : + +1. You can use Miniconda, which is a minimal version of the Anaconda Python distribution. You need to download it [there](https://www.anaconda.com/download/success) : scroll down until you reach the Miniconda Installers and click on the Windows installer. + + {{< img "images/sdk/getting-started/conda_install.png" 500x "miniconda">}} + +2. Launch the .exe you just downloaded and follow the installation procedure. + + {{< img "images/sdk/getting-started/conda_install_2.png" 500x "miniconda installer">}} + +3. Open the Anaconda Powershell Prompt on your applications and type `conda create -n
+
+
+To be sure it worked, you can write `pip list` and check that you have reachy2-sdk.
+
+
## Dependencies
The SDK relies on a few third-party Python packages, such as:
@@ -46,3 +114,7 @@ The SDK relies on a few third-party Python packages, such as:
* [grpc](https://grpc.io) - to connect to the robot
They will be **installed automatically** when you install the SDK.
+
+
+
+{{< warning icon="👉🏾" text="Now that you have reachy2-sdk installed on your computer, you can connect to your robot and learn how to use it with the Getting Started Notebooks. So keep up !" >}}
\ No newline at end of file
diff --git a/content/developing-with-reachy-2/getting-started-sdk/visualize-fake-robot.md b/content/developing-with-reachy-2/getting-started-sdk/visualize-fake-robot.md
index ffd38425..b40053a9 100644
--- a/content/developing-with-reachy-2/getting-started-sdk/visualize-fake-robot.md
+++ b/content/developing-with-reachy-2/getting-started-sdk/visualize-fake-robot.md
@@ -14,4 +14,14 @@ weight: 120
toc: true
---
-*Page in progress*
\ No newline at end of file
+For now, Reachy doesn't have any collision avoidance restrictions (left arm against right arm, arm against torso, etc.).
+
+So before implementing any new behaviour on your Reachy, we recommand you to test your movements on a fake mode. That means that your physical robot won't move but the simulated one will. As so, you will be able to visualize what Reachy will do and to adapt your moves before testing it on the real one.
+
+For that, blablabla
+
+
+Then you can go back to the dashboard, click on **Visualisation tools** and you will see Rviz with your fake Reachy.
+
+
+Now, you are ready to make your robot move ! You can skip to the *Basics*.
diff --git a/content/developing-with-reachy-2/simulation/simulation-installation.md b/content/developing-with-reachy-2/simulation/simulation-installation.md
index 8f4f3b45..93a094e1 100644
--- a/content/developing-with-reachy-2/simulation/simulation-installation.md
+++ b/content/developing-with-reachy-2/simulation/simulation-installation.md
@@ -14,13 +14,15 @@ weight: 400
toc: true
---
-If you want to try movements on the robot without using the real robot, you can install a simulated Reachy 2 on your computer, and run it the same way the real robot is run. The easiest way is using a docker image. We will thus assume that you already have docker installed and setup.
+If you want to try movements on the robot without using the real robot, you can install a simulated Reachy 2 on your computer, and run it the same way the real robot is run. You'll have a rviz window to see the fake robot move.
+
+The easiest way is using a docker image. We will thus assume that you already have docker installed and setup.
Clone the sources of our docker, and pull the sources:
```python
git clone git@github.com:pollen-robotics/docker_reachy2_core.git
cd docker_reachy2_core
-./pull_sources.sh beta
+./sources checkout stable
```
Then download the configuration files:
@@ -31,12 +33,13 @@ cp -r reachy_config_example/.reachy_config ~/
In your docker_reachy2_core folder, compose a container with:
```python
-docker compose -f dev.yaml up -d core
+docker compose -f mode/dev.yaml up -d core
```
> This can take a few minutes to compose.
Build:
```python
+full_build
cbuilds
```
diff --git a/content/help/faq/robot-faq.md b/content/help/faq/robot-faq.md
index 5004ec56..fbe9bcbe 100644
--- a/content/help/faq/robot-faq.md
+++ b/content/help/faq/robot-faq.md
@@ -204,3 +204,18 @@ An `AVG SLOPE SCORE` below `0.1%` is OK.
Ideally it could be under `0.05%`.
The lower, the better.
+
+## 6. Change the sound volume
+
+If you want to change the volume, especially for the starting sound of your robot or the output sound when you teleoperate, you need to go on a terminal **when the webRTC service is running** :
+
+Run:
+```console
+$ ssh bedrock@your_robot_ip #password : root
+$ docker exec -it webrtc_streaming_playback_ros bash
+$ alsamixer -c 1
+```
+
+Then, you can set the volume as you wish.
+
+
diff --git a/content/help/faq/sdk-faq.md b/content/help/faq/sdk-faq.md
index 0c38b61a..208a0e7a 100644
--- a/content/help/faq/sdk-faq.md
+++ b/content/help/faq/sdk-faq.md
@@ -23,3 +23,9 @@ Check all logs of the service with:
```bash
journalctl -b -u reachy2-core
```
+
+> *I execute a command in the SDK but nothing happens on my robot*
+
+Check that you are not on a fake mode (mode that only makes the virtual robot moves in the visualisation tools of the dashboard but not the real one) : for that, you can type `reachy.info` and check the mode is not 'FAKE'. If so, the simplest way to undo it is to reboot entirely your robot.
+
+Check on the dashboard services that everything is fine, especially in the reachy2-core logs. If you see errors, restart the core.
diff --git a/content/help/faq/teleoperation-faq.md b/content/help/faq/teleoperation-faq.md
index 784a1725..d0ac182a 100644
--- a/content/help/faq/teleoperation-faq.md
+++ b/content/help/faq/teleoperation-faq.md
@@ -14,10 +14,33 @@ toc: true
weight: 230
---
+## Problems with the app
+
+> *The app is lagging a lot, what can I do ?*
+
+Check that your computer is plugged (note that for some laptops, they must be plugged in as soon as they are switched on).
+
+If that doesn’t resolve the lag, maybe your network is overloaded, you can try change your robot’s and your computer’s network (you don’t need to have internet for it to work, it can work on a isolated router). Check that there is no driver update available on your VR device (for Oculus Quest, you can see them on top of your MetaQuestLink app on your computer, if your device is plugged).
+
+Finally, it can be a GPU issue : FAQ GPU.
+
+
+> *When I hit “play”, I have a loading page in my device and I never enter the app*
+
+Go to Edition > Project Settings > XR Plug-in Management. Check that Initialize XR on Start-Up and Oculus are selected. If so, try to unselect the first one and try again.
+
+> *Tunnelling appears only in one eye*
+
+Go to Edition > Project Settings > XR Plug-in Management > Oculus > Stereo rendering mode : select multi pass and try again.
+
+
+
## Problem with the cameras or sound
### With teleoperation application
+Check in your laptop settings that your device is selected in “Output”. Check also that you don’t have an audio device connected by Bluetooth that can interfere.
+
During teleoperation, the cameras and sound are managed by the webrtc service.
This service is automatically launched when you start Reachy 2 computer.
@@ -31,3 +54,5 @@ Check all logs of the service with:
```bash
journalctl -b -u webrtc
```
+
+
diff --git a/layouts/index.html b/layouts/index.html
index 77250363..82531432 100644
--- a/layouts/index.html
+++ b/layouts/index.html
@@ -45,9 +45,9 @@ On Mac
+ +To be done. + +Tutorials
-
-
+
+
+ Image not found: {{ .Get 0 }} +
+{{ end }} diff --git a/layouts/shortcodes/img.html b/layouts/shortcodes/img.html index 11b628aa..6abc7b8f 100644 --- a/layouts/shortcodes/img.html +++ b/layouts/shortcodes/img.html @@ -1,3 +1,7 @@ {{ $image := resources.Get (.Get 0) }} -{{ $image := $image.Resize (.Get 1) }} -Image not found : {{ .Get 0 }}
+{{ end }} \ No newline at end of file diff --git a/static/gifs/tutorials/gif_awake.gif b/static/gifs/tutorials/gif_awake.gif new file mode 100644 index 00000000..4fff3ed8 Binary files /dev/null and b/static/gifs/tutorials/gif_awake.gif differ diff --git a/static/gifs/tutorials/gif_oranges.gif b/static/gifs/tutorials/gif_oranges.gif new file mode 100644 index 00000000..d80d131d Binary files /dev/null and b/static/gifs/tutorials/gif_oranges.gif differ diff --git a/static/gifs/tutorials/gif_rope.gif b/static/gifs/tutorials/gif_rope.gif new file mode 100644 index 00000000..9523c062 Binary files /dev/null and b/static/gifs/tutorials/gif_rope.gif differ