tutorials-education/poppy_ergo_jr__decouverte_du_robot/TP1_mouvement_et_fonctions_cor_prof.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import time\n",
    "from poppy.creatures import PoppyErgoJr\n",
    "\n",
    "poppy = PoppyErgoJr() \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Initialisation \n",
    "**Ecrire un jeu d'instructions permettant **\n",
    "\n",
    "1. d'initialiser la vitesse de chacun des moteurs à 30°/s.\n",
    "2. de mettre les moteurs *poppy.m1* à *poppy.m6* dans les positions données par la liste suivante *pos_init = [0, -90, 30, 0, 60, 0]*. \n",
    "\n",
    "**Remarque : **\n",
    "\n",
    "Lorsque la vitesse du moteur *poppy.m1 == 0* ou lorsque le moteur est dans l'état *compliant == True*, la commande *poppy.m1.goal_position = 50* n'a pas d'effet.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "i = 0\n",
    "pos_init = [0, -90, 30, 0, 60, 0]\n",
    "for m in poppy.motors: \n",
    "    m.moving_speed = 60\n",
    "    m.compliant = False\n",
    "    m.goal_position = pos_init[i]\n",
    "    i = i + 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quelques remarques \n",
    "* L'itérateur *m* est ici une variable locale au sein de la boucle pour et il va parcourir dans l'ordre la liste *poppy.motors* On peut donc considérer qu'il est du type *poppy.mi* il possède alors tous les attributs de *poppy.mi* \n",
    "* On a besoin d'un compteur pour parcourir la liste contenant les positions initiales. Ici, la variable *i* qui doit alors être incrémentée de 1 à chaque passage dans la boucle *pour* afin de faire coincider le moteur et la position à atteindre par ce moteur. \n",
    "* Une autre syntaxe possible pour parcourrir deux listes simultanement : \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for (motor, pos) in zip(poppy.motors, pos_init):\n",
    "    motor.moving_speed = 60\n",
    "    motor.compliant = False\n",
    "    motor.goal_position = pos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Faire de ce jeu d'instructions une procédure\n",
    "On veut faire de ces instructions d'initialisation une procédure dont les arguments sont le robot nommé *bot* et la liste donnant les positions initiales des moteurs nommé *pos_initiale*. \n",
    "Le prototype de cette procédure est : *f_init(bot, pos_initiale)*. A la fin de l'exécution de  la procédure, on affichera un message pour identifier ce qui a été fait. \n",
    "\n",
    "**Remarque : ** En Python, on déclare une procédure à l'aide du mot réservé *def* suivi du prototype de la procédure. \n",
    "Cette ligne ce termine par *:*.\n",
    "\n",
    "Ensuite, c'est l'indentation qui délimite le contenu de cette procédure.\n",
    "\n",
    "**Remarque : ** Il en est de même pour une fonction, celle-ci comportera le mot réservé *return* qui permettra à l'issue du traitement de retourner le contenu souhaité."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f_init(bot, pos_initiale): \n",
    "    i = 0\n",
    "    for m in bot.motors: \n",
    "        m.moving_speed = 30\n",
    "        m.compliant = False\n",
    "        m.goal_position = pos_initiale[i]\n",
    "        i = i + 1\n",
    "    print(\"la vitesse de mouvement a été mise à jour à \", bot.m1.moving_speed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quelques remarques \n",
    "* La variable *i* est ici une variable locale \n",
    "* *bot* et *pos_initiale* sont les deux arguments de la fonction. \n",
    "* Ici, lors de l'appel de la procédure, *poppy* est visible à partir de son instanciation et du fait des caractéristiques du robot (synchronisation), il n'est pas utile de le passer en argument à moins d'avoir plusieurs robots instanciés. \n",
    "* Par ailleurs, on pourrait créer une fonction avec des arguments optionnels, la recherche de la syntaxe est laissée à votre charge.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tester votre procédure \n",
    "Faire fonctionner votre procédure avec *poppy* et *pos_init = [0, -90, 30, 0, 60, 0]* puis avec *[30, -60, 30, -30, 60, 20]*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f_init(poppy, pos_init)\n",
    "print(poppy.m1.moving_speed)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Une nouvelle procédure *f_init2*\n",
    "Définir une nouvelle procédure *f_init* dont le prototype est *f_init2(bot, pos_initiale, vitesse)* et qui permet cette fois d'initialiser la vitesse des moteurs à la valeur vitesse donnée en argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f_init2(bot, pos_initiale, vitesse): \n",
    "    i = 0\n",
    "    for m in bot.motors: \n",
    "        m.moving_speed = vitesse\n",
    "        m.compliant = False\n",
    "        m.goal_position = pos_initiale[i]\n",
    "        i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**QUESTION :** \n",
    "\n",
    "Expliquer pourquoi deux procédures ne \"peuvent\" pas avoir le même nom.\n",
    "\n",
    "* Si elles avaient le même nom, l'exécution du bloc d'instructions permettant de la définir la seconde fois écraserait alors la définition première de la fonction. Il n'en resterait alors plus qu'une seule, la dernière. \n",
    "* Ce n'est pas le nombre d'arguments qui va définir une fonction mais son nom. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expliquer le rôle de la procédure définie ci-dessous.\n",
    "Par son appel, elle va permettre de mettre tous les moteurs du robot *bot* dans l'état *compliant* c'est à dire le rendre souple/mobile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def f_bouger_a_la_main(bot): \n",
    "    for m in bot.motors :\n",
    "        m.compliant = True\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vérifier votre réponse en la testant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f_bouger_a_la_main(poppy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expliquer ce que doit faire la fonction *f_pos_cible*. \n",
    "\n",
    "La fonction *f_pos_cible* va enregistrer la position courante de tous les moteurs du robot dans une liste et la retourner.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f_pos_cible(bot): \n",
    "    f_pos_cible = []\n",
    "    for m in bot.motors:\n",
    "        f_pos_cible.append(m.present_position) \n",
    "    return f_pos_cible    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Défi \n",
    "On veut pouvoir créer un mouvement d'une position de départ à une position d'arrivée.\n",
    "Pour cela : \n",
    "\n",
    "1. on va initialiser les positions de départ et d'arrivée\n",
    "2. Faire bouger les moteurs un par un de la position de départ à la position d'arrivée. \n",
    "3. Pendant toute la durée du mouvement, la led du moteur doit être rouge une fois le mouvement fini, elle doit passer au vert.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pos_arrivee = f_pos_cible(poppy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pos_arrivee = [30.65, -34.46, 63.49, -30.94, -86.36, -31.82]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pos_depart = f_pos_cible(poppy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pos_depart = [3.37, -98.39, 80.79, -1.32, 11.58, -15.98]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f_mouv(bot, pos_D, pos_A): \n",
    "    f_init2(poppy, pos_D, 50)\n",
    "    time.sleep(3.0)\n",
    "    i = 0\n",
    "    for m in poppy.motors: \n",
    "        m.goal_position = pos_A[i]\n",
    "        m.led = 'red'\n",
    "        time.sleep(2 * abs(pos_A[i] - pos_D[i]) / m.moving_speed)\n",
    "        i = i + 1\n",
    "        m.led = 'green'\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f_mouv(poppy, pos_depart, pos_arrivee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f_mouv(poppy, pos_arrivee, pos_depart)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Auteur : Georges Saliba, Lycée Victor Louis, Talence sous [licence CC BY SA](https://creativecommons.org/licenses/by-nc-sa/3.0/fr/) "
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}