OBJETSC_1-DILLMANN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objets connectés\n",
    "\n",
    "Les objets connectés, [des robots dans nos maisons](http://lienmini.fr/3389-701) ?\n",
    "\n",
    "L'impact de la robotisation [dans les magasins](http://lienmini.fr/3389-707)\n",
    "\n",
    "Question déclencheante : *\" Si on dispose d'un employé et d'un robot. Faut il confier une tâche répétitive et fastidieuse à l'un ou à l'autre pour qu'elle soit correctement réalisée ? \"*\n",
    "\n",
    "Nous allons parler d'un certain type de robot appelés : les systèmes embarqués, en anglais on parle de *Embedded Hardware* . Les connaissances de technologies vue au colège sur la fabrication de robots est un prérequis pour comprendre ce cours.\n",
    "\n",
    "Comment utiliser un microcontrôleur pour automatiser une tâche de caractérisation répétitive ? Dans le cas d’une série de résistors, le tracé de la droite caractéristique de la Tension (en V) en fonction du Courant (en A) est une tâche est particulièrement fastidieuse. En fait le plus pénible est la lecture des données fluctuantes qui apparaîssent sur les ecrans des multimètres. On admetra qu'il sera presque impossible de la reproduire à l’identique des données expérimentale en changeant le manipulateur, par contre un robot testeur peut être conçu pour relever le défi et permettre l'acquisition rapide et automatisée d'un très grand nombre de variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A) Géneralités"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Les systèmes informatiques embarqués\n",
    "\n",
    "Un système informatique embarqué est intégré à un objet. Il contrôle les entrées et les sorties de celui-ci grâce à ses composants, dont les principaux sont :\n",
    "- La carte programmable\n",
    "- Les capteurs\n",
    "- Les actionneurs\n",
    "Il est destiné à piloter l'objet à distance (en faisant remonter des informations sur le cloud) ou de manière autonome (grâce à des algorithmes qui permettent à son système de contrôle de s'orienter vers des objectifs programmés). \n",
    "\n",
    "Lorsqu'un système informatique embarqué échange des données avec un ordinateur on parle d'**objet connecté**.\n",
    "\n",
    "Le smartphone est un exemple d'un tel objet. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) La programmation d'un système infomatique embarqué\n",
    "\n",
    "Pour programmer un système informatique embarqué, on doit organiser la tâche à accomplir sous forme d'un **algorithme**. C'est une suite d'instructions qui comprends notament des **fonctions** spécifiques aux capteurs et actionneurs. On ecrit un **programme** dans un langage qui puisse être interprété par le système.\n",
    "\n",
    "Pour l'execution de celui-ci il faut le **téléverser** dans le système à travers un **port** de communication. On parle aussi de `flashage` du logiciel pilote pour décrire cette étape d'implémentation.\n",
    "\n",
    "Dans ce cours nous allons voire quelques éléments de codage qui seront utiles pour interpéter un programme de contrôle.\n",
    "\n",
    "On va d'abord s'intéresser aux **fonctions** puis on vera un exemple d'**algorithme** et finallement nous rentrerons dans le **programme** du microcontroleur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Première introduction aux fonctions en langage python\n",
    "\n",
    "Une fonction est un outil de programmation qui permet de transformer des donnée en entrée (appelés arguments) par des résultats en sortie. Sa syntaxe est très formelle : \n",
    "\n",
    "~~~python\n",
    "def NOM_DE_LA_FONCTION (argument1):\n",
    "    return resultat\n",
    "~~~\n",
    "\n",
    "Notez bien les deux points après la déclaration de l'argument, ainsi que l'indentation (l'espace au début de la ligne où se trouve la commande \n",
    "~~~python\n",
    "    return\n",
    "~~~\n",
    "qui renvoie le produit de la fonction. On renvoie au notebook spécifique sur l'utilisation des fonctions avec python : *informatique_embarquee_INTRO_FONCTIONS-DILLMANN.ipynb* qui présente des exemples de fonctions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) L'interface homme-machine\n",
    "\n",
    "Les programmes à téléverser sont des codes écris dans un langage de haut niveau (le `C++`) qui doit être *compilé* par un EDI (un **Environement de Développement Intégre**)\n",
    "\n",
    "La suite d'instructions d'un logiciel de programation est appellée à être \"compilée\" ce qui veut dire transformée en un langage adapté à la machine avant d'être téleversée sur la machine elle même en language machine.\n",
    "\n",
    "Le transfert des données fait appel à la notion de *Binary Digit* que l'on peut ecrire **BI**nary digi**T** : ou plus simplement  **BIT** , un mot valise qu'il faut absolument connaître pour comprendre le fonctionnement des programmes. Désormais nous utiliserons le mot \"bit\" pour caractériser la plus petite unité d'information qui puisse être transmise à un ordinateur.\n",
    "\n",
    "Dès que le programme a été compilé de façon satisfesante, il doit être implémenté sur le microcontroleur. On appelle cette opération l'étape de *téeversement*. Il est indispensable que la liaison entre l'ordinateur ou se trouve l'EDI et la carte soit correctement pilotée."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1) La programmation d'un système de type Arduino (lecture d'un port analogique)\n",
    "\n",
    "L'exemple suivant est extrait de la bibliothèque des exemples de base et permet de lire la valeur d'une résistance dans un potentiomètre.\n",
    "\n",
    "La programmation de l'arduino se fait en langage `C++`, qui a de nombreux points de différence avec le langage Python. Mais à notre niveau c'est pratiquement la même chose :\n",
    "\n",
    "~~~ cpp\n",
    "void setup() {\n",
    "  \n",
    "  Serial.begin(115200); // 1\n",
    "}\n",
    "\n",
    "// la fonction suivante est destinée à être executé en permanence\n",
    "void loop() {\n",
    "  \n",
    "  int sensorValue = analogRead(A0); // 2\n",
    "  \n",
    "  Serial.println(sensorValue); // 3\n",
    "  \n",
    "  delay(1);        // Attends 1 seconde pour des raisons de stabilité\n",
    "}\n",
    "~~~\n",
    "\n",
    "Ce code peut être téleversé tel quel dans l'IDE Arduino "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Replace les commentaires du code `C++` dans le bon ordre en te servant des flèches haut et bas du notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Commentaire portant sur l'opération à réaliser sur la valeur acquise par le port de communication spécifique :\n",
    "\n",
    "~~~cpp\n",
    "// imprimer la valeur qui est lue :\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Commentaire portant sur la mise en place (setup) d'un protocole de communication :\n",
    "\n",
    "~~~cpp\n",
    "// initialise le port de communication serie a 115200 bits par seconde\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Commentaire portant sur la déclaration de la borne de communication destinée à recevoir un signal :\n",
    "\n",
    "~~~cpp\n",
    "// Lis la valeur du port analogique qui se trouve au pin 0 :\n",
    "~~~"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On retrouve deux sortes de fonctions principales :\n",
    "\n",
    "~~~ c\n",
    "void setup() \n",
    "void loop()\n",
    "~~~\n",
    "\n",
    "La première définit la vitesse à laquelle les bits vont être envoyés quant à la deuxième elle constitue le coeur du programme puis-ce que c'est elle qui demande la lecture du signal qui se trouve sur le pin 0, grâce à la fonction `analogRead()` et qui imprime dans la console série le résultat grâce à une autre fonction `Serial.println()`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2) La programmation d'un système de type Arduino (géneration d'un signal)\n",
    "\n",
    "Dans le programme suivant on va voire comment utiliser une des sortie digitales qui se trouve alignées avec le bouton 'réset'. Ces sorties ne doivent **jamais** être reliées de l'une à l'autre sous peine de détruire la platinne. \n",
    "\n",
    "\n",
    "~~~cpp\n",
    "/*\n",
    "\n",
    "    Gradateur de lumière\n",
    "\n",
    "           Cet exemple montre comment estomper progressivement la lueur d'une LED sur la broche 9 en utilisant la fonction :  \n",
    "           \n",
    "           analogWrite()\n",
    "  \n",
    "  Description de la fonction.\n",
    "\n",
    "  La fonction analogWrite() utilise PWM (Impulsion modulée en amplitude), donc si vous voulez changer la broche en utilisant une autre carte, assurez-vous d'utiliser une autre broche compatible PWM. \n",
    " \n",
    "  Sur la plupart des Arduino, les broches PWM sont identifiés par un signe \"~\", \n",
    "  comme ~3, ~5, ~6, ~9, ~10 et ~11.\n",
    "  \n",
    "  Dans la carte PlugUino la tilde à disparut mais le pins D10 est PWM on pourra vérifier que les autres sont bien ajustables\n",
    "\n",
    "  Cet example appartient au domaîne publique\n",
    "  \n",
    "  http://www.arduino.cc/en/Tutorial/Fade\n",
    "*/\n",
    "\n",
    "int led = 9;           // déclaration du pin \"PWM\" qui alimente la DEL\n",
    "int brightness = 0;    // niveau de luminosité de la DEL\n",
    "int fadeAmount = 5;    // combien d'etapes de variation pour la DEL\n",
    "\n",
    "// la routine de configuration s'exécute une fois lorsque vous appuyez sur reset :\n",
    "void setup() {\n",
    "  // déclare que la broche 9 est une sortie :\n",
    "  pinMode(led, OUTPUT);\n",
    "}\n",
    "\n",
    "// la routine de la boucle se répète encore et encore, pour toujours :\n",
    "void loop() {\n",
    "  // régler la luminosité de la broche 9 :\n",
    "  analogWrite(led, brightness);\n",
    "\n",
    "  // modifier la luminosité pour la prochaine fois à travers la boucle :\n",
    "  brightness = brightness + fadeAmount;\n",
    "\n",
    "  // inverser le sens du fondu lumineux une fois que l'on est parvennu aux extrémités :\n",
    "  if (brightness <= 0 || brightness >= 255) {\n",
    "    fadeAmount = -fadeAmount;\n",
    "  }\n",
    "  // attendre 30 millisecondes pour voir l'effet de gradation\n",
    "  delay(30);\n",
    "}\n",
    "~~~\n",
    "\n",
    "Nous avons les deux éléments qui vont nous permettre de faire notre propre robot de caractérisation de dipôles\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## B) Application : Le robot caracteriseur de dipôles\n",
    "\n",
    "Nous allons nous intéresser à un type d'automate très courant dans les équipes de recherche et développement dans lesquelles on prépare la conception de nouveaux composants. On appelle cela des \"[Flying Probes](https://youtu.be/syQDnRmdhmA)\". \n",
    "\n",
    "La tension $U_{AB}$ aux bornes du dipôle est une fonction de la variable intensité $I$ qui le traverse : $U_{AB}= f (I)$.\n",
    "La caractéristique tension-courant d'un dipôle est la courbe représentative de $f$ avec $I$ en abscisse et $U_{AB}$ en ordonnée.\n",
    "\n",
    "Dans ce cas :\n",
    "- La carte programmable est de type Arduino (ou assimilé)\n",
    "- L'actionneur est un signal de tension, triangulaire allant de $0\\,V$ à presque $5\\,V$\n",
    "- Les capteurs sont les tensions mesurées de part et d'autre d'un dipôle à caractériser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Situation de départ : Quelle démarche suivre pour tracer la caractéristique d'un dipôle avec des multimètres ?\n",
    "\n",
    "On s'intéresse d'abord à la démarche \"artisanalle\" qui consiste à relever pour différentes tensions d'un générateur à tension variable l'intensité $I$ et la tension $U_{AB}$ que l'on reporte dans un tableau.\n",
    "\n",
    "Le montage correspond à ce qui a été vu en classe de 4ème : \n",
    "\n",
    "<p><img src=\"circuit_4eme1.png\" alt=\"Schéma simplifié\" /></p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'énnoncé de l'exercice résolu au collège est :\n",
    "\n",
    "\"Tracez la caractéristique tension-courant de la résistance étudiée. Sur du papier milimètré (ou mieux : reportez les valeurs d'un tableau dans un logiciel de tracé graphique si vous savez vous en servir) et identifiez le modèle physique qui permet de représenter la distribution des couples de points.\"\n",
    "\n",
    "\t\n",
    "Le montage que vous devez réaliser pour étudier le comportement\n",
    "de la résistance est représenté ci-dessus.\n",
    "\n",
    "Il semble être compliqué. Dans la pratique, il est assez simple.\n",
    "\n",
    "Il utilise un ampèremètre branché en série avec un générateur variable et un voltmètre placé en dérivation aux bornes de la résistance.\n",
    "\n",
    "Expérimentalement, on observe que quand on augmente la tension en volt à la sortie du générateur variable, la tension aux bornes de la résistance est liée à l'intensité du courant $i_r$ circulant dans le résistor.\n",
    "    \n",
    "La différence de potentiel $U_R$ exprimée en volts et l'intensité du courant $i_R$ electrique exprimée en ampères sont proportionnelles.\n",
    "\n",
    "Grâce à la loi d'Ohm : $$ U_R = R \\times i_r $$  il est possible de modéliser la relation entre la tension aux bornes d'un résistor et le courant qui le traverse, on peut de plus \"ajuster\" une valeur de la résistance : c'est à dire trouver le paramètre le plus juste, d'une résistance, pour qu'une droite $U=R \\times I$ simulée avec une résistance calculée, resemble le plus possible à la droite passant par les valeurs expérimentales. Si l'ajustement est réussit ont peut montrer que la résistance calculée correspond à la résistance mesurée pour le résistor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) Explicitation de la démarche\n",
    "\n",
    "La methode qui permet de caractériser un résistor par la valeur de sa résistance (en $\\Omega$) fait appel à la loi d'Ohm qui modélise correctement ce comportement.\n",
    "\n",
    "### 2.1) Un premier 'algorigramme'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On utilise la fonction Digraph du module graphviz \n",
    "#qui est disponible sur  www.kaggle.com, \n",
    "# et sûrement aussi sur le serveur local\n",
    "# sur tous les autres intérpréteurs il faut demander\n",
    "# la permission d'installer un module spécifique\n",
    "\n",
    "from graphviz import Digraph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 2.40.1 (20161225.0304)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"780pt\" height=\"583pt\"\n",
       " viewBox=\"0.00 0.00 779.97 583.48\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 579.4802)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"#ffffff\" stroke=\"transparent\" points=\"-4,4 -4,-579.4802 775.9693,-579.4802 775.9693,4 -4,4\"/>\n",
       "<!-- A -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>A</title>\n",
       "<polygon fill=\"none\" stroke=\"#000000\" points=\"637.8122,-575.4802 452.8122,-575.4802 452.8122,-537.4802 637.8122,-537.4802 637.8122,-575.4802\"/>\n",
       "<text text-anchor=\"middle\" x=\"545.3122\" y=\"-560.2802\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">Faire varier la puissance </text>\n",
       "<text text-anchor=\"middle\" x=\"545.3122\" y=\"-545.2802\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\"> délivrée par le générateur &#39;G&#39; </text>\n",
       "</g>\n",
       "<!-- B1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>B1</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"180.3122\" cy=\"-474.6102\" rx=\"180.1247\" ry=\"26.7407\"/>\n",
       "<text text-anchor=\"middle\" x=\"180.3122\" y=\"-478.4102\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">Relever la valeur de l&#39;intensité I </text>\n",
       "<text text-anchor=\"middle\" x=\"180.3122\" y=\"-463.4102\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\"> à l&#39;ampèremètre et l&#39;ecrire dans un tableau</text>\n",
       "</g>\n",
       "<!-- A&#45;&gt;B1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>A&#45;&gt;B1</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M460.1966,-537.3887C409.5283,-526.0237 344.6967,-511.4819 290.1915,-499.2563\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"290.6637,-495.7753 280.1401,-497.0017 289.1316,-502.6056 290.6637,-495.7753\"/>\n",
       "</g>\n",
       "<!-- B2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>B2</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"545.3122\" cy=\"-474.6102\" rx=\"166.7545\" ry=\"26.7407\"/>\n",
       "<text text-anchor=\"middle\" x=\"545.3122\" y=\"-478.4102\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">Relever la valeur de la tension U </text>\n",
       "<text text-anchor=\"middle\" x=\"545.3122\" y=\"-463.4102\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\"> au voltmètre et l&#39;ecrire dans un tableau</text>\n",
       "</g>\n",
       "<!-- A&#45;&gt;B2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>A&#45;&gt;B2</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M545.3122,-537.0782C545.3122,-529.4652 545.3122,-520.4632 545.3122,-511.6985\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"548.8123,-511.616 545.3122,-501.616 541.8123,-511.616 548.8123,-511.616\"/>\n",
       "</g>\n",
       "<!-- C -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>C</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"477.3122\" cy=\"-384.8701\" rx=\"217.578\" ry=\"26.7407\"/>\n",
       "<text text-anchor=\"middle\" x=\"477.3122\" y=\"-388.6701\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">Reporter les coordonnées des couples ainsi obtenus </text>\n",
       "<text text-anchor=\"middle\" x=\"477.3122\" y=\"-373.6701\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\"> sur le papier milimétré</text>\n",
       "</g>\n",
       "<!-- B1&#45;&gt;C -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>B1&#45;&gt;C</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M260.2935,-450.4434C298.7839,-438.8133 345.1402,-424.8065 385.1097,-412.7295\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"386.298,-416.0269 394.8582,-409.784 384.2732,-409.3261 386.298,-416.0269\"/>\n",
       "</g>\n",
       "<!-- B2&#45;&gt;C -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>B2&#45;&gt;C</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M524.91,-447.6852C518.3206,-438.9891 510.9154,-429.2164 503.9442,-420.0165\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"506.5291,-417.6325 497.7001,-411.776 500.9499,-421.8602 506.5291,-417.6325\"/>\n",
       "</g>\n",
       "<!-- DECISION -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>DECISION</title>\n",
       "<polygon fill=\"none\" stroke=\"#000000\" points=\"477.3122,-322 242.3122,-269 477.3122,-216 712.3122,-269 477.3122,-322\"/>\n",
       "<text text-anchor=\"middle\" x=\"477.3122\" y=\"-280.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">Est ce que le nombre de points permet </text>\n",
       "<text text-anchor=\"middle\" x=\"477.3122\" y=\"-265.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\"> de faire passer une droite par l&#39;origine </text>\n",
       "<text text-anchor=\"middle\" x=\"477.3122\" y=\"-250.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\"> pour en relier le plus possible ?</text>\n",
       "</g>\n",
       "<!-- C&#45;&gt;DECISION -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>C&#45;&gt;DECISION</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M477.3122,-357.9959C477.3122,-350.2241 477.3122,-341.3936 477.3122,-332.3858\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"480.8123,-332.1872 477.3122,-322.1873 473.8123,-332.1873 480.8123,-332.1872\"/>\n",
       "</g>\n",
       "<!-- YES -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>YES</title>\n",
       "<ellipse fill=\"none\" stroke=\"#ffffff\" cx=\"477.3122\" cy=\"-162\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"477.3122\" y=\"-158.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">Oui</text>\n",
       "</g>\n",
       "<!-- DECISION&#45;&gt;YES -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>DECISION&#45;&gt;YES</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M477.3122,-215.8135C477.3122,-207.0151 477.3122,-198.2054 477.3122,-190.3363\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"480.8123,-190.278 477.3122,-180.2781 473.8123,-190.2781 480.8123,-190.278\"/>\n",
       "</g>\n",
       "<!-- NO -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>NO</title>\n",
       "<ellipse fill=\"none\" stroke=\"#ffffff\" cx=\"644.3122\" cy=\"-162\" rx=\"27\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"644.3122\" y=\"-158.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">Non</text>\n",
       "</g>\n",
       "<!-- DECISION&#45;&gt;NO -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>DECISION&#45;&gt;NO</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M538.5486,-229.7647C565.1023,-212.7513 594.8966,-193.6615 616.0785,-180.0898\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"618.0629,-182.9753 624.5947,-174.6334 614.2865,-177.0813 618.0629,-182.9753\"/>\n",
       "</g>\n",
       "<!-- Q -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>Q</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"477.3122\" cy=\"-90\" rx=\"138.3755\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"477.3122\" y=\"-86.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">Quelle est la pente de cette droite ?</text>\n",
       "</g>\n",
       "<!-- CONCLUSION -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>CONCLUSION</title>\n",
       "<ellipse fill=\"none\" stroke=\"#000000\" cx=\"477.3122\" cy=\"-18\" rx=\"146.774\" ry=\"18\"/>\n",
       "<text text-anchor=\"middle\" x=\"477.3122\" y=\"-14.3\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">Déterminer la valeur de la Résistance</text>\n",
       "</g>\n",
       "<!-- Q&#45;&gt;CONCLUSION -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>Q&#45;&gt;CONCLUSION</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M477.3122,-71.8314C477.3122,-64.131 477.3122,-54.9743 477.3122,-46.4166\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"480.8123,-46.4132 477.3122,-36.4133 473.8123,-46.4133 480.8123,-46.4132\"/>\n",
       "</g>\n",
       "<!-- YES&#45;&gt;Q -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>YES&#45;&gt;Q</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M477.3122,-143.8314C477.3122,-136.131 477.3122,-126.9743 477.3122,-118.4166\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"480.8123,-118.4132 477.3122,-108.4133 473.8123,-118.4133 480.8123,-118.4132\"/>\n",
       "</g>\n",
       "<!-- NO&#45;&gt;A -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>NO&#45;&gt;A</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M667.9087,-171.2765C686.1685,-179.8627 710.1619,-194.5612 721.3122,-216 779.8578,-328.5655 796.4679,-399.2541 721.3122,-501.4802 711.5179,-514.8024 680.9694,-526.3287 648.0113,-535.3392\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"646.9718,-531.9937 638.1984,-537.9333 648.7609,-538.7612 646.9718,-531.9937\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x1097fab00>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot = Digraph(comment='Algorigramme')\n",
    "#G1=pgv.AGraph(strict=False,directed=True)\n",
    "\n",
    "################## Définition des noeuds de l'algorigramme :\n",
    "\n",
    "dot.node('A',\"Faire varier la puissance \\n délivrée par le générateur 'G' \",shape='rectangle')\n",
    "#A = \"Augmenter un peu la  du générateur 'G' \"\n",
    "\n",
    "\n",
    "dot.node('B1',\"Relever la valeur de l'intensité I \\n à l'ampèremètre et l'ecrire dans un tableau\")\n",
    "#B1 = \"Relever la valeur de l'intensité I \\n à l'ampèremètre et l'ecrire dans un tableau\"\n",
    "\n",
    "dot.node('B2',\"Relever la valeur de la tension U \\n au voltmètre et l'ecrire dans un tableau\" )\n",
    "#B2 = \"Relever la valeur de la tension U \\n au voltmètre et l'ecrire dans un tableau\"\n",
    "\n",
    "dot.node('C',\"Reporter les coordonnées des couples ainsi obtenus \\n sur le papier milimétré\")\n",
    "#C = \"Reporter les coordonnées des couples ainsi obtenus \\n sur le papier milimétré\"\n",
    "\n",
    "# Réécrire la condition C pour remplacer le papier milimétré par un tableur graphqiue de votre choix\n",
    "\n",
    "dot.node('DECISION',\"Est ce que le nombre de points permet \\n de faire passer une droite par l'origine \\n pour en relier le plus possible ?\",shape='diamond')\n",
    "#DECISION = \"Est ce que le nombre de points permet \\n de faire passer une droite par l'origine \\n pour en relier le plus possible ?\"\n",
    "\n",
    "dot.node('Q',\"Quelle est la pente de cette droite ?\")\n",
    "#Q = \"Quelle est la pente de cette droite ?\"\n",
    "\n",
    "dot.node('CONCLUSION',\"Déterminer la valeur de la Résistance\")\n",
    "#CONCLUSION = \"Déterminer la valeur de la Résistance\"\n",
    "\n",
    "dot.node('YES',\"Oui\",color='white')\n",
    "#YES = \"Oui\"\n",
    "\n",
    "dot.node('NO',\"Non\",color='white')\n",
    "#NO = \"Non\"\n",
    "\n",
    "######## Définition des liens entre différentes étapes de l'algorigramme : :\n",
    "\n",
    "dot.edge('A','B1')\n",
    "dot.edge('A','B2')\n",
    "dot.edge('B1','C')\n",
    "dot.edge('B2','C')\n",
    "dot.edge('C','DECISION')\n",
    "dot.edge('DECISION','YES')\n",
    "dot.edge('DECISION','NO')\n",
    "dot.edge('NO','A')\n",
    "dot.edge('YES','Q')\n",
    "\n",
    "dot.edge('Q','CONCLUSION')\n",
    "\n",
    "dot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2) Mise en place d'un circuit plus réaliste \n",
    "\n",
    "Avant de passer à la section suivante on va modifier un peu la disposition des élements du\n",
    "montage vu auparavant, et surtout introduire la notion de masse, comme la référence du potentiel qui n'a pas été présentée au collège :\n",
    "\n",
    "<p><img src=\"./circuit_4eme2.png\" alt=\"Schéma simplifié\" /></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce deuxième schéma les composants ont été redistribués, mais ils accomplissent exactement les mêmes fonctions. On notera qu'il n'y a pas de courant qui entre dans la branche du voltmètre, du fait de la valeur de la résistance de celui-ci qui est toujours plus importante que celle de $R$. La loi d'additivité des intensités s'applique et l'intensité du courant est la même dans le résistor et dans l'ampèremètre.\n",
    "\n",
    "On remarque aussi que $E_v$ est un générateur variable qui alimente des résistors en série (Celle de $R$ et celle de l'ampèrmètre qui est toujours négligeable devant celle de $R$). En fait nous ne disposons pas toujours d'un tel générateur, or il est vraiment indispensable pour la caractérisation de la résistance par une fonction $U=f(I)$ .\n",
    "\n",
    "\n",
    "Pour mimer un générateur variable de tension continnue, on se sert d'une technique qui permet de transformer la serie d'impulsions binaires (tension maximale ou nulle) se répettant sur chaque cycle, en une tension continnue, dite pseudo-analogique. \n",
    "\n",
    "C'est la méthode **MLI** pour Modulation de largeur d'impulsion, on joue sur le rapport de la durée du niveau haut par la période du cycle appellée *rapport cyclique*. Plus ce rapport est élevé plus la tension fournie est proche de la tension maximale."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercice : Trouvez un lien qui décrive cette technique aussi appelée *Pulse Width Modulation* (PWM) et incorporez-le à cette cellule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}