CI : Traitement de l’information

Nom : Prénom : Date :

Introduction à la Numération : TP
1STI2D
Compteur hexadécimal

Pour la réalisation des maquettes, nous utiliserons TinkerCad outil de simulation de la plateforme Arduino.

Etape 1 : Découverte de l’afficheur

- Connectez-vous sur :(www.tinkercad.com),

- Créez un nouveau circuit
- Liste des composants nécessaires :
o Une carte Arduino UNO
o 4 résistances d’1kW
o 1 Afficheur 7 segments
o 1 platine d’essai
- Réaliser le montage suivant :

Comme pour des LED standards, il faut une résistance de limitation du courant sur chaque anode des 8
LEDs composant cet afficheur.

- Paramétrez l’afficheur en mode Cathode Communes :

- Uploadez le programme suivant vers la carte Arduino :

1
/** Fonction setup() */
void setup()
{
/* toutes les broches utilisées en sortie */
for (int i=2; i<10; i++)
{
pinMode(i, OUTPUT);
}
}
/** Fonctionloop() */
Void loop()
{
digitalWrite (2, HIGH);
delay (1000);
digitalWrite (2, LOW);
delay (1000);
}

Décrivez le comportement observé.

Modifier le programme pour identifier quelle broche allume quel segment, compléter le schéma
suivant :

Modifiez le code afin que chaque segment s’allume à tour de rôle pendant 200 ms ( pensez à
utiliser une boucle for … )

APPELLEZ LE PROFESSEUR pour montrer votre résultat

2
Etape 2 : comptage en hexadécimal

Notre objectif est à présent de compter en hexadécimal de 0 à F.

Nous disposons pour l’instant du code suivant (le fichier est disponible sur le cahier de texte):

const byte PIN_SEGMENT_A =2;

const byte PIN_SEGMENT_B =3;
const byte PIN_SEGMENT_C =4;
const byte PIN_SEGMENT_D =5;
const byte PIN_SEGMENT_E =6;
const byte PIN_SEGMENT_F =7;
const byte PIN_SEGMENT_G =8;
const byte PIN_SEGMENT_DP =9;

const byte LUT_ETATS_SEGMENTS[] = {

0b00111111, // afficher le 0
0b00000110,
0b01011011,
0b01001111,
0b01100110,
0b01101101,
0b01111101,
0b00000111,
0b01111111,
0b01101111};

/** Fonction setup() */

void setup()
{
/* toutes les broches utilisées en sortie */
for (int i=2; i<10; i++)
{
pinMode(i, OUTPUT);
}
Serial.begin(9600);
}

/** Fonctionloop() */
void loop() {
static byte chiffre = 0;
static byte etat_dp = 0;

/* Affiche le chiffre */
affiche_chiffre_7seg(chiffre, etat_dp);

/* Incrémente le chiffre de 0 à 9 */
if (++chiffre == 10) {
chiffre = 0;
}

/* Fait clignoter le point décimal (inverse l'état à chaque fois) */

etat_dp = !etat_dp;

/* Délai pour la démo */

delay(1000);
}
/** Fonction permettant d'afficher un chiffre sur un afficheur 7 segments */
void affiche_chiffre_7seg(byte chiffre, byte dp) {

/* Simple sécurité */
if (chiffre > 10)
return; // Accepte uniquement des valeurs de 0 à 10.

/* Conversion chiffre -> états des segments */

byte segments = LUT_ETATS_SEGMENTS[chiffre];

/* Affichage */
digitalWrite(PIN_SEGMENT_A, bitRead(segments, 0));
digitalWrite(PIN_SEGMENT_B, bitRead(segments, 1));
digitalWrite(PIN_SEGMENT_C, bitRead(segments, 2));
digitalWrite(PIN_SEGMENT_D, bitRead(segments, 3));
digitalWrite(PIN_SEGMENT_E, bitRead(segments, 4));
digitalWrite(PIN_SEGMENT_F, bitRead(segments, 5));
digitalWrite(PIN_SEGMENT_G, bitRead(segments, 6));
digitalWrite(PIN_SEGMENT_DP, dp);
}

Testez le code et décrivez le résultat :

3
- En cherchant sur le site de « Arduino », quel avantage à déclarer chaque PIN en type byte et non
int ?
-

Complétez EN VERT la lettre associée à chaque segment sur le schéma de la page 2.

Pour l’instant combien d’éléments contient LUT_ETATS_SEGMENTS ? …………..

Pour compter en hexadécimal combien d’éléments devra contenir LUT_ETATS_SEGMENTS ?

…………..

Modifiez le code afin de transformer notre compteur décimal en compteur hexadécimal.

APPELLEZ LE PROFESSEUR pour montrer votre résultat.

Question bonus : modifiez le code pour afficher un mot.