{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conversions décimal-binaire-hexadécimal en langage Python\n",
    "\n",
    "Dans ce notebook nous allons étudier les fonctions natives de Python qui permettent de réaliser des conversions entre les différents systèmes de réprésentation des nombres.\n",
    "\n",
    "Nous écrirons ensuite l'intégralité du code permettant, sur la carte BBC MicroBit, de convertir en décimal un nombre entré en binaire à l'aide de deux boutons poussoirs.\n",
    "\n",
    "Remarque : il faut aussi être capable de faire des conversions \"à la main\" : revoir le polycopié \"Représentation des données : Types et valeurs de base\" étudié en cours.\n",
    "\n",
    "## 1- Ecriture d'un nombre en Python\n",
    "Les activités liées au numérique peuvent nécessiter parfois de travailler en binaire ou en hexadécimal (qui est en fait une forme d’écriture plus compacte) plutôt que dans notre système décimal usuel. On peut même travailler en octal... \n",
    "Cela pourrait être source de confusion : par exemple, que signifie l’écriture du nombre « 1000 » : \n",
    "\n",
    "    * en décimal : mille ?\n",
    "\n",
    "    * en binaire l’écriture 1000 a comme équivalent décimal le nombre 8 ?\n",
    "\n",
    "    * en hexadécimal, l’écriture 1000 a comme équivalent décimal le nombre 4096 ?\n",
    "\n",
    "Pour éviter les risques de confusions, on précisera la base dans laquelle le nombre est écrit. Malheureusement il n’y a pas de convention unique… la précision de la base se faisant par un préfixe ou par un suffixe, et pas toujours le même !!!\n",
    "\n",
    "En Python, la convention est la suivante :\n",
    "    * un nombre entier, écrit comme on le fait dans la vie courante est représenté en décimal\n",
    "\n",
    "    * précédé du préfixe 0b ce nombre est écrit en binaire (il est bien sûr constitué uniquement de 0 et de 1)\n",
    "\n",
    "    * précédé du préfixe 0x ce nombre est écrit en hexadécimal\n",
    "\n",
    "    * précédé du préfixe 0o il est écrit en octal\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# écrire un nombre dans la base de son choix puis lancer l'interpréteur Python avec la combinaison \n",
    "# de touches {Ctrl + Entrée} pour en obtenir l'écriture décimale\n",
    "# nombre à convertir en décimal :\n",
    "print(0x1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2- Fonctions natives de conversion :\n",
    "\n",
    "Le langage Python possède 3 fonctions natives pour réaliser la conversion d'un nombre\n",
    "(**fonctions natives** ou \"**builtin functions**\" en anglais : ce sont des fonctions qui font partie du langage et que l'on n'a donc pas besoin d'aller chercher dans un module externe)  :\n",
    "\n",
    "    * bin(ce_nombre) pour convertir ce_nombre en binaire\n",
    "    * hex(ce_nombre) pour convertir ce_nombre en hexadécimal\n",
    "    * int(ce_nombre) pour convertir ce_nombre en décimal\n",
    "\n",
    "ce_nombre pourra être donné en décimal, en binaire ou en hexadécimal en respectant le format vu au paragraphe précédent.\n",
    "\n",
    "Exemple : pour convertir le nombre décimal 141 en binaire, on entrerait dans l’interpréteur : bin(141), ce qui retournerait '0b10001101'.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1- Conversion décimal <-> binaire :\n",
    "\n",
    "Dans la cellule ci-dessous, entrer le code permettant :\n",
    "\n",
    "    1- de convertir le nombre décimal '125' en binaire\n",
    "\n",
    "    2- de convertir le nombre binaire '10011101' en décimal \n",
    "Remarque : on utilisera la fonction print() pour afficher et garder à l'écran les différents résultats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conversion de '125' en binaire :\n",
    "\n",
    "# Conversion de '10011101' en décimal :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2- Conversion décimal <-> hexadécimal :\n",
    "\n",
    "Dans la cellule ci-dessous, entrer le code permettant :\n",
    "\n",
    "    1- de convertir et d'afficher le nombre décimal '125' en hexadécimal\n",
    "    \n",
    "    2- de convertir le nombre hexadécimal '0FA4'en décimal "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conversion de '125' en hexadécimal :\n",
    "\n",
    "# Conversion de '0FA4' en décimal :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3- Synthèse :\n",
    "**EXERCICE 1:** Réaliser les conversions demandées ci-dessous ; observer le nombre de bits nécessaires à l'affichage en binaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convertir 0xF en décimal puis en binaire\n",
    "\n",
    "\n",
    "# Convertir 0xFF en décimal puis en binaire\n",
    "\n",
    "\n",
    "# Convertir 0xFFFF en décimal puis en binaire\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**EXERCICE 2:**\n",
    "On veut avoir un programme qui demande à l'utilisateur un nombre **n** en décimal et qui en réalise (sur une ligne d'affichage) la conversion en binaire et en hexadécimal. Le rédiger dans la cellule de code ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Programme de conversion décimal vers binaire et hexadécimal :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3- Convertisseur Binaire -> Décimal avec la carte BBC Micro:Bit\n",
    "\n",
    "\n",
    "\n",
    "Au paragraphe précédent,lors d'une telle conversion, le nombre binaire était passé en une seule fois à la fonction int(). Ici le problème est différent car l'octet à convertir sera entré bit par bit à l'aide des deux boutons poussoirs A et B  présents sur la carte Micro:Bit :\n",
    "\n",
    "![image : microbit_aff_1.png](images/microbit_aff_1.png)\n",
    "\n",
    "**Cahier des charges du code à écrire :**\n",
    "\n",
    "    * au démarrage du programme, on rentre dans une boucle infinie en affichant le symbole ‘?’ (le programme tourne alors en boucle en attendant l'appui sur l'un des deux boutons poussoirs\n",
    "    \n",
    "    * le code binaire constituant l’octet à convertir sera entré à l’aide des deux boutons poussoirs :\n",
    "        - si le bouton A est appuyé, on entre alors un 0 ; \n",
    "        - si le bouton B est appuyé, ce sera alors un 1 ;\n",
    "        - le code binaire est entré de la gauche vers la droite. Exemple : pour entrer le code 01100001, on appuiera 1 fois sur le bouton A puis 2 fois sur le bouton B, puis 4 fois sur le bouton A et une fois sur le bouton B.\n",
    "\n",
    "    * A chaque appui sur l’un des boutons l’afficheur devra afficher soit un 0 soit un 1 pendant une demi-seconde puis s’effacer en attendant un nouvel appui sur un des boutons.\n",
    "    \n",
    "    * Après le huitième appui, l’octet étant alors constitué, on fait défiler sur l’afficheur la valeur décimale de \n",
    "    cet octet, puis on retourne au début de la boucle infinie pour pouvoir faire une nouvelle conversion.\n",
    "    \n",
    "Au moins trois techniques différentes pourraient être envisagées :\n",
    "\n",
    "    * l'une arithmétique basée sur la technique de pondération des chiffres en fonction de la position\n",
    "\n",
    "    * en utilisant les opérateurs de décalage de bits ( >> ou << )\n",
    "    \n",
    "    * à l'aide d'une séquence ordonnée (liste, chaîne de caractères ...)\n",
    "    \n",
    "Les deux dernières techniques nécessitant des connaissances plus approfondies, nous utiliserons la première méthode, qui correspond aussi à la présentation qui en a été faite dans le cours.\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1- Principe mis en oeuvre :\n",
    "Le cahier des charges impose de travailler sur un octet, donc sur 8 bits que l'on va nommer de b0 à b7. \n",
    "Chacun de ces bits a un poids tel qu'indiqué ci-dessous :\n",
    "                                \n",
    "   b7 | b6 | b5 | b4 | b3 | b2 | b1 | b0 \n",
    ":----: | :----: | :----: |:----: | :----: | :----: |:----: | :----: \n",
    "128 | 64 | 32  |  16  |  8  |  4  |  2  |  1  \n",
    "                              \n",
    "                             \n",
    "Par exemple la conversion de l'octet 1 1 0 1 0 0 1 0 donnera : 210\n",
    "\n",
    "Ci-dessous deux méthodes arithmétiques similaires utilisables dans un script Python pour convertir le nombre binaire '0b11010010' en nombre décimal. \n",
    "\n",
    "Remarques :\n",
    "   \n",
    "   - en Python le symbole de multiplication est l'étoile : '*', \n",
    "   - l'élévation à une puissance se réalise avec la double étoile '**' \n",
    "   - la deuxième écriture (celle avec les puissances de 2) permet de mieux faire apparaître l'algorithme que l'on pourrait mettre en oeuvre.\n",
    "                                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "octet = 128*1 + 64*1 + 32*0 + 16*1 + 8*0 + 4*0 + 2*1 + 1*0\n",
    "print(octet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ou encore :\n",
    "octet = 2**7*1 + 2**6*1 + 2**5*0 + 2**4*1 + 2**3*0 + 2**2*0 + 2**1*1 + 2**0*0\n",
    "print(octet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... mais de nouveau, on a entré l'intégralité du nombre binaire en une seule fois avant de le convertir. \n",
    "\n",
    "Comme l'octet sera entré en 8 étapes, on peut envisager de construire son équivalent décimal en autant d'étapes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compléter le code ci-dessous pour obtenir en sortie un nombre décimal (représenté par la variable 'octet') égal\n",
    "# à 210 pour une entrée en pas à pas de chacun des bits : 1 1 0 1 0 0 1 0 \n",
    "# - ne pas oublier les commentaires...\n",
    "# - valider votre code à chaque étape à l'aide de la combinaison de touche {Ctrl + Entrée} pour voir la construction\n",
    "# progressive de cette conversion arithmétique :\n",
    "\n",
    "octet = 0\n",
    "# le bit7 vient d'être entré avec le bouton poussoir B (= 1): l'octet a donc changé :\n",
    "octet = octet + 2**7\n",
    "# le bit6 vient d'être entré avec le bouton poussoir ... .... .... \n",
    "???\n",
    "...\n",
    "???\n",
    "# ... et à la fin on affiche la valeur de l'octet :\n",
    "print(octet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le programme précédent nous donne l'algorithme à suivre : \n",
    "  \n",
    "  - on définit une variable *octet* et on lui affecte la valeur 0. A la fin du programme elle contient la valeur de l'octet.\n",
    "  - si on entre un bit à 0, on ne change pas la valeur de la variable *octet*, \n",
    "  - si on entre un bit à 1, on augmente *octet* de la valeur 2 à la puissance n, où  n est le rang du bit (n compris entre 0 et 7)\n",
    "\n",
    "Commençons par simuler l'entrée d'un seul bit (le bit'n') mis à 0 ou à 1 avec les touches A ou B du clavier du PC (attention : à taper en **majuscules**). Pour cela on va utiliser dans ce notebook la fonction **input( )** déjà rencontrée dans le notebook **\"0_1_Interaction_Utilisateur.ipynb\"**\n",
    "\n",
    "*Remarque : * On ne cherchera pas à gérer le cas où un utilisateur se trompe de touche. En effet, sur la carte Micro:Bit, il n'y a que deux boutons poussoirs...le A et le B !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "octet = 0\n",
    "# choisir ci-dessous une valeur de n entre 0 et 7 pour définir le bit sur lequel on veut travailler:\n",
    "n = ???\n",
    "bt = input('?')\n",
    "\n",
    "if bt =='A':    # en cas d'appui sur la touche A du clavier\n",
    "    pass        # pour l'instant on ne fait rien\n",
    "elif bt =='B':  # sinon, si la touche B a été appuyée alors :\n",
    "    octet = ???\n",
    "\n",
    "\n",
    "print(octet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si cette portion de programme fonctionne sur un bit quelconque, il reste à finaliser l'algorithme qui permettra de **répéter huit fois** cette portion de code. On démarera avec le bit 7 pour finir avec le bit 0 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "octet = 0\n",
    "n = 7\n",
    "\n",
    "while n >= ???:\n",
    "    bt = input('?')\n",
    "\n",
    "    if bt =='A':    # en cas d'appui sur la touche A du clavier\n",
    "        n = ???\n",
    "    elif bt =='B':  # sinon, si la touche B a été appuyée alors :\n",
    "        octet = octet + ???\n",
    "        n = ???\n",
    "\n",
    "print(octet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2- Mise en application\n",
    "\n",
    "Lorsque ce code fonctionne :\n",
    "\n",
    "  - en classe : ouvrir le logiciel mu-editor,\n",
    "\n",
    "  ou\n",
    "  \n",
    "  - à la maison : aller sur le site https://create.withcode.uk/ \n",
    "  \n",
    "  et en **faire une adaptation** pour qu'il tourne sur la carte BBC Micro:Bit comme énoncé dans le cahier des charges (il faudra prendre en charge l'appui sur le bouton A ou sur le bouton B)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}