2_Reachy_the_mime.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial n°2 - SDK : Reachy the mime\n",
    "\n",
    "In this tutorial, we will learn how to do a more complex task with Reachy using the SDK client, with both arms and the mobile base, all moving together at the same time !\n",
    "\n",
    "Here, we are going to transform Reachy into a mime who pulls an invisible rope. \n",
    "\n",
    "What you will learn : \n",
    "\n",
    "- How to use the mobile base,\n",
    "- How to synchronize arms and mobile base movements,\n",
    "- How and when to use blocking gotos,\n",
    "- How to follow a trajectory with the end effector.\n",
    "\n",
    "\n",
    "\n",
    "## 1. Prerequisites\n",
    "\n",
    "To use the SDK client, you first need to install *reachy2-sdk*. If it is not the case, checkout the section below 👇\n",
    "<details>\n",
    "\n",
    "<summary>Install the Python library reachy2-sdk</summary>\n",
    "\n",
    "In general, you'd better **work in a virtual environment**. You have 2 different ways to install the sdk : \n",
    "- by running the following command:\n",
    "\n",
    "<code>\n",
    "pip install reachy2-sdk -e .\n",
    "</code>\n",
    "\n",
    "- from source by following the instructions on the [GitHub repository](https://github.com/pollen-robotics/reachy2-sdk)\n",
    "\n",
    "</details>\n",
    "\n",
    "If you have never used the SDK client before, don't forget to do the [Getting Started notebooks](https://github.com/pollen-robotics/reachy2-sdk/tree/develop/src/examples), that will help you understand all the basics you need to know about it ! And if you want to go further, you can also check the [SDK documentation](https://pollen-robotics.github.io/reachy2-sdk/reachy2_sdk.html). \n",
    "\n",
    "> Note: this version of the tutorial is made for **version 1.0.10+ of reachy2-sdk**\n",
    "\n",
    "## 2. Setup\n",
    "\n",
    "### 2.1. Material\n",
    "\n",
    "For this tutorial, you'll only need Reachy, and that's it ! \n",
    "\n",
    "Generally speaking, before making the real robot move, working on a **virtual Reachy is strongly recommended** to visualize the movements and try to modify them. For that, you can follow the [documentation](https://pollen-robotics.github.io/reachy2-docs/developing-with-reachy-2/simulation/simulation-installation/) and instanciate a ReachySDK with the *IP = 'localhost'*. Once you're sure that all your moves are safe for the robot, you can work on the real Reachy. \n",
    "Just know that for this tutorial, you won't be able to test it entirerely on the fake robot, as the mobile base is not set on virtual Reachy in Rviz. \n",
    "\n",
    "### 2.2. Scene\n",
    "\n",
    "> Your Reachy must be at a sufficient **height** so that its outstretched arms do not touch the mobile base. \n",
    "\n",
    "Put Reachy in a safe environment with enough place to move around, no one in reachable space and no obstacles (as there are no safety yet preventing the robot from colliding with its environment). And always keep the emergency stop button nearby! \n",
    "\n",
    "\n",
    "\n",
    "## 3. Preview\n",
    "\n",
    "In this tutorial, we'll build step by step the program that will enable Reachy to pull a rope. Here, you can have a look at what Reachy will do at the end :\n",
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"images/gif_rope.gif\" alt=\"Gif preview\" style=\"width: 30%; display: inline-block;\"/>\n",
    "</p>\n",
    "\n",
    "Now that you are all set, let's dig into it ! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Let's build it ! \n",
    "\n",
    "### 4.1. Instanciation of the SDK\n",
    "\n",
    "First, we will connect to the robot. To do so, we need to import the SDK client package and to instanciate a ReachySDK.\n",
    "\n",
    "Two requirements :\n",
    "- Your computer needs to be on the same network as the robot.\n",
    "- You need to know your Reachy's IP : to do so, you have two options : \n",
    "    - you can check it on the dashboard (*.local_IP_address_of_your_robot:8000* in a browser), section Network. \n",
    "    - you can have a look at the small screen on Reachy's back, that will show you one at a time its Ethernet and its Wifi IP. \n",
    "\n",
    "> 💡 You'll see that it's really easy to mistakenly run on the real robot before testing in simulation. So you can add a security on your code : if you put the IP of a real robot, the program will ask you a confirmation by pressing \"y\" or \"yes\" before executing anything. \n",
    "\n",
    "Now, let's connect to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the package\n",
    "from reachy2_sdk import ReachySDK\n",
    "\n",
    "IP = \"localhost\" # Change the IP to your Reachy's when you are ready to run the code for real\n",
    "\n",
    "# add the security check\n",
    "fake = IP == \"localhost\"\n",
    "\n",
    "if not fake:\n",
    "    res = input(\"Are you sure you want to execute on the real robot ? (y/N)\")\n",
    "    if res.lower() not in [\"y\", \"yes\"]:\n",
    "        print(\"Aborted.\")\n",
    "        exit()\n",
    "\n",
    "# connect to the robot        \n",
    "reachy = ReachySDK(IP)\n",
    "reachy.is_connected()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are getting the message \"Could not connect to Reachy\", make sure that :\n",
    "-  Reachy is turned on\n",
    "- the reachy2_core.service is running \n",
    "- the IP address is correct. \n",
    "\n",
    "*More info on the debug section of the [sdk documentation](https://pollen-robotics.github.io/reachy2-docs/help/help/recovering/).<br>*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2. Set Reachy ready\n",
    "\n",
    "### 4.2.1. Turn it on\n",
    "\n",
    "Reachy has its motors off by default. So first, we need to turn them on. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.turn_on()\n",
    "print(f\"Reachy's motors are on : {reachy.is_on()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we are going to place the robot in a neutral position, with the head looking straight ahead and the arms alongside its torso. You can use the *goto_posture* method to do so. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.goto_posture('default')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.2. The mobile base\n",
    "\n",
    "Now, let's talk a little about how the mobile base works. \n",
    "\n",
    "To make it move, we have two ways : \n",
    "- *goto(x, y, theta)* method\n",
    "- *translate_by(x,y)* and *rotate_by(theta)* methods\n",
    "\n",
    "\n",
    "#### Goto method  :\n",
    "\n",
    "We set the **absolute** target position of the mobile base. Well, it's absolute, relative to the position it was when Reachy was started, or relative to the last position where `reset_odometry()` was called. \n",
    "    \n",
    "For example, let's say we just powered the robot. The position of the mobile base is currently `x = 0, y = 0, theta = 0`, `(0, 0, 0)`. \n",
    "    \n",
    "Now if we call `reachy.mobile_base.goto(0.2, 0, 0)`, after the robot has moved, its position is `(0.2, 0, 0)`. If we call `reachy.mobile_base.goto(0.2, 0, 0)` again, nothing will happen because Reachy is already at this position. \n",
    "    \n",
    "Now if we call `reachy.mobile_base.reset_odometry()`, it will reset the mobile base's position, meaning its position is now `(0, 0, 0)` again, without moving the mobile base. Its new origin is the current position.\n",
    "    \n",
    "To be safe, we always call `reset_odometry()` before running our code here, because we may not know how the mobile base moved before. \n",
    "\n",
    "\n",
    "#### Translate_by / rotate_by methods: \n",
    "\n",
    "You are safe, the reference position is always Reachy's current position.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that Reachy is on, we are going to reset the odometry to be sure : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.mobile_base.reset_odometry()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2.3. Set the initial position\n",
    "\n",
    "Now, let's set Reachy in an initial position where its elbows are at 90° and grippers are open. Conveniently, there is a feature in the SDK to do just that !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.goto_posture('elbow_90', open_gripper=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, turn its head to the left. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.head.goto([0,10,50])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We save the current poses of the end effectors in *right_start_pose* and *left_start_pose* (as 4x4 homogeneous matrices), because we will build the next moves relative to these starting poses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save current effector poses \n",
    "right_start_pose = reachy.r_arm.forward_kinematics()\n",
    "left_start_pose = reachy.l_arm.forward_kinematics()\n",
    "\n",
    "print(f\"Right arm start pose:\\n {right_start_pose} \\nLeft arm start pose:\\n {left_start_pose}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For reference, these are the frames we'll be working with : \n",
    "\n",
    "<p align=\"center\">\n",
    "  <img src=\"images/frame_reachy_default_pose.png\" alt=\"Screenshot 1\" width=\"300\"/>\n",
    "  <img src=\"images/frame_reachy_elbow90_pose.png\" alt=\"Screenshot 2\" width=\"300\"/>\n",
    "</p>\n",
    "\n",
    "We consider the origin of the world to be Reachy's torso. So when we say we translate or rotate in \"absolute\", it means relative to Reachy's torso frame. \n",
    "\n",
    "> 💡 One important thing to notice is the gripper frames. You can see that they are oriented the same way as the torso when the arms are in the **default** position, meaning along the body. Now look at what happens when we set the arms at 90° : forward is `-z`, right is `-y` and up is `+x`. This can be a little counter intuitive when computing poses in the gripper's reference frame, so keep that in mind!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reachy is now ready to start, let's move on to the next step !\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3. Build the sequence\n",
    "\n",
    "The mime sequence is composed of several parts to be synchronized together : \n",
    "- extension of one arm and gripper closing\n",
    "- flexion of the other arm\n",
    "- translation of the mobile base\n",
    "\n",
    "The easiest way to build it (and it is a general rule when implementing complex behavior on the robot) is to break it down into smaller parts and implement them one by one independently. Once each part is working, you can combine them to create the full sequence.\n",
    "\n",
    "Let's start with the first part ! \n",
    "\n",
    "\n",
    "#### 4.3.1. Extension of the arm\n",
    "\n",
    "Let's compute the extended position for the right end effector. We start from the reference pose and : \n",
    "- adjust the position forwards and towards the middle\n",
    "- rotate the effector to be perpendicular to the ground and in the robot's *x* axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from reachy2_sdk.utils.utils import rotate_in_self\n",
    "\n",
    "right_extend = right_start_pose.copy()\n",
    "# Translate by 0.1m in the absolute x direction and by 0.2m in the absolute y direction\n",
    "right_extend[:3, 3] += [0.1, 0.2, 0.0] \n",
    "# Rotate the end effector by 60° around y and -90° around z in the gripper's frame\n",
    "right_extend = rotate_in_self(right_extend, [0, 60, -90]) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have our goal pose, let's Reachy make the move to reach it and when the move is done, close the gripper :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.r_arm.goto(right_extend, duration=1.5, wait=True)\n",
    "reachy.r_arm.gripper.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is what you should see :\n",
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"images/pull_rope_1.gif\" alt=\"Gif 1\" width=\"30%\">\n",
    "</p>\n",
    "\n",
    "\n",
    "\n",
    "💡 Here, notice that the wait parameter is set to True in our call to *goto*(). \n",
    "\n",
    "> By default, the goto functions are not blocking, as the default value of *wait* is False, that means they're **not blocking calls** and they will execute asynchronously. They are executed in a separate thread, so they won't block the main thread, meaning the next instruction will be executed at the same time. \n",
    "\n",
    "Here, and typically in python, the function you call is **blocking**, meaning we have to wait for it to finish executing before executing the next instruction. That allows us to be sure that the gripper will close only when the arm has finished its movement. Without the addition of the *wait=True* parameter, the gripper would have closed during arm movement. You can change the parameter to see for yourself! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's move on to the next part. \n",
    "\n",
    "#### 4.3.2. Flexion of the arm\n",
    "\n",
    "Now, we want the right arm to translate along the `x` direction (by 0.2 meters), like if it had grasped a rope and pulled on it. \n",
    "\n",
    "We can use the translate_by() method for that. Go ahead and make the arm move : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.r_arm.translate_by(-0.2, 0, 0, duration=1.5, wait=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great ! Now, we need to make the mobile base move too. \n",
    "\n",
    "#### 4.3.3. Translation of the mobile base\n",
    "\n",
    "We want the mobile base to move forward by the same amount the right arm has moved to create the illusion that Reachy pulled itself. We can use the goto function to do that. Make the mobile base move now : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.mobile_base.goto(0.2,0,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3.4. Make it work together\n",
    "\n",
    "Now, we need to put all this moves work together at the same time. We want : \n",
    "- one arm to go in position to catch the rope\n",
    "- the other arm to go backwards to pull the rope\n",
    "- the mobile base to go forward\n",
    "\n",
    "First, let's go back to the beginning by moving the mobile base to its origin and by making Reachy's arms get the elbow_90 posture with open grippers: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.mobile_base.goto(x=0, y=0, theta=0)\n",
    "reachy.l_arm.goto_posture('elbow_90', open_gripper=True)\n",
    "reachy.r_arm.goto_posture('elbow_90', open_gripper=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we make Reachy's right arm catch the rope as before : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.r_arm.goto(right_extend, duration=1.5, wait=True)\n",
    "reachy.r_arm.gripper.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We build the left extend pose the same way as with the right arm, except that the translation on the y axis needs to be negative this time, to be close to the middle. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_extend = left_start_pose.copy()\n",
    "left_extend[:3, 3] += [0.1, -0.2, 0.0]\n",
    "left_extend = rotate_in_self(left_extend, [0, 60, 90])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we make all the other moves work together : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "## launch simultaneously all the moves \n",
    "# make the left arm go catch the rope\n",
    "goto_id = reachy.l_arm.goto(left_extend, duration=2.0, wait=False) # Non-blocking\n",
    "\n",
    "# make the right arm pull the rope\n",
    "reachy.r_arm.translate_by(-0.2, 0, 0, duration=1.5, wait=False) # Non-blocking\n",
    "\n",
    "# move the mobile base forward\n",
    "reachy.mobile_base.goto(0.2, 0, 0)\n",
    "\n",
    "\n",
    "## Wait for the end of the left arm move to close the gripper\n",
    "if goto_id.id != 0:\n",
    "    while not reachy.is_goto_finished(goto_id):\n",
    "        time.sleep(0.1)\n",
    "reachy.l_arm.gripper.close()\n",
    "\n",
    "time.sleep(2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a moment to understand what's going on here.\n",
    "\n",
    "`reachy.arm.goto()` returns a `goto id`. This `goto id` allows us to ask the SDK if this move is finished using `reachy.is_goto_finished(goto_id)`. \n",
    "\n",
    "Here, we want to move both arms at the same time. But their durations are not the same (2.0s and 1.5s). We run all the moves in non blocking mode (left arm, right arm and mobile base), but then we want to wait for the first move to end before continuing. To do that, we can block the execution until `reachy.is_goto_finished(goto_id)` is True. \n",
    "\n",
    "That's what we do here with the `while not reachy.is_goto_finished(goto_id):` instruction.\n",
    "\n",
    "The full move now looks like this : \n",
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"images/pull_rope_2.gif\" alt=\"Gif 2\" width=\"30%\">\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3.5. Follow a trajectory\n",
    "\n",
    "Now, we want :\n",
    "- the left arm to translate along `x`the same way the right arm just did\n",
    "- the right arm to go back into position to be ready to pull again\n",
    "- the mobile base to move forward again\n",
    "\n",
    "Here is where things get interesting. If we used default `arm.translate_by()` or `arm.goto()`, we have no guarantee that the arms won't collide together performing their respective moves (spoiler alert : they will). \n",
    "\n",
    "So we want the right arm to go back the extended position by following a trajectory that will avoid the left arm.\n",
    "\n",
    "To do that, we can use the feature that interpolates trajectory tracking: setting the goto interpolation space to `cartesian_space`, and using the `elliptical` interpolation_mode to follow a semi-circular trajectory until the target position. \n",
    "With the *arc_direction* parameter set to \"right\", the semi circle trajectory will be in the `(x, y)` plane, going to the right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# open the gripper\n",
    "reachy.r_arm.gripper.open()\n",
    "\n",
    "# move the mobile base forward\n",
    "reachy.mobile_base.translate_by(0.2, 0)\n",
    "\n",
    "# move the left arm to pull the rope\n",
    "reachy.l_arm.translate_by(-0.2, 0, 0, duration=1.5, wait=False)\n",
    "\n",
    "# move the right arm to catch the rope with a semi-circular trajectory\n",
    "reachy.r_arm.goto(\n",
    "    right_extend,\n",
    "    duration=1.3,\n",
    "    interpolation_space='cartesian_space',\n",
    "    interpolation_mode='elliptical',\n",
    "    arc_direction=\"right\",\n",
    "    wait=True,\n",
    ")\n",
    "\n",
    "# close the gripper\n",
    "reachy.r_arm.gripper.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look at the trajectory of the right arm !\n",
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"images/pull_rope_3.gif\" alt=\"Gif 3\" width=\"30%\">\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we just have to do the same with the left arm !\n",
    "So at the same time, we : \n",
    "- open the left gripper\n",
    "- move forward the mobile base\n",
    "- pull the invisible rope with the right arm \n",
    "- move forward the left arm, using a semi-circular trajectory to the left this time\n",
    "\n",
    "Then we close the left gripper. \n",
    "\n",
    "You can do it on your robot : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# open the left gripper\n",
    "reachy.l_arm.gripper.open()\n",
    "\n",
    "# move the mobile base forward\n",
    "reachy.mobile_base.translate_by(0.2, 0)\n",
    "\n",
    "# move the right arm to pull the rope\n",
    "reachy.r_arm.translate_by(-0.2, 0, 0, duration=1.5, wait=False)\n",
    "\n",
    "# move the left arm to catch the rope with a semi-circular trajectory\n",
    "reachy.l_arm.goto(\n",
    "    left_extend,\n",
    "    duration=1.3,\n",
    "    interpolation_space='cartesian_space',\n",
    "    interpolation_mode='elliptical',\n",
    "    arc_direction=\"left\",\n",
    "    wait=True,\n",
    ")\n",
    "\n",
    "# close the left gripper\n",
    "reachy.l_arm.gripper.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well done ! You did it ! Now that you understood how to do it, you can continue to move Reachy forward, or make a U-turn via the mobile base (*reachy.mobile_base.rotate_by(180)*), or do the same sequence but in reverse! \n",
    "\n",
    "Don't hesitate to try out and practice all Reachy's features ! \n",
    "\n",
    "Once you've finished, you can return Reachy to its initial position and log off. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.goto_posture('elbow_90', duration = 3, wait = True)\n",
    "reachy.turn_off_smoothly()\n",
    "reachy.disconnect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Final tips\n",
    "\n",
    "Now, you've learned how to build a sequence on Reachy using only the SDK Client with: \n",
    "- arms movements\n",
    "- mobile base movements\n",
    "- trajectory following\n",
    "- synchronization between Reachy's parts\n",
    "\n",
    "You can now use this sequence as a starting point to create other complex behaviors on the robot. Feel free to modify the movements, the duration of the movements, the order of the movements, etc. to get more familiar with the SDK, the robot and to check whether you can make Reachy do what you want it to do ! \n",
    "\n",
    "Here are some general tips to keep in mind to be the best at implementing complex behaviors on Reachy:\n",
    "\n",
    "- **Always test behavior** on a fake robot before running it on the real robot! This will help you check if the behavior is doing what you expect it to do and to avoid any potential damage to the robot.\n",
    "- If you are working on the real robot, make sure that it has enough space around it to move its arms and head, and **always** have the emergency shutdown nearby. Especially, make sure that the arms will not be blocked by objects such as a table as there are no safety yet preventing the robot for colliding with its environment.\n",
    "- Split the behavior you wish to develop into smaller parts and implement them one by one. Once each part is working, you can combine them to create the full sequence. Go slow and test each part before moving on to the next one. \n",
    "\n",
    "\n",
    "## 6. Skip to the next tutorial ! \n",
    "\n",
    "Here, we've covered just a few of the methods that can be used on Reachy. To discover more ways of controlling the robot, don't hesitate to continue following the tutorials ! \n",
    "\n",
    "1. Reachy's awakening (with SDK only)\n",
    "\n",
    "**2. Reachy the mime (with SDK only)**\n",
    "\n",
    "3. Reachy the greengrocer (with SDK & Pollen-Vision)\n",
    "\n",
    "\n",
    "Keep up and you'll be soon an expert to control Reachy ! "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "reachy10",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}