1_Reachy_awakening.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "48929c36",
   "metadata": {},
   "source": [
    "# Tutorial n°1 - SDK : Reachy's awakening\n",
    "\n",
    "In this tutorial, we will learn how do a task with Reachy using the SDK client. \n",
    "\n",
    "Here, we are going to make Reachy do the awake sequence, which is a series of movements that makes it look like it is waking up. It involves moving its head and arms and can be used as a starting point for more complex sequences.\n",
    "\n",
    "What you will learn:\n",
    "- How to make it move its head\n",
    "- How to make it move its arms\n",
    "- How to synchronize head and arms movements\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",
    "## 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/getting-started-sdk/visualize-fake-robot/) 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",
    "\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 look like it's awakening. Here, you can have a look at what Reachy will do at the end :\n",
    "\n",
    "<p align=\"center\">\n",
    "  <img src=\"images/gif_awake.gif\" alt=\"Gif 1\" width=\"30%\">\n",
    "</p>\n",
    "\n",
    "Now that you are all set, let's dig into it ! "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f9b7fb3",
   "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_adress_of_your_robot:8000*), 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",
    "Now, let's connect to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1686373e-3b8b-4865-8672-c55f784dd1b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import the package\n",
    "from reachy2_sdk import ReachySDK\n",
    "\n",
    "#connect to the robot\n",
    "reachy = ReachySDK(host=\"localhost\")  # replace 'localhost' with the actual IP address of your Reachy\n",
    "print(\"Reachy is connected :\", reachy.is_connected())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7184992",
   "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",
   "id": "75a19efe",
   "metadata": {},
   "source": [
    "### 4.2. Set Reachy ready\n",
    "\n",
    "Reachy has its motors off by default. So first, we need to turn them on. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "951b9c69",
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.turn_on()\n",
    "print(f\"Reachy's motors are on : {reachy.is_on()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3601390",
   "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,
   "id": "11e26011",
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.goto_posture(\"default\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfd36767",
   "metadata": {},
   "source": [
    "Is your Reachy looking like this?\n",
    "\n",
    "<p align=\"center\">\n",
    "  <img width=200 src=\"images/default_position.png\" alt=\"Default position of Reachy\" />\n",
    "</p>\n",
    "\n",
    "Great! Let's start implementing the awake sequence!\n",
    "\n",
    "*If not, you may need to restart the core of your robot and go back from the beginning*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "842ed49d",
   "metadata": {},
   "source": [
    "### 4.3. Build the sequence\n",
    "\n",
    "The awake sequence is composed of four parts:\n",
    "1. Reachy \"sleeps\", i.e. the arms are swinging alongside its torso and the head is nodding slowly\n",
    "2. Reachy looks like it is waking up, lifting its head and moving it from side to side\n",
    "3. Reachy lifts its arms, moves them one by one and follows with its head the effector of the moving arm\n",
    "4. Reachy nods and gets back to its default position\n",
    "\n",
    "The easiest way to implement 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: making Reachy \"sleep\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "558ec58f",
   "metadata": {},
   "source": [
    "#### 4.3.1. Asleep part\n",
    "\n",
    "During the asleep sequence, the head of Reachy moves slowly up and down and the arms are outstretched, swinging back and forth. We will implement this sequence first.\n",
    "\n",
    "##### Head movement\n",
    "\n",
    "We will use the *look_at* method to make Reachy's head move up and down. The *look_at* method makes Reachy's head look at a specific point in the robot's frame. We will make Reachy's head look at a point that is above its current position and then below its current position. This will make Reachy's head move up and down.\n",
    "\n",
    "*If you want more details about the mentioned methods, feel free to check the [documentation](https://pollen-robotics.github.io/reachy2-sdk/reachy2_sdk/parts/head.html) !*\n",
    "\n",
    "Let's define a function that makes Reachy's head move up and down. We will call this function `asleep_head`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aeed105a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def asleep_head(reachy: ReachySDK):\n",
    "    for _ in range(2):\n",
    "        reachy.head.look_at(x=0.50, y=0.0, z=-0.20, duration=2.0, wait=False)\n",
    "        reachy.head.look_at(x=0.50, y=0.0, z=-0.30, duration=2.0, wait=False)\n",
    "\n",
    "print(\"Function asleep_head defined.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd4567cd",
   "metadata": {},
   "source": [
    "Notice that the head will move up and down in a short range. If you want to make the head move in a larger range, just change the value of the z-coordinate in the look_at method.\n",
    "\n",
    "Here, the parameter *wait* is set to False : we will not wait for the end of the movements in this part of the sequence as we want Reachy to move its head and arms simultaneously later.\n",
    "\n",
    "Now, you can try it out and check Reachy's head!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1f876db",
   "metadata": {},
   "outputs": [],
   "source": [
    "asleep_head(reachy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b925d84",
   "metadata": {},
   "source": [
    "##### Arm movement\n",
    "\n",
    "There are different methods available to make Reachy's arms move: *goto* (with the list of joint positions or the goal pose of the effector), *translate_by* and *rotate_by*. Depending on the movement you want to achieve, you will prefer one over the others.\n",
    "\n",
    "There, we want Reachy's arms to swing back and forth, standing straight on each side of the torso. \n",
    "\n",
    "The simplest way to do it is to place the arms in the default posture, get the current positions of the arms' joints and change the articular value of the shoulder pitch joint, by using the *goto* method. As you learned in the [SDK example](https://github.com/pollen-robotics/reachy2-sdk/blob/develop/src/examples/3_arm_and_gripper.ipynb), the list of joints is as follow : [shoulder pitch, shoulder roll, elbow yaw, elbow pitch, wrist roll, wrist pitch, wrist yaw], so we will change the first value of the list.\n",
    "\n",
    "Let's define a function that makes Reachy's arms swing back and forth. We will call this function `asleep_arms`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5cb3122",
   "metadata": {},
   "outputs": [],
   "source": [
    "def asleep_arms(reachy: ReachySDK):\n",
    "    #first, define goal pitch positions for the left arm\n",
    "    jpl = reachy.l_arm.get_current_positions() # Considering the arms are in the default position\n",
    "    jpl_front = jpl.copy()\n",
    "    jpl_front[0] += 6.0\n",
    "    jpl_back = jpl.copy()\n",
    "    jpl_back[0] -= 6.0\n",
    "\n",
    "    #then, for the right arm\n",
    "    jpr = reachy.r_arm.get_current_positions()\n",
    "    jpr_front = jpr.copy()\n",
    "    jpr_front[0] += 6.0\n",
    "    jpr_back = jpr.copy()\n",
    "    jpr_back[0] -= 6.0\n",
    "\n",
    "    for _ in range(2):\n",
    "        # Move left arm backward and right arm forward first and then vice versa\n",
    "        reachy.l_arm.goto(jpl_back, duration=2.0, wait=False)\n",
    "        reachy.l_arm.goto(jpl_front, duration=2.0, wait=False)\n",
    "\n",
    "        reachy.r_arm.goto(jpr_front, duration=2.0, wait=False)\n",
    "        reachy.r_arm.goto(jpr_back, duration=2.0, wait=False)\n",
    "\n",
    "    #go back to the default posture for both arms\n",
    "    reachy.l_arm.goto_posture(\"default\", wait=False)\n",
    "    reachy.r_arm.goto_posture(\"default\", wait=True)\n",
    "\n",
    "print(\"Function asleep_arms defined.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29e741be",
   "metadata": {},
   "source": [
    "Now, try the function on Reachy and check its arms!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0db6121b",
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.goto_posture(\"default\", wait=True)\n",
    "\n",
    "asleep_arms(reachy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "040c8f81",
   "metadata": {},
   "source": [
    "Notice that the arms swing back and forth in a desynchronized way. When the left arm is moving forward, the right arm is moving backward.\n",
    "\n",
    "For the range of the arm movement, we chose a range of 12 degrees for the shoulder pitch joint. If you want to change the range of the movement, just change the value 6.0 in the fonction.\n",
    "\n",
    "##### Combine the head and arm movements\n",
    "\n",
    "Now that we have implemented both arms and head movements separately and validate them, we can combine them to make the full asleep behavior in a single function `asleep`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "328e9160",
   "metadata": {},
   "outputs": [],
   "source": [
    "def asleep(reachy: ReachySDK):\n",
    "    asleep_head(reachy)\n",
    "    asleep_arms(reachy)\n",
    "\n",
    "print(\"Function asleep defined.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b44a15ac",
   "metadata": {},
   "source": [
    "Let's try the function! You should see both sequence for the head and the arms running simultaneously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dc4d88e",
   "metadata": {},
   "outputs": [],
   "source": [
    "reachy.goto_posture(\"default\", wait=True)\n",
    "\n",
    "asleep(reachy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73a2a429",
   "metadata": {},
   "source": [
    "> 💡 One important thing to notice is that in order to make the movements of the head and arms synchronized, we need NOT to wait for the end of the movements of the head when we start the movements of the arms (hence the *wait=False* argument in the *look_at* calls). \n",
    "> Same goes for the arms, if we wait for the end of the movement, let's say of the left arm before starting the right arm, the movements will be desynchronized.\n",
    "Calling the *look_at* and *goto* methods with *wait=False* will load the movements in the goto queue of the SDK which will run them one by one sequentially for each part (left arm, right arm and head).\n",
    "\n",
    "Try to change some of the *wait* arguments to True, to check how it is impacting the movements !\n",
    "\n",
    "Because the duration of the movement of the head and of each arm is the same (4 seconds), we only need to wait for the end of the last movement to be sure that the whole asleep behavior is finished (here we arbitrarily chose to wait for the end of the right arm movement)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e798110d",
   "metadata": {},
   "source": [
    "That's it for the asleep part! We can now move on to the next part of the awake sequence: making Reachy looks like it is waking up."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "527b7241",
   "metadata": {},
   "source": [
    "#### 4.3.2. Waking up part\n",
    "\n",
    "Now, we want Reachy to lift its head and move it from side to side. \n",
    "\n",
    "We are going to define a single function called `head_awake_sequence` to set all the sequence. We can use *look_at* method, with long duration moves to make it look like it's waking up slowly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "423b4a44",
   "metadata": {},
   "outputs": [],
   "source": [
    "def head_awake_sequence(reachy: ReachySDK):\n",
    "    # Lift the head up slowly (it is supposed to be just waking up)\n",
    "    reachy.head.look_at(x=0.5, y=0.0, z=0.0, duration=4.0, wait=False)\n",
    "\n",
    "    # Look left and right\n",
    "    reachy.head.look_at(x=0.5, y=-0.2, z=-0.2, duration=2.0, wait=False)\n",
    "    reachy.head.look_at(x=0.5, y=0.0, z=-0.05, duration=2.0, wait=False)\n",
    "    reachy.head.look_at(x=0.5, y=0.2, z=-0.2, duration=2.0, wait=False)\n",
    "\n",
    "    # Look straight ahead again\n",
    "    reachy.head.look_at(x=0.5, y=0.0, z=0.0, duration=2.0, wait=True)\n",
    "\n",
    "print(\"Function head_awake_sequence defined.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3efae99d",
   "metadata": {},
   "source": [
    "You can now try it on the robot ! \n",
    "\n",
    "> 💡 Note that we only wait for the last *look_at* to be finished to consider the sequence done. However in this case, since only head movements are composing the awake sequence and are performed one after the other, we could have set wait=True for every *look_at* call, without making any difference. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13b87053",
   "metadata": {},
   "outputs": [],
   "source": [
    "head_awake_sequence(reachy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e29a3a8",
   "metadata": {},
   "source": [
    "Perfect ! Now, we can move on to the next step. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a9e0bc5",
   "metadata": {},
   "source": [
    "#### 4.3.3. Arms swinging and end effector tracking\n",
    "\n",
    "Now, we want Reachy to lift its arms, move them one by one and follow the effector of the moving arm with its head.\n",
    "\n",
    "This part is a bit more complex as it involves moving the arms and the head simultaneously and making the robot track itself. \n",
    "\n",
    "But don't worry, we are going to break down how we can implement this behavior:\n",
    "\n",
    "\n",
    "1. **Lift the arms and move them one by one**: here we want to place the arms at 90 degree angle and move them one by one forward and backward. \n",
    "- To lift the arms at 90 degree angle, we will just call the *goto_posture* method which has it as a predefined posture available.\n",
    "- To move the arm, we can use the *translate_by* method : it allows us not to worry about the joints positions needed for this nor getting the appropriate pose matrices for a *goto* call.  We only need to specify the offset from the current pose in the robot's frame that we want to apply to the effector of the arm. </br>\n",
    "\n",
    "\n",
    "2. **Make the head follow the moving arm effector** : as before, we will use the *look_at* method which takes as argument the coordinates x, y, z of a point in the robot's frame. Good news is that we can easily get the coordinates of the effector center in the robot's frame by calling the *forward_kinematics* method of the arm. We will use it to get the coordinates of the moving arm effector and make the head look at this point.\n",
    "\n",
    "And we can define a function `arm_swing_and_effector_tracking` to deal with this entire behavior.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1efebea4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def arm_swing_and_effector_tracking(reachy: ReachySDK):\n",
    "    # Put the arms at 90 degrees angle and wait for it to be done\n",
    "    reachy.goto_posture(\"elbow_90\", wait=True)\n",
    "\n",
    "    for arm in [reachy.l_arm, reachy.r_arm]:\n",
    "        x, y, z = arm.forward_kinematics()[:3, 3]\n",
    "        # The first look_at has a longer duration to avoid a sudden head movement\n",
    "        reachy.head.look_at(x=x, y=y, z=z, duration=1.5, wait=True)\n",
    "\n",
    "        arm.translate_by(x=0.2, y=0.0, z=0.1, wait=False) \n",
    "        arm.translate_by(x=-0.2, y=0.0, z=-0.1, wait=False)\n",
    "        arm.translate_by(x=0.2, y=0.0, z=0.1, wait=False)\n",
    "        last_gotoid = arm.translate_by(x=-0.2, y=0.0, z=-0.1, wait=False)\n",
    "\n",
    "        # while the arm is moving, the head is tracking the effector\n",
    "        while not reachy.is_goto_finished(last_gotoid):\n",
    "            x, y, z = arm.forward_kinematics()[:3, 3]\n",
    "            reachy.head.look_at(x=x, y=y, z=z, duration=0.05, wait = True, interpolation_mode='linear')  # head tracking the effector at 20Hz\n",
    "\n",
    "        reachy.head.look_at(x=0.5, y=0.0, z=0.0, duration=1.0, wait = True)\n",
    "\n",
    "print(\"Function arm_swing_and_effector_tracking defined.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06d616ba",
   "metadata": {},
   "source": [
    "> 💡 Note that we don't wait for the end of the movements of the moving arm in this function as we want the head to follow the effector while the arm is moving. We only wait for the end of the last movement to consider the whole sequence done. While the arm is moving, we call the forward_kinematics method of the arm to get the coordinates of the effector and make the head look at this point.\n",
    "\n",
    "For the *look_at* calls of the head, we need to set *wait=True* otherwise a large number of *look_at* calls will be loaded in the goto queue of the sdk and the head will not be able to follow the effector of the moving arm and lots of delay will appear. <br>\n",
    "Again, you can try to change the *wait* argument of the *look_at()*, to see the difference ! "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef6361d2",
   "metadata": {},
   "source": [
    "Now, let's try the function on the robot !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd587f66",
   "metadata": {},
   "outputs": [],
   "source": [
    "arm_swing_and_effector_tracking(reachy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2291a9b0",
   "metadata": {},
   "source": [
    "That's working ! Now, we can move on to the last part of our sequence. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e1a1123",
   "metadata": {},
   "source": [
    "#### 4.3.4. Nodding and getting back to the default posture\n",
    "\n",
    "To finish, Reachy nods with its head and gets back to the default posture.\n",
    "\n",
    "We will define a function `nod_and_default_posture` for this behavior.\n",
    "To make the nodding part, we will use the *look_at()* method as before. To get back to the default position, we will use the *goto_posture()* method that we also used before in this project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "488f73df",
   "metadata": {},
   "outputs": [],
   "source": [
    "def nod_and_default_posture(reachy):\n",
    "    reachy.head.look_at(0.5, 0.0, -0.2, 1.0)\n",
    "    reachy.head.look_at(0.5, 0.0, 0.0, 0.5, wait=True)\n",
    "    reachy.l_arm.goto_posture(\"default\")\n",
    "    reachy.r_arm.goto_posture(\"default\", wait=True)\n",
    "\n",
    "print(\"Function nod_and_default_posture defined.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b53607f3",
   "metadata": {},
   "source": [
    "Now, you can try the function on the robot :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "934203f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "nod_and_default_posture(reachy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b910672d",
   "metadata": {},
   "source": [
    "Perfect ! So now we have all the building blocks we need to construct a function to link this entire sequence together. Let's do it !"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a170733d",
   "metadata": {},
   "source": [
    "### 4.4. Put it all together\n",
    "\n",
    "Now that we have implemented each behavior separately, it's time to compose them to make the full awake sequence!\n",
    "\n",
    "The sequence is just a composition of the different behaviors we implemented and each behavior will be executed sequentially. We will call the functions we defined in the right order to make Reachy do the awake sequence.\n",
    "\n",
    "We will gather the different parts of the awake sequence in a single function `awake`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17eae7f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def awake(reachy: ReachySDK):\n",
    "    asleep(reachy)\n",
    "    head_awake_sequence(reachy)\n",
    "    arm_swing_and_effector_tracking(reachy)\n",
    "    nod_and_default_posture(reachy)\n",
    "\n",
    "print(\"Function awake defined.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7320174",
   "metadata": {},
   "source": [
    "Call the function to see Reachy doing the whole awake sequence!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b5ef67b",
   "metadata": {},
   "outputs": [],
   "source": [
    "awake(reachy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04638db9",
   "metadata": {},
   "source": [
    "Well done, we did it, Reachy has woken up ! "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a46b4360",
   "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",
    "- head movements\n",
    "- arms movements\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. 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 only SDK)**\n",
    "\n",
    "2. Reachy the mime (with only SDK)\n",
    "\n",
    "3. Reachy the greengrocer (with SDK & Pollen-Vision)\n",
    "\n",
    "\n",
    "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": 5
}