{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Premiers pas avec les diodes electro-luminescentes (DEL ou LED)\n",
    "\n",
    "Une diode électroluminescente est un composé électronique qui émet de la lumière lorsqu'il est parcouru par un courant électrique. L'une des particularités de ce composant est qu'il ne peut être parcouru que *dans un seul sens* si l'on permute le sens du courant il est bloqué (aucune intensité ne parcourt le composant) et la diode (LED) reste éteinte. Nous verrons comment exploiter cette particularité en contrôlant par un programme l'alimentation de LEDs. \n",
    "\n",
    "![Light-Emitting Diode - Diode électro luminescente](images/led_schema.jpg)\n",
    "                        ![licence : Charles-Henri Eyraud](images/Licence.jpg)\n",
    "\n",
    "Nous allons utiliser un certain nombre de programmes écrits par des développeurs pour nous permettre d'interagir avec les broches d'une Raspberry Pi, ces programmes sont regroupés dans des librairies stockées sur le disque de la machine et prêtes à l'emploi, il suffit de solliciter leur utilisation pour accéder aux programmes qu'elles contiennent. On utilise pour cela l'instruction :\n",
    "\n",
    "**import** *nom_de_la_bibliothèque* **as** *nom_que_nous_utiliserons_dans_le_programme*\n",
    "\n",
    "Ces commandes doivent **systématiquement** figurer en tête de chaque programme que nous allons écrire. Lors de la phase d'apprentissage elles ne doivent être utilisées qu'**une seule fois** pour le programme considéré. La _redéclaration_ de la broche entraîne un conflit qui place la broche dans un état _\"hors service\"_. La situation est réversible soit en utilisant la commande  `led.dir(mraa.DIR_IN)` si le conflit est faible soit en ouvrant un terminal depuis la page de garde \"Cahier de programmes\" et en utilisant la commande `mraa-gpio set 11 0` qui réinitialise complètement la broche."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contrôler l'allumage et l'extinction d'une LED par un programme\n",
    "\n",
    "Nous allons utiliser le montage encadré ci-dessous et connecter deux broches de la Raspberry Pi. L'identification des broche est une question de type *\"troll\"* dans la mesure où il y a plusieurs façons d'identifier ces broches dont toutes ont des avantages et des inconvénients. Nous utiliserons ici le **numéro de la broche** en commençant en haut à gauche (les connecteurs USB et RJ45 étant considérés en bas) en descendant et en augmentant de droite à gauche.\n",
    "\n",
    "![montage LED](images/RaspberryPi_Led_Detail.jpg)\n",
    "                        ![licence : Charles-Henri Eyraud](images/Licence.jpg)\n",
    "                        \n",
    "Connecter la patte longue de la LED  à la broche 13 en y intercalant une résistance de 100 à 300 ohms et le fil noir à la broche 6 (GROUND). Pour allumer la LED, il faut commencer par\n",
    "* importer les programmes de la bibliothèque mraa\n",
    "* déclarer l'utilisation de la broche 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mraa\n",
    "led = mraa.Gpio(13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les broches peuvent fonctionner dans le sens *in* pour **recevoir** des données ou dans le sens *out* pour envoyer un signal ou un courant.\n",
    "* il faut déclarer la broche 13 en mode sortie *out*\n",
    "* l'état de la broche est fourni  (0 correct, 7 erreur) et recueilli dans la variable status. Pour imprimer l'état décommenter la seconde ligne de ce bloc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = led.dir(mraa.DIR_OUT)\n",
    "#print ('Return status : {0:1d}'.format(status))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour allumer la LED on met la sortie au niveau 1 avec la commande *write*\n",
    "* l'état de la broche est fourni  (0 correct, 7 erreur) et recueilli dans la variable status. Pour imprimer l'état décommenter la seconde ligne de ce bloc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = led.write(1)\n",
    "#print ('Return status : {0:1d}'.format(status))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On éteint ou on ré-éteint la LED en mettant la sortie au niveau 0 avec la commande *write*\n",
    "* l'état de la broche est fourni  (0 correct, 7 erreur) et recueilli dans la variable status. Pour imprimer l'état décommenter la seconde ligne de ce bloc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = led.write(0)\n",
    "#print ('Return status : {0:1d}'.format(status))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Il est possible de contrôler la durée d'allumage ou d'extinction de la LED ce qui conduit à la logique de clignotement. Pour y parvenir il est nécessaire de disposer de fonctions temporelles fournies par la bibliothèque *time*. On importe time ensuite on choisit la durée d'allumage et d'extinction en secondes:\n",
    "Exécuter le programme ci-dessous puis commenter chaque étape\n",
    "Importer la bibliothèque *time*\n",
    "Allumer la LED pendant ? secondes\n",
    "Eteindre la LED pendant ? secondes\n",
    "......"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "led.write(1)\n",
    "time.sleep(1)\n",
    "led.write(0)\n",
    "time.sleep(1)\n",
    "led.write(1)\n",
    "time.sleep(1)\n",
    "led.write(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Exercice : Faire clignoter une LED\n",
    "Brancher une LED verte sur la broche 35 (GPIO 19) et la faire clignoter 10 fois en un seul programme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Taper le code ici"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Faire clignoter la Led rouge en utilisant une instruction de répétition : la boucle\n",
    "\n",
    "Comme on l'a vu ci dessus il suffit d'imposer le temps d'allumage et d'extinction pour un obtenir un clignotement, cependant c'est très fastidieux de répéter plusieurs fois la même séquence d'instructions. La programmation fournit un outil qui décrit une répétition de commandes et permet en quelques lignes de répéter un grand nombre d'instructions identiques. Le programme ci-dessous utilise la *variable* **i** qui :\n",
    " * prend la valeur 0 pour commencer : *la valeur initiale* et \n",
    " * se termine à 20 *la valeur finale* \n",
    " * en augmentant chaque fois d'une unité : *le pas*\n",
    " range(\"valeur initiale\",\"valeur finale\",\"pas\")\n",
    "\n",
    "Le clignotement se compose d'une phase d'allumage pendant 0.15 s et une phase d'extinction de 0.25 s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,20,1) :\n",
    "    led.write(1)\n",
    "    time.sleep(0.15)\n",
    "    led.write(0)\n",
    "    time.sleep(0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice\n",
    "\n",
    "Modifier *la valeur initiale*, *la valeur finale* et *le pas* pour modifier le clignotement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(-,-,-) :\n",
    "    led.write(1)\n",
    "    time.sleep(-.-)\n",
    "    led.write(0)\n",
    "    time.sleep(-.-)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut modifier la commande qui est répétée en ajoutant des tests qui permettent de fixer le moment ou le type de clignotement change. Ici on change tous les 10 clignotements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,30,1) :\n",
    "    if (i < 10) :\n",
    "        led.write(1)\n",
    "        time.sleep(1)\n",
    "        led.write(0)\n",
    "        time.sleep(1)\n",
    "    elif (i >= 10 and i < 20) :\n",
    "        led.write(1)\n",
    "        time.sleep(0.2)\n",
    "        led.write(0)\n",
    "        time.sleep(0.2)\n",
    "    else :\n",
    "        led.write(1)\n",
    "        time.sleep(0.05)\n",
    "        led.write(0)\n",
    "        time.sleep(0.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice\n",
    "\n",
    "Décrivez un mode de clignotement composé de plusieurs phases sur le modèle ci-dessus et écrivez le programme correspondant dans le bloc ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(-,-,-) :\n",
    "    if (- < -) :\n",
    "        led.write(1)\n",
    "        time.sleep(-.-)\n",
    "        led.write(0)\n",
    "        time.sleep(-.-)\n",
    "    elif ():\n",
    "    \n",
    "    else :\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}