STIC:STIC IV (2021)/Grand projet: Boite Binaire

De EduTech Wiki
Aller à la navigation Aller à la recherche
La version imprimable n’est plus prise en charge et peut comporter des erreurs de génération. Veuillez mettre à jour les signets de votre navigateur et utiliser à la place la fonction d’impression par défaut de celui-ci.
Projet réalisé par Jerome Humbert

1 Introduction

La problématique est l'apprentissage de la numération en base 2 (binaire). Souvent lorsque celle-ci est expliquée on voit apparaître les calculs représentant les puissances de deux et une brève explication de la manière de calcul. Mais c'est rare de tomber sur une représentation visuelle. Étant informaticien, c'est un domaine qui m'est familier et qui m'a été inspiré par mes étudiants qui ont un cours sur les numérotations en différentes bases.

2 Problème

Actuellement, l'apprentissage est réalisé de manière très classique au moyen d'une présentation et d'un cours ex cathedra. Dans le cadre de ce cours, aucunes tentatives n'ont été relevées pour changer le medium d'apprentissage utilisé.

3 Cahier des charges

3.1 Contexte et public

Lors d'un cours dispensé en HES, les étudiants de première année sont amenés à apprendre les différentes bases (2,8,10,16) de numération. L'idée ici est d'apporter un aspect tactile et visuel de représenter ces notions. Le public cible est donc des étudiants généralement entre 18 et 30 ans qui débutent des études d'informaticiens.

3.2 Objectifs

L'objectif principal est l'apprentissage de la base binaire (voir d'autres bases) aux étudiants. Des objectifs secondaires peuvent être liés à l'apprentissage des bases de l'électronique et faire comprendre aux étudiants que derrière chaque outil technologique il y a de l'électronique derrière et de la programmation. Le projet vise donc à apporter une représentation visuelle et concrète de cette base de numération, introduire la base de l'électronique et inciter une vision globale d'un produit électronique.

3.3 Besoins

Pyramide de la rétention d'information selon la méthode d'apprentissage choisie. Image issue de : https://www.mobiliwork.com/learning-by-doing-definition-avantages-et-fonctionnement/

Le projet nécessite la création d'une boîte où sera contenu l'électronique et qui servira de support pour les interrupteurs et l'écran affichant le résultat final. Cette boîte peut-être en bois ou en plexiglass/plastique. Ici nous utiliserons du plexiglass/plastique pour que les étudiants puissent voir l'intérieur ainsi qu'une découpeuse laser afin de simplifier la découpe. Les interrupteurs sont au nombre de dix afin de pouvoir faire des calculs jusqu'à la dixième puissance de deux. Finalement, un petit écran affichera le résultat en base 10 selon les interrupteurs enclenchés.

3.4 Apports théoriques

Ici la méthode d'apprentissage est clairement axée sur le learning by doing car les étudiants vont devoir créer et monter eux-mêmes leurs boîte. Cela implique donc quelques notions théoriques de prime abord telles que des notions de bases en électronique, en programmation et en base de numération mais sans aller trop en profondeur afin de leur laisser une certaine autonomie. Comme présenté dans la pyramide ci-jointe, l'apprentissage par la pratique est une des meilleures méthodes pour l'apprentissage et la rétention d'information.

3.5 Présentation du projet

J'ai en tête une sorte de boîte avec des indicateurs (des leviers, des leds, ...) au dessous de chaque puissance de 2 (allant jusqu'à 2^10) et changeant d'état selon l'entrée effectuée par l'utilisateur (entrer un nombre en base 10) ou alors afficher le nombre en base 10 selon l'état des indicateurs. Je dois connaître mieux leur niveau en électronique de base afin d'opter pour la solution la plus simple dans ce domaine.

4 Solution

4.1 Premier prototype

En m'appuyant sur la description réalisée ci-dessus, mon premier schéma de prototype ressemble à ceci :

Premier prototype boite binaire.jpg

Ce prototype représente bien les différents besoins matériels requis (les interrupteurs, l'écran, la boîte) mais n'est pas très ergonomique d'usage. En effet, il n'est pas forcément aisé de savoir dans quel sens lire le nombre entré en binaire (haut -> bas ou gauche -> droite). De plus, sans ouvrir la boîte, il n'est pas possible d'éteindre/allumer le circuit. De plus, j'avais imaginé des interrupteurs placé de manière horizontale pour ne pas avoir un problème avec la gravité (mettant les interrupteurs en bas) et devoir mettre des moteurs pour ceux-ci. Ici les étudiants devraient activer ou non les interrupteurs pour ensuite avoir le nombre affiché à l'écran.

4.2 Second prototype

Mon second prototype est en majeur partie identique au premier mais change l'interaction des étudiants avec l'outil.

Second prototype boite binaire.jpg

Ici les étudiants entreraient un nombre grâce à un petit clavier sur la boite et les interrupteurs, actionnés par des moteurs, bougeraient pour refléter la réponse en base binaire. Je n'ai au final pas gardé cette approche car je la trouve moins pédagogique. En effet cela se rapproche plus de l'usage d'une calculette qui a que pour effet de donner la réponse sans devoir réfléchir.

4.3 Troisième prototype

Mon troisième prototype part donc sur la base du premier et tente de régler les problèmes d'ergonomie.

Troisième prototype boite binaire.jpg

Ici la lecture du binaire est simplifiée et la possibilité d'allumer et éteindre le projet est prévu. C'est sur cette base que je vais démarrer la conception.

Taille de la face : L 26,7cm H 10.2cm

Taille du coté : L 10cm H 10.02

Taille du dessus/dessous : L 26.7cm H 10cm

Rayon trou interrupteur : 11cm

Taille du 7digit : L 3cm H 1,4cm

4.4 Présentation de la solution finale

  • Décrire le dispositif et son fonctionnement. Une petite documentation peut être réalisée à destination des utilisateurs-trices.

Le dispositif se présente sous la forme d'une boîte ayant 11 interrupteurs. Chaque interrupteur va représenter un 1 ou un 0 dans le chiffre binaire composé à l'exception de l'interrupteur On/Off qui va allumer ou éteindre le circuit. Selon l'état des interrupteurs, le chiffre binaire composé sera transformer en un nombre en base 10 et affiché sur le petit écran en haut à droite.

BoiteBinaireFace.jpg

Dans cet exemple nous pouvons voir qu'avec les interrupteurs disposés ainsi le chiffre binaire affiché est 000011010 ce qui correspond à 16 + 8 + 2 ce qui équivaut à 26.

  • Réaliser et documenter le schéma final de votre circuit

Grâce à l'ouverture prévue derrière la boîte, il est possible de voir et modifier le circuit depuis la boîte directement.

BoiteBinaireDos.jpg

Pour des questions de simplicité, je vais détailler le circuit par rapport aux trois fonctionnalités principales : un interrupteur binaire, la connexion du display et l'interrupteur on/off.

Pour les interrupteurs binaires, le (+) est la fiche extérieure et va être connectée sur la colonne (+) de la platine d'essai. La deuxième fiche de chaque interrupteur va être connectée sur des pin de l'arduino Digital ou Analog (mais configuré comme Digital). Le même principe sera appliqué pour l'interrupteur On/Off, seul son traitement diffèrera dans le code de l'Arduino.

Le négatif de la platine d'essai est connecté sur le Ground de l'Arduino. Une diode fait le lien dans le circuit et permet de voir si celui-ci fonctionne. Il est également possible de remarquer une différente intensité dans celle-ci selon les interrupteurs enclenchés.

Finalement, il ne reste que le display à connecter. Malheureusement, l'Arduino Uno n'a pas assez de pins disponibles pour réaliser le tout. C'est pourquoi j'ai utilisé un EzExtender qui permet d'ajouter quelques pins supplémentaires. Comment fonctionne le display ? Chaque nombre est représenté ainsi :

   
    A
   ---
F |   | B
  | G |
   ---
E |   | C
  |   |
   ---
    D

Il y a donc 7 pins qui sont utilisés sur le composant (un pour chaque lettre). il y a 4 pins pour déterminer quel digit doit être allumé. Le dernier pour arriver à 12 pins est le point pour les nombres à virgules. Ainsi le display va afficher un digit, puis l'autre puis l'autre puis le dernier pour revenir ensuite au premier. Dit comme ça, on pourrait penser qu'il y aura un chiffre affiché après l'autre. Mais à partir d'une certaine vitesse, cela devient invisible à l'œil nu et les 4 chiffres sont visibles simultanément.

Sur le composant, la numérotation part d'en bas à gauche et fini en haut à droite.

Les 7 pins (lettres) sont les suivants : A 11, B 7, C 4, D 2, E 1, F 10, G 5.

Les 4 pins pour les digits : 1er 12, 2ème 9, 3ème 8, 4ème 6

Le pin 3 permet l'usage des points pour des nombres à virgules. Dans le cadre de mon projet, cela n'est pas nécessaire.

Chacun de ces pins sont connectés à des pins sur l'Arduino et seront géré par le code dans celui-ci.

Le détail du circuit peut être trouvé ici : https://www.tinkercad.com/things/1BHEEybHKTK-fantabulous-borwo-stantia/editel?sharecode=9h2eXMnEba37hp7vVWmLQ5iDKp7SUcg4WMDVjHnsDJk

4.5 Traces

Gardez un journal de bord dans lequel vous notez chaque fois que le matériel (ses propriétés ou affordances) vous a mené à changer votre design. Faites un schéma pour chaque étape, et les décisions revues dans chaque étape.

Problèmes de multi interrupteurs avec différentes LED : https://www.tinkercad.com/things/1BHEEybHKTK-fantabulous-borwo-stantia/editel?sharecode=9h2eXMnEba37hp7vVWmLQ5iDKp7SUcg4WMDVjHnsDJk -> Voir si https://create.arduino.cc/projecthub/ronbentley1/toggle-switches-reliable-reading-da30a1 fonctionne

Pas assez de Pins pour tout faire sur un seul Arduino : Achat de EzExpander

L'affichage "coulait" sur le chiffre suivant. La solution a été de mettre les 4 digits à LOW puis afficher le chiffre. Ainsi rien ne découle sur l'autre chiffre.

4.6 Code

  1 #include <EZExpander.h>
  2 
  3 /*
  4   Showing number 0-9 on a Common Anode 7-segment LED display
  5   Displays the numbers 0-9 on the display, with one second inbetween.
  6     A
  7    ---
  8 F |   | B
  9   | G |
 10    ---
 11 E |   | C
 12   |   |
 13    ---
 14     D
 15   This example code is in the public domain.
 16  */
 17  
 18 // Pin 2-8 is connected to the 7 segments of the display.
 19 
 20 
 21 // Create an EZExpander object
 22 EZExpander expander = EZExpander();
 23 
 24 //Switchs
 25 int switch1 = 2;
 26 int switch2 = 3;
 27 int switch3 = 4;
 28 int switch4 = 5;
 29 int switch5 = 6;
 30 int switch6 = 7;
 31 int switch7 = A0;
 32 int switch8 = A1;
 33 int switch9 = A2;
 34 int switch10 = A3;
 35 int switchOnOff = A4;
 36 
 37 // Digital pins
 38 int pinA = 28;
 39 int pinB = 29;
 40 int pinC = 30;
 41 int pinD = 31;
 42 int pinE = 32;
 43 int pinF = 33;
 44 int pinG = 34;
 45 int D1 = 21;
 46 int D2 = 20;
 47 int D3 = 23;
 48 int D4 = 22;
 49 int valeur = 0;
 50 int valpos1 = 0;
 51 int valpos2 = 0;
 52 int valpos3 = 0;
 53 int valpos4 = 0;
 54 int matrice[10][7] = {{0,0,0,0,0,0,1},{1,0,0,1,1,1,1},{0,0,1,0,0,1,0},{0,0,0,0,1,1,0},{1,0,0,1,1,0,0},{0,1,0,0,1,0,0},{0,1,0,0,0,0,0},{0,0,0,1,1,1,1},{0,0,0,0,0,0,0},{0,0,0,1,1,0,0}};
 55 // the setup routine runs once when you press reset:
 56 void setup() {                
 57   pinMode(switch1, INPUT_PULLUP);
 58   pinMode(switch2, INPUT_PULLUP);
 59   pinMode(switch3, INPUT_PULLUP);
 60   pinMode(switch4, INPUT_PULLUP);
 61   pinMode(switch5, INPUT_PULLUP);
 62   pinMode(switch6, INPUT_PULLUP);
 63   pinMode(switch7, INPUT_PULLUP);
 64   pinMode(switch8, INPUT_PULLUP);
 65   pinMode(switch9, INPUT_PULLUP);
 66   pinMode(switch10, INPUT_PULLUP);
 67   pinMode(switchOnOff, INPUT_PULLUP);
 68   Serial.begin(9600);
 69 }
 70 
 71 // the loop routine runs over and over again forever:
 72 void loop() {
 73   if(digitalRead(switchOnOff) == HIGH){
 74     int cpt = 0;
 75     for (int i = 0; i < 4; i++){
 76       int val = int(int(valeur)/pow(10,i)) % 10;
 77       if(i == 0){
 78         valpos4 = val;
 79       }else if(i == 1){
 80         valpos3 = val;
 81       }else if(i == 2){
 82         valpos2 = val;
 83       }else if(i == 3){
 84         valpos1 = val;
 85       }
 86     }
 87     int delai = 1;
 88     // Le chiffre des unités
 89     expander.digitalWrite(D1, LOW);
 90     expander.digitalWrite(D2, LOW);
 91     expander.digitalWrite(D3, LOW);
 92     expander.digitalWrite(D4, LOW); 
 93     setDigit(valpos4);
 94     expander.digitalWrite(D1, LOW);
 95     expander.digitalWrite(D2, LOW);
 96     expander.digitalWrite(D3, LOW);
 97     expander.digitalWrite(D4, HIGH); 
 98     
 99     delay(delai);
100     // Le chiffre des dizaines
101     expander.digitalWrite(D1, LOW);
102     expander.digitalWrite(D2, LOW);
103     expander.digitalWrite(D3, LOW);
104     expander.digitalWrite(D4, LOW); 
105     setDigit(valpos3);
106     expander.digitalWrite(D1, LOW);
107     expander.digitalWrite(D2, LOW);
108     expander.digitalWrite(D3, HIGH);
109     expander.digitalWrite(D4, LOW); 
110     
111     delay(delai);
112     // Le chiffre des centaines
113     expander.digitalWrite(D1, LOW);
114     expander.digitalWrite(D2, LOW);
115     expander.digitalWrite(D3, LOW);
116     expander.digitalWrite(D4, LOW); 
117     setDigit(valpos2);
118     expander.digitalWrite(D1, LOW);
119     expander.digitalWrite(D2, HIGH);
120     expander.digitalWrite(D3, LOW);
121     expander.digitalWrite(D4, LOW); 
122     
123     delay(delai);
124     // Le chiffre des milliers
125     expander.digitalWrite(D1, LOW);
126     expander.digitalWrite(D2, LOW);
127     expander.digitalWrite(D3, LOW);
128     expander.digitalWrite(D4, LOW); 
129     setDigit(valpos1);
130     expander.digitalWrite(D1, HIGH);
131     expander.digitalWrite(D2, LOW);
132     expander.digitalWrite(D3, LOW);
133     expander.digitalWrite(D4, LOW); 
134     valeur = 0;
135     delay(delai);
136 
137     //Composition du chiffre décimal selon l'état des interrupteurs
138     if(digitalRead(switch10) == HIGH){
139       valeur += 1;
140     }else{
141       valeur += 0;
142     }
143     if(digitalRead(switch9) == HIGH){
144       valeur += 2;
145     }else{
146       valeur += 0;
147     }
148     if(digitalRead(switch8) == HIGH){
149       valeur += 4;
150     }else{
151       valeur += 0;
152     }
153     if(digitalRead(switch7) == HIGH){
154       valeur += 8;
155     }else{
156       valeur += 0;
157     }
158     if(digitalRead(switch6) == HIGH){
159       valeur += 16;
160     }else{
161       valeur += 0;
162     }
163     if(digitalRead(switch5) == HIGH){
164       valeur += 32;
165     }else{
166       valeur += 0;
167     }
168     if(digitalRead(switch4) == HIGH){
169       valeur += 64;
170     }else{
171       valeur += 0;
172     }
173     if(digitalRead(switch3) == HIGH){
174       valeur += 128;
175     }else{
176       valeur += 0;
177     }
178     if(digitalRead(switch2) == HIGH){
179       valeur += 256;
180     }else{
181       valeur += 0;
182     }
183     if(digitalRead(switch1) == HIGH){
184       valeur += 512;
185     }else{
186       valeur += 0;
187     }
188   }else{
189     expander.digitalWrite(D1, LOW);
190     expander.digitalWrite(D2, LOW);
191     expander.digitalWrite(D3, LOW);
192     expander.digitalWrite(D4, LOW);
193   }
194 }
195 
196 
197 
198 // Pour chacun des pin A-G, selon la valeur dans la matrice, on l'allume ou l'éteint pour afficher les chiffres.
199 void setDigit(int valpos){
200 
201   for(int i = 0; i < sizeof(matrice[valpos]); i++){
202     if(i == 0){
203       setValeur(i,pinA,valpos);
204     }else if(i == 1){
205       setValeur(i,pinB,valpos);
206     }else if(i == 2){
207       setValeur(i,pinC,valpos);
208     }else if(i == 3){
209       setValeur(i,pinD,valpos);
210     }else if(i == 4){
211       setValeur(i,pinE,valpos);
212     }else if(i == 5){
213       setValeur(i,pinF,valpos);
214     }else if(i == 6){
215       setValeur(i,pinG,valpos);
216     }
217   }
218 }
219 
220 
221 void setValeur(int i, int pin ,int valpos) {
222     if(matrice[valpos][i] == 0){
223         expander.digitalWrite(pin, LOW);
224       }else{
225         expander.digitalWrite(pin, HIGH);
226       }
227 }

5 Test(s) de la solution

Afin de pouvoir tester mon dispositif, j'ai décidé d'utiliser une procédure Fluid project overview afin d'avoir une vue d'ensemble des tous les potentiels utilisateurs de mon projet.

5.1 Définitions des utilisateurs

Cela me permet de détailler les usagers en rapport à deux types d'utilisateurs :

  • L'apprenant
  • L'enseignant

5.2 Objectifs utilisateurs

L'objectif de l'apprenant est de comprendre et assimiler la notion de la numération en base 2 ainsi que la transformation d'une base à l'autre.

L'objectif de l'enseignant est de transmettre cette même notion de manière visuelle et ludique au moyen de la boîte binaire.

5.3 Étapes de réalisation de l'objectif

5.3.1 Enseignant
  1. L'enseignant va premièrement devoir expliquer plusieurs notions d'électronique notamment le (+)/(-) et l'utilisation d'une platine d'essai.
  2. L'enseignant devra également expliquer pourquoi cela nous intéresse de changer de base de numération.
  3. L'enseignant montrera un exemple de changement de numération et demandera aux étudiants d'essayer de déchiffrer le fonctionnement. Il pourra laisser en place la boîte pour que les étudiants essaient de l'utiliser.
  4. L'enseignant une fois l'exercice terminé complètera avec la théorie afin de consolider le savoir acquis.
5.3.2 Etudiant
  1. L'étudiant va d'abord écouter et assimiler les notions nécessaires à priori.
  2. L'étudiant va essayer de comprendre le mécanisme de transformation de numération.
  3. L'étudiant va présenter sa version de compréhension du mécanisme.

5.4 Réalisation des tests

Pour chaque étape décrite ci-dessus, 4 questions doivent être posées :

  • Est-ce que l'utilisateur sait ce qu'il doit faire ?
  • Est-ce que c'est difficile de comprendre ce qu'il doit faire ?
  • Est-ce que l'utilisateur sait s'il a bien réalisé ce qu'il devait réaliser ?
  • Est-ce que le feedback est difficile à analyser ?

6 Discussion

6.1 Discussion du design

Je suis globalement satisfait du Design de ma boîte binaire. Peut-être que les gravures auraient mérité d'être un peu plus profondes pour les rendre plus visibles.

7 Licence, fichiers et documentation

By-nc.png Cette œuvre est mise à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale 4.0 International.

  • Fichiers :

L'ensemble des fichiers utilisé sont disponible ici : http://tecfaetu.unige.ch/etu-maltt/zelda/humbeja9/stic-4/BoiteBinaire/

Afin de comprendre l'usage du 4 digit display, je suis parti de ce code et de cette vidéo : https://www.youtube.com/watch?v=iZI1GjCvIiw