CPX-Un_BN_Pour_CircuitPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Un Bloc Note pour expérimenter CircuitPython sur CPX\n",
    "\n",
    "> Tout est dans le titre, il s'agit ici de découvrir l'ordinateur à carte unique (SBC, Single Board Computer) qu'est le Circuit Playground Express (CPX) et sa programmation en CircuitPython, un MicroPython personnalisé par [Adafruit](https://www.adafruit.com/) pour faciliter le prototypage électronique. [MicroPython](https://github.com/micropython) est une adaptation allégée de Python3 créée par [Damien George](https://github.com/dpgeorge) pour la programmation de certains microcontôleurs comme celui du BBC micro:bit...\n",
    "\n",
    "> Mais tout d'abord **félicitations** d'être déjà parvenu à ouvrir ce notebook, bientôt, ...\n",
    "\n",
    "> Ce document est un notebook jupyter, pour bien vous familiariser avec cet environnement regardez cette rapide [Introduction](Introduction-Le_BN_pour_explorer.ipynb).\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mise en situation :\n",
    "<center>\n",
    "<img src=\"https://ericecmorlaix.github.io/img/CPX.gif\" width=\"50%\">\n",
    "<figcaption><a href=\"https://www.adafruit.com/product/3333\">Circuit Playground Express (CPX)</a></figcaption></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kesako ? :\n",
    "\n",
    "Le [Circuit Playground Express](https://www.adafruit.com/product/3333) (CPX) est un mini-ordinateur programmable de poche (une carte à [microcontrôleur](https://fr.wikipedia.org/wiki/Microcontr%C3%B4leur)) conçu pour développer votre créativité avec la technologie.\n",
    "\n",
    "C'est une évolution du [Circuit Playground Classic](https://www.adafruit.com/product/3000) qui est basé sur un processeur ATmega32U4 cadencé à 8 MHz programmable en langage Arduino mais pas en CircuitPython.\n",
    "\n",
    "\n",
    "Ce petit appareil, basé sur un processeur ATSAMD21 ARM Cortex M0 cadencé à 48 MHz, intègre beaucoup de fonctionnalités : il a un cercle de 10 x mini LED NeoPixels qui peuvent produire des animations colorées, deux boutons poussoirs et un interrupteur à glissière programmables pouvant être utilisés pour contrôler des jeux, ou, par exemple, faire une pause et sauter des chansons sur une liste de lecture ; le CPX peut détecter le mouvement, la température, la luminosité, la couleur, une présence à proximité et vous dire le niveau sonnore ambiant en emmettant lui même de petits sons ; il peut aussi utiliser une connexion par infrarouge ou USB en tant que port série, clavier, souris, joystick ou MIDI, pour interagir avec d'autres appareils et Internet ; Il possède également 7 connecteurs sensibles au touché d'un doigt et une petite LED rouge programmable pour interagir avec son utilisateur...\n",
    "\n",
    "<center>\n",
    "<img src=\"https://cdn-learn.adafruit.com/assets/assets/000/046/973/medium800/circuit_playground_express-labeled.jpg?1507155485\" width=\"50%\">\n",
    "<figcaption><a href=\"https://learn.adafruit.com/adafruit-circuit-playground-express/guided-tour\">Inventaire des fonctionnalités d'un CPX</a></figcaption></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce petit ordinateur possède la dernière technologie qui équipe les appareils modernes : téléphones mobiles, réfrigérateurs, montres intelligentes, alarmes antivol, robots, etc...\n",
    "\n",
    "Ainsi, il s'apparente à ce que l'on nomme l'Internet des objets : Internet of Things, abrégé IoT.\n",
    "\n",
    "Grâce à la connexion à l'IoT, nous pouvons interagir avec un large éventail de capteurs à travers le monde entier en temps réel et nous pouvons maintenant prendre des décisions intelligentes en utilisant nos appareils.\n",
    "\n",
    "> Activer la cellule de code suivante pour voir Ladyada expliquer à Adabot les fonctionnalitées du CPX :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<center>\n",
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/4lGRgO40UhM\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
       "</center>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<center>\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/4lGRgO40UhM\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
    "\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un CPX est à la fois autonome et extensible. En plus d'utiliser ses LED intégrées, boutons et capteurs, nous pouvons élargir sa gamme de fonctions en l'insérant dans une extension :\n",
    "\n",
    "<img src=\"https://cdn-shop.adafruit.com/970x728/3093-02.jpg\" width=\"40%\">\n",
    "<center><figcaption><a href=\"https://www.adafruit.com/product/3093\">Adafruit CRICKIT for Circuit Playground Express</a></figcaption></center>\n",
    "\n",
    "Donc finalement, Circuit Playground Express est [tout ce que vous pouvez imaginer](https://learn.adafruit.com/category/express?total_count=139) . Vous pouvez le transformer en votre dispositif de messagerie, console de jeu, vêtement intelligent, alarme antivol, contrôleur de maison intelligente...<br>\n",
    "\n",
    "A peu près tout ce que votre imagination peut créer en utilisant des capteurs supplémentaires, en réalisant un boitier ou un support pour la carte, et en programmant son microcontroleur.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Origine :\n",
    "\n",
    "[Adafruit Industries](https://www.adafruit.com/about) est une compagnie  new yorkaise produisant du matériel libre qui a été mise sur pieds par [Limor Fried](https://fr.wikipedia.org/wiki/Limor_Fried)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<center>\n",
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/cwpIx7n6UYg\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
       "</center>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<center>\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/cwpIx7n6UYg\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le nom Adafruit qui vient du pseudonyme «ladyada» utilisé en ligne par Fried. C'est un hommage à la pionnière informatique [Ada Lovelace](https://fr.wikipedia.org/wiki/Ada_Lovelace).\n",
    "\n",
    "Le but de la compagnie est d'encourager les gens à s'impliquer dans la technologie, la science et l'ingénierie. Leurs projets sont conçus pour être des systèmes pratiques - et pas seulement des exercices académiques - et pour **encourager plus de femmes à s'intéresser à ce domaine**.\n",
    "\n",
    "La compagnie conçoit et fabrique nombre de produits électroniques et vend une grande variété de composants électroniques, d'outils et d'accessoires via son commerce en ligne : on va retrouver beaucoup de shields spécifiques pour les cartes Arduino ou Raspberry PI mais aussi une grande variété de cartes breakout et des créations originales comme le CPX.\n",
    "\n",
    "Tous les produits d'Adafruit sont manufacturés dans leur usine de 4.000 mètres carrés dans le quartier West SoHo de Manhattan à New York.\n",
    "\n",
    "Adafruit produit également de nombreuses [ressources pour apprendre](https://learn.adafruit.com/), y compris des tutoriels écrits et des vidéos disponibles notamment sur une [chaine Youtube](https://www.youtube.com/adafruit) qui compte plus de 300000 abonnés...\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programmation :\n",
    "\n",
    "## Inventaire des solutions :\n",
    "\n",
    "Trois voies permettent de programmer un CPX :\n",
    "- MakeCode\n",
    "- Arduino IDE\n",
    "- CircuitPython\n",
    "\n",
    "### MakeCode :\n",
    "\n",
    "<img src=\"https://ericecmorlaix.github.io/img/MakeCodeCPX.png\" width=\"50%\">\n",
    "<center><figcaption><a href=\"https://makecode.adafruit.com/\">https://makecode.adafruit.com/</a></figcaption></center>\n",
    "\n",
    "Pour débuter, le principal outil de programmation en ligne pour le Circuit Playground Express est le JavaScript Block Editor de Microsoft :\n",
    "\n",
    "Vous éditez votre code à partir du site Web, vous le testez sur l’émulateur puis vous téléchargez le binaire (fichier.uf2 compilé à la demande) afin de programmer votre micro:bit. Et rien de complexe dans cette programmation : il suffit de brancher le câble USB à un ordinateur, et le micro:bit est reconnu comme une clef USB (stockage de masse). Une simple copie du fichier téléchargé sur ce support de stockage émulé suffit à déclencher la reprogrammation du micro:bit, qui se déconnectera automatiquement et lancera votre code. On ne peut plus simple :\n",
    "- https://learn.adafruit.com/adafruit-circuit-playground-express/makecode\n",
    "\n",
    "### Arduino :\n",
    "\n",
    "<img src=\"https://ericecmorlaix.github.io/img/arduino.png\" width=\"30%\">\n",
    "<center><figcaption><a href=\"https://www.arduino.cc/\">https://www.arduino.cc/</a></figcaption></center>\n",
    "\n",
    "Des trois solutions de programmation prises en charge par Circuit Playground Express, [Arduino](https://www.arduino.cc/) est le plus ancien des langages. Arduino a plus de dix ans de projets et d’historique. Vous trouverez donc beaucoup de codes existants que vous pourrez utiliser avec votre CPX.\n",
    " \n",
    "Arduino est essentiellement en C / C ++ avec une bibliothèque intégrée d’interfaces matérielles. C'est le plus bas des trois langages: vous pouvez intégrer un assemblage, écrire du code ultra-rapide et utiliser pleinement la mémoire et le système de fichiers. Mais ... c'est plus difficile à utiliser pour les débutants! \n",
    "\n",
    "Aussi, si vous êtes un expert Arduino, vous trouverez avantage à [utiliser CPX avec l'IDE Arduino](https://learn.adafruit.com/adafruit-circuit-playground-express/arduino).\n",
    "\n",
    "Mais si vous commencez à coder, commencez par consulter [MakeCode](https://learn.adafruit.com/adafruit-circuit-playground-express/makecode).\n",
    "\n",
    "Enfin, si vous souhaitez un développement rapide sans téléchargement / compilation ni gestion de la mémoire, consultez [CircuitPython](https://learn.adafruit.com/adafruit-circuit-playground-express/circuitpython-quickstart). Ce n’est pas aussi rapide qu’Arduino, mais il est plus rapide à coder, plus simple et finalement plus amusant...\n",
    "\n",
    "\n",
    "### CircuitPython :\n",
    "\n",
    "<img src=\"https://ericecmorlaix.github.io/img/CircuitPython_Logo.png\" width=\"50%\">\n",
    "<center><figcaption><a href=\"https://learn.adafruit.com/adafruit-circuit-playground-express/what-is-circuitpython\">Qu'est ce que CircuitPython</a></figcaption></center>\n",
    "\n",
    "CircuitPython est un langage de programmation dérivé de MicroPython en Open Source et adapté pour faciliter le prototypage électronique sur les cartes de développement pédagogique conçues et vendues par [Adafruit](https://www.adafruit.com/).\n",
    "\n",
    "[Le projet CircuitPython, en constant développement sur GitHub](https://github.com/adafruit/circuitpython), propose des API de base Python unifiées et une liste croissante de bibliothèques Adafruit et de pilotes associés.\n",
    "\n",
    "[MicroPython](https://github.com/micropython) est une adaptation allégée de Python3 créée par [Damien George](https://github.com/dpgeorge) pour la programmation de certains microcontôleurs comme celui du BBC micro:bit.\n",
    "\n",
    "Damien George est l'un des principaux [contributeurs du projet CircuitPython](https://github.com/adafruit/circuitpython/graphs/contributors).\n",
    "\n",
    "Contrairement à la carte BBC micro:bit en MicroPython, il n'existe pas d'éditeur en ligne pour le CPX en CircuitPython.\n",
    "\n",
    "Dans la suite de ce bloc-note, nous allons explorer différentes solutions pour faire fonctionner le Circuit Playground Express en Python...\n",
    "\n",
    "\n",
    "### Remarque : \n",
    "Il est également possible d'utiliser le Circuit Playground Express (CPX) avec [Code.org](https://code.org/) CS Discoveries course : https://learn.adafruit.com/adafruit-circuit-playground-express/code-org-csd.\n",
    "\n",
    "\n",
    "## Hello World :\n",
    "\n",
    "Le premier programme que réalise tout apprenti informaticien est le fameux [Hello World!](https://fr.wikipedia.org/wiki/Hello_world)... Cela permet avec un programme minimal de prendre en main un langage et surtout de s'assurer du bon fonctionnement de l'environnement de développement choisi [IDE](https://fr.wikipedia.org/wiki/Environnement_de_d%C3%A9veloppement).\n",
    "\n",
    "Au moyen du câble fourni, raccordez le CPX sur un port USB de l'ordinateur. Le PC doit reconnaitre la carte comme un nouveau lecteur :\n",
    "\n",
    "- Si aucun lecteur n'apparait, appuyer sur le bouton poussoir repéré `RESET`, c'est le plus petit bouton qui se situe au centre de la carte.\n",
    "\n",
    "- Si un lecteur nommé `CIRCUITPY(E:)` apparait, c'est parfait vous pouvez poursuivre...\n",
    "\n",
    "- Si un lecteur nommé `CPLAYBOOT(E:)` apparait, il faut télécharger le plus récent fichier [adafruit-circuitpython-circuitplayground_express-v-.-.-.uf2](https://github.com/adafruit/circuitpython/releases/latest) puis le glisser/déposer dans le lecteur `(E:)`...  \n",
    "            \n",
    "> Besoin d'aide supplémentaire : https://learn.adafruit.com/adafruit-circuit-playground-express/circuitpython-quickstart#install-or-update-circuitpython-18-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Avec l'éditeur Mu\n",
    "\n",
    "A partir de Cortana, rechercher et lancer l'application de bureau `Mu`, au démarage choisir le mode `Adafruit CircuitPython`\n",
    "\n",
    "Ce mode a été developpé conjointement avec Adafruit pour faciliter la programmation de leur gamme de cartes à microcontrolleur fonctionnant en langage CircuitPython.\n",
    "\n",
    "Au démarrage, l'éditeur Mu reconnait la carte connectée à l'ordinateur et ouvre le fichier nommé `code.py` s'il est présent dans la mémoire de votre CPX ; ou, à défault, il crée un nouveau fichier nommé pour l'instant `Sans titre` et vous propose `# Ecrit ton programme ici ;-)`, une invitation fort sympatique...\n",
    "\n",
    "Copier et coller le code suivant à la place du code précédent :\n",
    "````python\n",
    "# Mon premier programme en CircuitPython sur CPX\n",
    "import board\n",
    "import digitalio\n",
    "import time\n",
    " \n",
    "led = digitalio.DigitalInOut(board.D13)\n",
    "led.direction = digitalio.Direction.OUTPUT\n",
    " \n",
    "while True:\n",
    "    led.value = True\n",
    "    time.sleep(0.5)\n",
    "    led.value = False\n",
    "    time.sleep(0.5)\n",
    "````\n",
    "Enregistrer votre programme dans le lecteur nommé `CIRCUITPY(E:)` en le nommant `code.py`:\n",
    "\n",
    "<img src=\"https://ericecmorlaix.github.io/img/MuCPX00.png\" alt=\"Enregitrer avec Mu sur CPX\" width=88%>\n",
    "\n",
    "La LED rouge répérée D13 à droite du connecteur micro-USB sur la carte CPX doit clignoter à la fréquence de 1 Hz ?\n",
    "\n",
    "<img src=\"https://i.imgur.com/ObPutOO.png\" alt=\"CPX LED rouge D13\" width=30%>\n",
    "\n",
    "Si oui, vous venez de réussir votre premier programme en CircuitPython sur CPX !\n",
    "\n",
    "Modifiez alors la fréquence de pulsation de la LED de votre code dans l'éditeur Mu puis appuyez sur `Enregistrer`.\n",
    "\n",
    "Le CPX modifie aussitôt son comportement !\n",
    "On observe ici la simplicité et la rapidité qu'offre l'éditeur Mu pour la programmation du CPX...\n",
    "\n",
    "Mais cette application offre encore d'autres fonctionnalités très intéressantes accessibles par ces deux boutons :\n",
    "\n",
    "<img src=\"https://codewith.mu/img/en/tutorials/adafruit_buttons.png\" alt=\"Boutons de Mu pour CPX\" width=15%>\n",
    "\n",
    "Ces fonctions sont exposées dans ce rapide tutoriel : https://codewith.mu/en/tutorials/1.0/adafruit\n",
    "\n",
    "Le bouton «Série» crée un nouveau volet entre l’éditeur de texte et le pied de page de Mu, qui se connecte à l'interpréteur CircuitPython du périphérique CPX.\n",
    "\n",
    "Toutes les données série émises par l'appareil apparaîtront ici : modifier votre code en ajoutant par exemple un `print(\"Bonjour, depuis le CPX\")` dans la boucle...\n",
    "\n",
    "Le message émis répétitivement par le CPX s'affiche dans la fenêtre nommée `Adafruit CircuitPython REPL`.\n",
    "\n",
    "Maintenant faites une erreur dans votre code, par exemple oubliez le `t` de `print()`, enregitrer, démarrer le moniteur série (faire un `Ctrl-D` pour recharger le programme si nécessaire) et lire le message... Comprenez-vous tout l'intérêt de cet outil ?\n",
    "\n",
    "Si vous devez accéder au CircuitPython REPL, assurez-vous que le volet est activé au clavier (cliquez simplement dessus!), puis tapez CTRL-C, comme indiqué ci-dessous:\n",
    "<img src=\"https://codewith.mu/img/en/tutorials/adafruit_serial.gif\" alt=\"Boutons Série de Mu pour CPX\" width=88%>\n",
    "\n",
    "Le terme “REPL” est un acronyme et signifie “Lire, Évaluer, Imprimer, Boucler”, (Read-Evaluate-Print-Loop), ce qui décrit succinctement ce que le panneau fait pour vous. Il lit les instructions de Python que vous tapez, évalue leur signification, affiche le résultat obtenu, puis effectue une boucle pour attendre votre prochaine instruction Python.\n",
    "\n",
    "Comme vous pouvez le constater dans l'exemple ci-dessus, utiliser le REPL de MicroPython revient à avoir une conversation avec le CPX en Python. Tout ce que vous pouvez faire dans un script Python classique, vous pouvez le faire dans le REPL. C’est une façon amusante d’explorer de façon ludique les capacités de CircuitPython sur le CPX.\n",
    "\n",
    "**C'est donc le moment d'essayer des choses... Par exemple, commencez par taper `help()`dans le REPL de l'éditeur Mu et laissez-vous guider par les propositions suggérées là...**\n",
    "\n",
    "Enfin, le bouton \"Plot\" ouvre le traceur de Mu. Si votre Circuit Playground Express produit des tuples de nombres via la connexion série, le traceur les affiche sous forme de graphique. Ceci est extrêmement utile pour visualiser les données que vous pourriez mesurer via le CPX. Pour plus d’informations à ce sujet, lisez [ce tutoriel sur le traceur de Mu](https://learn.adafruit.com/sensor-plotting-with-mu-and-circuitpython)\n",
    "\n",
    "<img src=\"https://codewith.mu/img/en/tutorials/adafruit_plotter.gif\" alt=\"Boutons de Mu pour micro:bit\" width=88%>\n",
    "\n",
    "\n",
    "Le site de l'éditeur Mu : http://codewith.mu et son dépot GitHub : https://github.com/mu-editor/mu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Communication avec le REPL,  l'interpréteur Python embarqué d'un CPX\n",
    "\n",
    "Nous allons faire fonctionner CPX directement depuis son interpréteur Python via une communication série depuis un PC.\n",
    "\n",
    "## Dans un terminal avec PuTTY  :\n",
    "Sur un PC Windows 10, faire un clic droit sur le menu `démarrer` et choisir `Gestionnaire de périphériques`, dérouler la liste des `Ports (COM et LPT)`, brancher et/ou débrancher le CPX pour repérer sur quel numéro de COM est connectée votre carte.\n",
    "\n",
    "<img src=\"https://ericecmorlaix.github.io/img/W10-Gestionnaire00.png\" alt=\"Gestionnaire de périphériques\" width=30%>\n",
    "\n",
    "A partir de Cortana, rechercher et lancer l'application de bureau `PuTTY`. Choisir une connection de type `Serial` (Série), saisir le numéro du port COM de vore carte et régler la vitesse de communication à 115200 bauds (bits/seconde) puis cliquer sur le bouton `Open` pour ouvrir la connection et établir la communication entre le PC et le BBC micro:bit.\n",
    "\n",
    "<img src=\"https://ericecmorlaix.github.io/img/W10-PuTTY00.png\" alt=\"application de bureau PuTTY\" width=40%>\n",
    "\n",
    "Un fenêtre de terminal s'ouvre. Après avoir appuyé sur la touche `Entrée`de votre clavier,  Les trois chevrons `>>>` d'un interpréteur python doivent apparaitre :\n",
    "\n",
    "<img src=\"https://ericecmorlaix.github.io/img/W10-PuTTY01.png\" alt=\"fenêtre de terminal\" width=40%>\n",
    "\n",
    "Saisir alors quelques instructions en Python, et d'autre en CircuitPython de la bibliothèque du CPX...\n",
    "\n",
    "Ce qu'il faut bien comprendre ici, c'est que ces instructions ne s'exécutent pas sur votre PC mais à l'autre bout du câble USB dans le processeur (CPU) du micro-contrôleur (µC) du Circuit Playground Express.\n",
    "\n",
    "Génial, votre CPX sait donc calculer, en fait, il sait faire à peu près tout ce qu'un programmme Python peut faire dans les limites de ses capacités de mémoire, 2 MB de mémoire stockage ([Flash](https://fr.wikipedia.org/wiki/M%C3%A9moire_flash)) plus 16 ko de mémoire vive ([RAM](https://fr.wikipedia.org/wiki/M%C3%A9moire_vive), Random Access Memory), et à la vitesse de 48 Mhz, sa fréquence d'horloge...\n",
    "\n",
    "Essayer des choses un peu plus évoluées, par exemple, définir une fonction telle que :\n",
    "\n",
    "````python\n",
    "def maFonction():\n",
    "    while True:\n",
    "        if \n",
    "        elif \n",
    "            break\n",
    "        else:\n",
    "            \n",
    "    \n",
    "````\n",
    "> **Rappel** : la touche `Tab` permet de faire de l'auto-complétion, saisir `` suivi d'un `Tab` produit ``...\n",
    "\n",
    "Revenir aux trois chevrons `>>>` en appuyant quatre fois sur `Entrée`, puis appeler votre fonction et tester votre programme...\n",
    "\n",
    "> Observer la réaction de la LED orange située à l'arrière du BBC micro:bit à chaque saisie d'un caractère dans la fenêtre de l'interpréteur... On devine le fonctionnement de la communication du PC vers le BBC micro:bit, c'est celle qu'utilise la fonctionnalité REPL dans l'éditeur Mu...\n",
    "\n",
    "<!-- \n",
    "    Pour en savoir plus à ce sujet :\n",
    "- Communication point à point de type RS232 et décodage d'une trame\n",
    "- essayer avec l'application Tera Term et se questionner sur la configuration du port série en baud rate of 115200, data 8 bits, parity none, stop 1 bit.\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/devguide/repl.html \n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PARTIE A FINALISER EN REPRENANT LA TRAME DU BBC micro:bit...\n",
    "\n",
    "## Dans les cellules de code d'un jupyter notebook :\n",
    "\n",
    "Pour tester directement depuis les cellules de ce bloc-note il vous faut démarrer un serveur jupyter notebook en local sur votre PC pour y ouvrir une copie de ce document.\n",
    "\n",
    "Dans le menu choisir `Kernel>Change Kernel>micro:bit`. Ce noyau est normalement disponible sur les PCs Windows 10 du labo de SI du lycée, si ce n'est pas votre cas, il suffit de suivre la procédure à cette adresse : https://github.com/takluyver/ubit_kernel\n",
    "\n",
    "On peut alors faire un premier test par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display.scroll('Test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "> Si cela fonctionne, c'est parfait vous pouvez poursuive...\n",
    ">\n",
    "> Si ce n'est pas le cas, alors vérifiez que rien n'empêche la communication série vers votre BBC micro:bit :\n",
    "- la carte est bien branchée par un cordon en USB (la LED orange située à l'arrière du BBC micro:bit est allumée) ;\n",
    "- l'éditeur Mu (surtout sa fonction REPL) est désactivé ;\n",
    "- la précédente communication avec PuTTY est bien arrêtée, sinon fermer la fenêtre PuTTY ;\n",
    "- il n'y a qu'un bloc-note ouvert avec le noyau micro:bit... \n",
    "\n",
    "Tout va bien, alors essayez maintenant avec la précédente boucle :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    if button_a.is_pressed():\n",
    "        display.show(Image.HAPPY)\n",
    "    elif button_b.is_pressed():\n",
    "        display.scroll(\"kenavo\")\n",
    "        break\n",
    "    else:\n",
    "        display.show(Image.SAD)\n",
    "display.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Faire un `break`** :\n",
    ">\n",
    "> Tant qu'une cellule de code est en cours d'exécution on voit `In[*] :` sur sa gauche. Une fois l'exécution du code terminée, l'`*` est remplacé par un nombre indiquant l'ordre dans lequel les cellules du notebook se sont exécutées.\n",
    ">\n",
    "> Changer l'ordre d'exécution des cellules revient à changer l'ordres des instructions d'un script Python. Celà peut-être intéressant dans certaines situations de développement pour essayer des choses, mais celà peut quelques fois conduire à des résultats inattendus...\n",
    ">\n",
    "> Pour interrompre l'exécution d'une cellule de code il faut choisir `Interrupt` dans le menu `Kernel` ou cliquer sur le bouton <button class='fa fa-stop icon-stop btn  btn-xs btn-default'></button>.\n",
    ">\n",
    "> Mais le problème dans un jupyter notebook avec les boucles infinis telle que `while True:`c'est que l'`*` pourrait ne jamais être remplacé par un nombre, et recourrir à l'interruption du noyau n'est pas très judicieux dans ce cas.\n",
    ">\n",
    "> La solution la plus élégante est d'introduire dans le code une instruction de `break` qui fait sortir de la boucle et donc permet d'atteindre ici la fin du programme lorsque l'on reste appuyer sur le boutton `b`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayez encore autre chose avant de poursuivre, de façon assurément zen, votre exploration par un tour d'horizon de quelques fonctionnalités du BBC micro:bit..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inventaire de fonctions du BBC micro:bit :\n",
    "\n",
    "## Afficheur, sortie sur matrice de 5x5 LEDs :\n",
    "\n",
    "<img src=\"https://microbit.org/images/beating-heart.gif\" alt=\"Matrice de 25 LEDs\" width=40%>\n",
    "Essayer :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    display.set_pixel(2, 2, 9)\n",
    "    sleep(500)\n",
    "    display.set_pixel(2, 2, 0)\n",
    "    sleep(500)\n",
    "    if button_b.is_pressed():\n",
    "        display.scroll(\"kenavo\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### display\n",
    "Nous avons précédemmment utilisé les fonctions `display.scroll()` et `display.show()`.\n",
    "Exécuter les instructions suivantes pour découvrir plus avant le module display :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(display)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(display))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans la cellule suivante, placer le curseur après le `d` et appuyer sur la touche `Tab`. Ensuite, ajouter un point `.` après `display` et choisir `set_pixel` dans la liste déroulante puis faire `Ctrl+Entrée`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifier le programme précédent pour faire clignoter la LED du coin suppérieur gauche de la matrice ([Guide pour matrice à LED](https://microbit.org/guide/hardware/leds/)). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    display.set_pixel(2, 2, 9)\n",
    "    sleep(500)\n",
    "    display.set_pixel(2, 2, 0)\n",
    "    sleep(500)\n",
    "    if button_b.is_pressed():\n",
    "        display.scroll(\"kenavo\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Introduisons un peu d'aléatoire :\n",
    "Importer le module `random` de MicroPython et rechercher la fonction qui vous permettrait de modifier le précédent programme de sorte qu'à chaque seconde l'une ou l'autre des LED de la matice s'allume progressivement puis brusquement s'éteigne avant qu'une nouvelle LED ne s'allume et ainsi de suite..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "help(random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    display.set_pixel(2, 2, 9)\n",
    "    sleep(500)\n",
    "    display.set_pixel(2, 2, 0)\n",
    "    sleep(500)\n",
    "    if button_b.is_pressed():\n",
    "        display.scroll(\"kenavo\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Gestion du hasard :\n",
    "> - https://microbit-micropython.readthedocs.io/fr/latest/tutorials/random.html\n",
    "> - https://microbit-micropython.readthedocs.io/en/v1.0.1/random.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image :\n",
    "Explorer la classe `Image`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(Image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(Image))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "monImage = Image(\n",
    "    '33333:'\n",
    "    '36663:'\n",
    "    '36963:'\n",
    "    '36663:'\n",
    "    '33333:')\n",
    "\n",
    "display.show(monImage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayer d'afficher autre chose sur la matrice à LED du BBC micro:bit :\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/images.html\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pyled\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/image.html\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/display.html\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Détection d'une entrée TOR : boutons , touches, ... :\n",
    "\n",
    "### Boutons poussoirs\n",
    "\n",
    "<img src=\"https://microbit.org/images/microbit-features-buttons.png\" alt=\"Boutons A et B\" width=40%>\n",
    "\n",
    "La carte BBC micro:bit dispose, sur sa face avant, de deux boutons poussoir repérés par les lettres A et B.\n",
    "\n",
    "Nous avons précédemmment utilisé les fonctions `button_a.is_pressed()` et `button_b.is_pressed()`.\n",
    "Exécuter les instructions suivantes pour découvrir plus avant la classe `button` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(button_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(button_a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Touches\n",
    "\n",
    "<img src=\"https://microbit.org/images/microbit-features-pins.png\" alt=\"Touches 0,1,2\" width=40%>\n",
    "\n",
    "Il y a 25 connecteurs en cuivre sur la tranche du bas de la carte BBC micro:bit. Ce sont des Entrées/Sorties qui permettent au micro:bit d'interagir avec son environnement en s'y connectant physiquement.\n",
    "Les trois grandes broches (pin) repérées 0, 1, 2 sont sensibles à un changement de capacité provoqué au contact d'un doigt.\n",
    "\n",
    "> Normalement ces touches capacitives devraient réagir au conctact de votre doigt, mais pour plus d'efficaccité le plus sûr est de raccorder un bout d'un câble à pince crocodile au `GND` et avec l'autre bout de venir toucher la broche `0`.\n",
    "\n",
    "Essayer avec ce code par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from microbit import *\n",
    "\n",
    "nombreDeTouches = 0\n",
    "\n",
    "while True:\n",
    "    if pin0.is_touched():\n",
    "        nombreDeTouches += 1\n",
    "        display.scroll(str(nombreDeTouches))\n",
    "    elif button_b.is_pressed():\n",
    "        display.scroll(\"kenavo\")\n",
    "        break  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce code, expliquer ce qu'est `nombreDeTouches` et ce que font l'opérateur `+=` et la fonction `str()` :\n",
    "- `nombreDeTouches` est...\n",
    "- `+=` sert à...\n",
    "- `str()` permet de..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opérateurs Booléens :\n",
    "Avec les deux entrées TOR (Tout Ou Rien), le bouton A, le bouton B, qui ne peuvent prendre chacun que deux valeurs booléennes `False = 0` `True = 1` nous pouvons programmer et tester des fonctions de logique booléenne.\n",
    "#### Fontion ET :\n",
    "Par exemple, essayer avec la fonction dont l'[expression booléenne](https://fr.wikipedia.org/wiki/Expression_bool%C3%A9enne_(programmation_informatique)) serait `A et B`,   :\n",
    "> En Python l'opérateur booléen pour le ET est le mot clé `and`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    if (button_a.is_pressed() and button_b.is_pressed()):\n",
    "        display.show(Image.YES)\n",
    "    else:\n",
    "        display.show(Image.NO)\n",
    "        \n",
    "    if pin0.is_touched():\n",
    "        display.scroll(\"kenavo\")\n",
    "        break\n",
    "display.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compléter alors la table de véritée de la fonction logique **ET**, d'équation $A\\cdot B$ :\n",
    "\n",
    "|  A  |  B  | ET  |\n",
    "|:---:|:---:|:---:|\n",
    "|  0  |  0  |     |\n",
    "|  0  |  1  |     |\n",
    "|  1  |  0  |     |\n",
    "|  1  |  1  |     |\n",
    "\n",
    "#### Fontion OU :\n",
    "Programmer la fonction dont l'[expression booléenne](https://fr.wikipedia.org/wiki/Expression_bool%C3%A9enne_(programmation_informatique)) serait `A ou B`,   :\n",
    "> En Python l'opérateur booléen pour le OU est le mot clé `or`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    if (button_a.is_pressed() and button_b.is_pressed()):\n",
    "        display.show(Image.YES)\n",
    "    else:\n",
    "        display.show(Image.NO)\n",
    "        \n",
    "    if pin0.is_touched():\n",
    "        display.scroll(\"kenavo\")\n",
    "        break\n",
    "display.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compléter alors la table de véritée de la fonction logique **OU**, d'équation $A + B$ :\n",
    "\n",
    "|  A  |  B  | OU  |\n",
    "|:---:|:---:|:---:|\n",
    "|  0  |  0  |     |\n",
    "|  0  |  1  |     |\n",
    "|  1  |  0  |     |\n",
    "|  1  |  1  |     |\n",
    "\n",
    "#### Fontion NON :\n",
    "Programmer la fonction dont l'[expression booléenne](https://fr.wikipedia.org/wiki/Expression_bool%C3%A9enne_(programmation_informatique)) serait `non A`,   :\n",
    "> En Python l'opérateur booléen pour le NON est le mot clé `not`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compléter alors la table de véritée de la fonction logique **NON**, d'équation $\\bar{A}$ :\n",
    "\n",
    "|  A  | NON |\n",
    "|:---:|:---:|\n",
    "|  0  |     |\n",
    "|  1  |     |\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    if (button_a.is_pressed() and button_b.is_pressed()):\n",
    "        display.show(Image.YES)\n",
    "    else:\n",
    "        display.show(Image.NO)\n",
    "        \n",
    "    if pin0.is_touched():\n",
    "        display.scroll(\"kenavo\")\n",
    "        break\n",
    "display.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programmer chacune à leur tour les expressions booléennes suivantes et commpléter leur table de vérité respective :\n",
    "- `non (A et B)`\n",
    "\n",
    "|  A  |  B  |  ?  |\n",
    "|:---:|:---:|:---:|\n",
    "|  0  |  0  |     |\n",
    "|  0  |  1  |     |\n",
    "|  1  |  0  |     |\n",
    "|  1  |  1  |     |\n",
    "\n",
    "- `non (A ou B)`\n",
    "\n",
    "|  A  |  B  |  ?  |\n",
    "|:---:|:---:|:---:|\n",
    "|  0  |  0  |     |\n",
    "|  0  |  1  |     |\n",
    "|  1  |  0  |     |\n",
    "|  1  |  1  |     |\n",
    "\n",
    "\n",
    "- `non A et non B`\n",
    "\n",
    "|  A  |  B  |  ?  |\n",
    "|:---:|:---:|:---:|\n",
    "|  0  |  0  |     |\n",
    "|  0  |  1  |     |\n",
    "|  1  |  0  |     |\n",
    "|  1  |  1  |     |\n",
    "\n",
    "\n",
    "- `non A ou non B`\n",
    "\n",
    "|  A  |  B  |  ?  |\n",
    "|:---:|:---:|:---:|\n",
    "|  0  |  0  |     |\n",
    "|  0  |  1  |     |\n",
    "|  1  |  0  |     |\n",
    "|  1  |  1  |     |\n",
    "\n",
    "\n",
    "Tel [De Morgan](https://fr.wikipedia.org/wiki/Lois_de_De_Morgan), que concluez-vous ? Proposez alors un nom pour ces fonctions...\n",
    "\n",
    "Compléter la table de vérité et programmer le fonctionnement d'un éclairage par va et vient dont l'équation serait : $$ L =\\bar{A}\\cdot B+A\\cdot\\bar{B}$$\n",
    "\n",
    "|  A  |  B  |  ?  |\n",
    "|:---:|:---:|:---:|\n",
    "|  0  |  0  |     |\n",
    "|  0  |  1  |     |\n",
    "|  1  |  0  |     |\n",
    "|  1  |  1  |     |\n",
    "\n",
    "Comment nommerait-on une telle fonction booléenne ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plus d'informations sur les boutons et les touches :\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/buttons.html\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pybutton\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/button.html\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/io.html\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pytouch\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/pin.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Autres entrées digitales :\n",
    "\n",
    "Nous avons déjà utilisé plus haut les boutons et les touches 0, 1, 2 en tant qu'entrée TOR (Tout Ou Rien). Le BBC micro:bit permet d'utiliser d'autres broches en tant qu'entrée binaire avec l'instruction `pinN.read_digital()` le N pouvant être remplacé par les numéros des broches (pin) de 0 à 16 ainsi que 19 et 20.\n",
    "\n",
    "<img src=\"https://microbit-micropython.readthedocs.io/en/v1.0.1/_images/pinout.png\" alt=\"Broches\" width=60%>\n",
    "\n",
    "Si ces broches sont utilisées en tant qu'entrée digitale alors leurs autres fonctionnalités potentiels ne sont plus disponibles. Par exemple les broches pin5 et pin11 sont aussi raccordées respectivement au boutons A et B. De même les broches pin3, pin4, pin6, pin7, pin9 et pin10 sont utilisées pour la matrice de LEDs et il faut [désactiver l'affichage](https://microbit-micropython.readthedocs.io/en/latest/display.html#microbit.display.off) pour les utiliser à autre chose...\n",
    "\n",
    "Pour pouvoir utiliser ces broches il faut les raccorder à d'autres composants électoniques par l'intermédiaire de fils à connecteur bannane ou à pince crocodile ou encore avec des straps sur une breadboard via un connecteur...\n",
    "\n",
    "<img src=\"https://ericecmorlaix.github.io/img/breadbit.png\" width=\"40%\">\n",
    "<center><figcaption><a href=\"https://www.proto-pic.co.uk/breadbit-prototyping-system-for-microbit.html\">bread:bit</a></figcaption></center>\n",
    "\n",
    "Plus d'informations sur les broches du BBC micro:bit :\n",
    "\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/pin.html\n",
    "- https://tech.microbit.org/hardware/edgeconnector_ds/\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pycomp\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pybutt1\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Communication :\n",
    "\n",
    "### Série :\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/network.html\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/uart.html\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pybit2bit\n",
    "\n",
    "### Radio :\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/radio.html\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=radio\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/radio.html\n",
    "\n",
    "### I2C, SPI :\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/i2c.html\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/spi.html\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=chuck"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## os :\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=files\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/tutorials/storage.html\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/filesystem.html\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/os.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Capteurs embarqués :\n",
    "\n",
    "### Température :\n",
    "\n",
    "http://www.multiwingspan.co.uk/micro.php?page=hot\n",
    "https://microbit-micropython.readthedocs.io/en/v1.0.1/microbit.html#microbit.temperature\n",
    "\n",
    "### Luminosité :\n",
    "https://microbit-micropython.readthedocs.io/fr/latest/display.html#microbit.display.read_light_level\n",
    "\n",
    "### Accéléromètre :\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/movement.html\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/gestures.html\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pyacc\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/accelerometer.html\n",
    "\n",
    "### Boussole :\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/direction.html\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/compass.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entrées Analogiques :\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/pin.html#microbit.MicroBitAnalogDigitalPin\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pypot\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pybutt\n",
    "\n",
    "## Sorties :\n",
    "\n",
    "### Digitales :\n",
    "\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/pin.html\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pymoreled\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### PWM :\n",
    "\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/pin.html#pulse-width-modulation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Faites du Bruit :\n",
    "### Musique :\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/music.html\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/music.html\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/audio.html\n",
    "\n",
    "### Voix :\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=speech\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/tutorials/speech.html\n",
    "- https://microbit-micropython.readthedocs.io/en/v1.0.1/speech.html\n",
    "\n",
    "### Buzzer\n",
    "- https://microbit-micropython.readthedocs.io/fr/latest/tutorials/io.html#bip-bip\n",
    "- http://www.multiwingspan.co.uk/micro.php?page=pybuzz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": ""
    }
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": ""
    }
   },
   "source": [
    "\n",
    " \n",
    " # Ressources :\n",
    " \n",
    "- https://www.adafruit.com/product/3333\n",
    "\n",
    "- https://learn.adafruit.com/adafruit-circuit-playground-express\n",
    "\n",
    "- https://learn.adafruit.com/category/express\n",
    "\n",
    "- https://makecode.adafruit.com/\n",
    "- https://learn.adafruit.com/welcome-to-circuitpython\n",
    "\n",
    "- https://learn.adafruit.com/adafruit-circuit-playground-express/installing-mu-editor\n",
    "\n",
    "- https://codewith.mu/en/tutorials/1.0/adafruit\n",
    "\n",
    "- https://learn.adafruit.com/adafruit-circuit-playground-express/circuitpython-audio-out\n",
    "\n",
    "- https://learn.adafruit.com/make-it-talk\n",
    "\n",
    "- https://learn.adafruit.com/adafruit-circuit-playground-express/playground-sound-meter\n",
    "\n",
    "- https://learn.adafruit.com/adafruit-circuit-playground-express/playground-drum-machine\n",
    "\n",
    "- https://learn.adafruit.com/infrared-ir-receive-transmit-circuit-playground-express-circuit-python/overview\n",
    "\n",
    "\n",
    "\n",
    "https://www.youtube.com/watch?v=yQdOi_H9Qno\n",
    "\n",
    "Adafruit Circuit Playground MIDI Touch Controller\n",
    "www.youtube.com\n",
    "New New New World Symphony. Close encounters with capacitive touch and USB MIDI driving Independence soft-synth with sample playback.\n",
    "https://learn.adafruit.com/circuitpython-made-easy-on-circuit-playground-express\n",
    "https://learn.adafruit.com/circuit-playground-express-serial-communications/what-is-serial-communications\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}