Cryptage image – Bac pratique – Section informatique – 2021

Bac Info 15-01-26

145 0

Sujet (Algo et programmation - Bac 2021)

Soit une image numérique dont les valeurs des pixels sont représentées par des nombres hexadécimaux enregistres dans un fichier texte nomme "ImgHexa.txt" à raison d'un nombre par ligne.

Aim de crypter le contenu du fichier "Inigllexa.txt", on utilise le Principe suivant :

1- Transférer le contenu du fichier "Ilmgileln.txt" vers un tableau d'enregistrements T. Chaque enregistrement est forme de trois champs commi suit :

- He : contient le nombre hexadécimal.

- Num : contient le numéro de la ligne du nombre hexadécimal dans le fichier.

- Dec contient l'équivalent décimal du nombre hexadécimal.

2- Trier le tableau T dans l'ordre croissant des valeurs du champ Dee.

3- Générer un code. sous forme (rune chaines de caractères. pour chaque nombre décimal du tableau T et l'enregistrer ainsi que son numéro de ligne Num dans Lin fichier texte nomme "Resultat.txt". Chaque ligne du fichier contiendra le code généré suivi par son numéro de ligne séparés par un espace.

NB : Utiliser la fonction Genere ci-dessous qui permet de générer un code a partir d'un nombre décimal Nb.

Fonction generer(nb):mot
Début
     mot<-''
     r <- nb mod 3
     Selon r faire
       0 : y <- "Ma"
       1 : y <- "Des"
       2 : y <- "Son"
     Fin selon
     mot <- y+mot
     nb <- nb div 3 
     Tant que (nb!=0) faire
       r <- nb mod 3
       Selon r faire
         0 : y  <- "Ma"
         1 : y <- "Des"
         2 : y <- "Son"
       Fin selon
       mot <- y+mot
       nb <- nb div 3
     Fin selon
     retourner mot
Fin

Fonction generer(nb):mot

Début

mot<-''

r <- nb mod 3

Selon r faire

0 : y <- "Ma"

1 : y <- "Des"

2 : y <- "Son"

Fin selon

mot <- y+mot

nb <- nb div 3

Tant que (nb!=0) faire

r <- nb mod 3

Selon r faire

0 : y <- "Ma"

1 : y <- "Des"

2 : y <- "Son"

Fin selon

mot <- y+mot

nb <- nb div 3

Fin selon

retourner mot

Fin

Travail demandé :

En utilisant un éditeur de texte disponible (Bloc-notes. Notepad, Notepad++, ...), créer un fichier texte nommé "ImgHexa.txt" et y saisir les nombres hexadécimaux ci-dessous, représentant les valeurs des pixels d'une image. a raison d'un nombre par ligne.

41, 26. 4D. 2D, 37. 74, AB, 26, 85, 68, 37, 82, AE, 94, 80, 35, 44, BO, 87, 56, 8C. 8E, SD, 8B, 38, 48

Ecrire un programme en Python intitule Cryptage qui permet de crier et de remplir un fichier texte "Resultat.1x1" par le résultat de cryptage du contenu du fichier texte "ImgHexa.txt" en utilisant le principe décrit précédemment.

Solution Algorithmique

Dans cet algorithme, On va utiliser trois fonctions et cinq procédures:

- la fonction exposant()

- la fonction conversion_decimale()

- la procédure remplir_tableau()

- la procédure afficher_tableau()

- la procédure trier_tableau()

- la fonction generer()

- la procédure remplir_fichier_resultat()

- la procédure afficher_fichier_resultat()

Algorithme du programme Principal

Algorithme cryptage
Debut 
      index <- 0
      # Remplissage du tableau à partir du fichier
      remplir_tableau(t)
      # Tri du tableau selon la valeur décimale
      trier_tableau(t, index)
      Ecrire('*** Tableau T trie ***')
      afficher_tableau(t, index)
      # Génération du fichier résultat
      remplir_fichier_resultat(t, index)
      Ecrire('*** Contenu du fichier Resultat ***')
      afficher_fichier_resultat()
Fin

Algorithme cryptage

Debut

index <- 0

# Remplissage du tableau à partir du fichier

remplir_tableau(t)

# Tri du tableau selon la valeur décimale

trier_tableau(t, index)

Ecrire('*** Tableau T trie ***')

afficher_tableau(t, index)

# Génération du fichier résultat

remplir_fichier_resultat(t, index)

Ecrire('*** Contenu du fichier Resultat ***')

afficher_fichier_resultat()

Fin

Déclaration des objets

Objet	Type / Nature
index	entier
t	tableau

La fonction exposant

Cette fonction permet de calculer la puissance d’un nombre entier

Fonction exposant(n:entier;e:entier):entier
    p <- 1
    Pour i de 0 à e-1 faire
        p <- p * n
    Fin pour
    retourner p 
Fin

Fonction exposant(n:entier;e:entier):entier

p <- 1

Pour i de 0 à e-1 faire

p <- p * n

Fin pour

retourner p

Fin

Déclaration des objets

Objet	Type / Nature
p	entier

La fonction conversion_decimale

Le rôle de cette fonction est de convertir un nombre écrit en base 16 (hexadécimal) sous forme de chaîne de caractères en un nombre entier en base 10 (décimal).

Fonction conversion_decimale(nombre_hexa:chaîne):entier
    decimal <- 0      # Résultat en base 10
    puissance <- 1    # Représente 16^0 au départ
    
    # Parcours de la chaîne de droite à gauche
    Pour i de long(nombre_hexa)-1 à 0 (pas=-1) faire
        chiffre <- nombre_hexa[i]
        
        # Conversion du caractère en valeur numérique
        Si '0' <= chiffre <= '9' alors
            valeur <- ord(chiffre) - ord('0')
        Sinon
            valeur <- ord(chiffre) - ord('A') + 10
        Fin si
        # Ajout de la contribution du chiffre
        decimal = decimal + valeur * puissance
        
        # Passage à la puissance suivante de 16
        puissance <- puissance * 16
    Fin pour
    retourner decimal  
 Fin

Fonction conversion_decimale(nombre_hexa:chaîne):entier

decimal <- 0 # Résultat en base 10

puissance <- 1 # Représente 16^0 au départ

# Parcours de la chaîne de droite à gauche

Pour i de long(nombre_hexa)-1 à 0 (pas=-1) faire

chiffre <- nombre_hexa[i]

# Conversion du caractère en valeur numérique

Si '0' <= chiffre <= '9' alors

valeur <- ord(chiffre) - ord('0')

Sinon

valeur <- ord(chiffre) - ord('A') + 10

Fin si

# Ajout de la contribution du chiffre

decimal = decimal + valeur * puissance

# Passage à la puissance suivante de 16

puissance <- puissance * 16

Fin pour

retourner decimal

Fin

Déclaration des objets

Objet	Type / Nature
decimal	entier
puissance	entier
chiffre	chaîne
valeur	valeur

La procédure remplir_tableau

Le rôle de cette procédure est de lire les nombres hexadécimaux contenus dans le fichier ImgHexa.txt et de remplir le tableau t avec des enregistrements contenant leurs informations.

Procédure remplir_tableau(t:tableau)
    # Ouverture du fichier en lecture
    Ouvrir (f , "ImgHexa.txt", "r")
    
    # Lecture de toutes les lignes du fichier
    nombres_hexa <- Lire_lignes(f)
    
    Pour nombre_hexa dans nombres_hexa faire
        nombre_hexa <- nombre_hexa.strip('\n')  # Suppression du retour à la ligne
        
        # Création d'un enregistrement sous forme de dictionnaire
        enregistrement = Enregistrement(
            Hex=str(),   # Valeur hexadécimale
            Num=int(),   # Numéro d'ordre
            Dec=int()    # Valeur décimale
        )
        
        # Remplissage du dictionnaire
        enregistrement['Hex'] <- nombre_hexa
        enregistrement['Num'] <- index + 1
        enregistrement['Dec'] <- conversion_decimale(nombre_hexa)
        
        # Stockage dans le tableau
        t[index] <- enregistrement
        index <- index + 1
    Fin pour   
Fin

Procédure remplir_tableau(t:tableau)

# Ouverture du fichier en lecture

Ouvrir (f , "ImgHexa.txt", "r")

# Lecture de toutes les lignes du fichier

nombres_hexa <- Lire_lignes(f)

Pour nombre_hexa dans nombres_hexa faire

nombre_hexa <- nombre_hexa.strip('\n') # Suppression du retour à la ligne

# Création d'un enregistrement sous forme de dictionnaire

enregistrement = Enregistrement(

Hex=str(), # Valeur hexadécimale

Num=int(), # Numéro d'ordre

Dec=int() # Valeur décimale

)

# Remplissage du dictionnaire

enregistrement['Hex'] <- nombre_hexa

enregistrement['Num'] <- index + 1

enregistrement['Dec'] <- conversion_decimale(nombre_hexa)

# Stockage dans le tableau

t[index] <- enregistrement

index <- index + 1

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier
nombres_hexa	chaîne
nombre_hexa	chaîne
enregistrement	Enregistrement
index	entier (variale globale)

La procédure afficher_tableau

Cette procédure affiche à l’écran les n premiers enregistrements du tableau t.

Procédure afficher_tableau(t:tableau;n:entier):
    Pour i de 0 à n-1 faire
        Ecrire(t[i])
    Fin pour
Fin

Procédure afficher_tableau(t:tableau;n:entier):

Pour i de 0 à n-1 faire

Ecrire(t[i])

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La procédure trier_tableau

Cette procédure trie le tableau t par ordre croissant en se basant sur le champ Dec en utilisant la méthode du tri par sélection.

Procédure trier_tableau(t:tableau; n:entier)
    Pour i de 0 à n-2 faire
        min_index <- i
        
        # Recherche du plus petit élément
        Pour j de i à n-1
            Si t[min_index]['Dec'] > t[j]['Dec'] alors
                min_index <- j
            Fin si
        Fin pour
        # Échange des éléments si nécessaire
        Si min_index != i alors
            temp <- t[i]['Hex']
            t[i]['Hex'] <- t[min_index]['Hex']
            t[min_index]['Hex'] <- temp
            
            temp <- t[i]['Num']
            t[i]['Num'] <- t[min_index]['Num']
            t[min_index]['Num'] <- temp
            
            temp <- t[i]['Dec']
            t[i]['Dec'] <- t[min_index]['Dec']
            t[min_index]['Dec'] <- temp
        Fin si
    Fin pour  
Fin

Procédure trier_tableau(t:tableau; n:entier)

Pour i de 0 à n-2 faire

min_index <- i

# Recherche du plus petit élément

Pour j de i à n-1

Si t[min_index]['Dec'] > t[j]['Dec'] alors

min_index <- j

Fin si

Fin pour

# Échange des éléments si nécessaire

Si min_index != i alors

temp <- t[i]['Hex']

t[i]['Hex'] <- t[min_index]['Hex']

t[min_index]['Hex'] <- temp

temp <- t[i]['Num']

t[i]['Num'] <- t[min_index]['Num']

t[min_index]['Num'] <- temp

temp <- t[i]['Dec']

t[i]['Dec'] <- t[min_index]['Dec']

t[min_index]['Dec'] <- temp

Fin si

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
min_index	entier
j	entier
temp	entier

La procédure remplir_fichier_resultat

Le rôle de cette procédure remplir_fichier_resultat est d'écrire dans le fichier Resultat.txt les résultats calculés à partir du tableau t.

Elle génère et enregistre dans le fichier Resultat.txt les codes associés aux valeurs décimales et leurs numéros correspondants.

Procédure remplir_fichier_resultat(t:tableau; n:entier)
    # Ouverture du fichier en écriture
    Ouvrir(f , "Resultat.txt", "w")

    Pour i de 0 à n-1
       code <- generer(t[i]['Dec'])
       Ecrire(f , code + ' ' + Convch(t[i]['Num']) + '\n')
    Fin pour
    Fermer(f)
Fin

Procédure remplir_fichier_resultat(t:tableau; n:entier)

# Ouverture du fichier en écriture

Ouvrir(f , "Resultat.txt", "w")

Pour i de 0 à n-1

code <- generer(t[i]['Dec'])

Ecrire(f , code + ' ' + Convch(t[i]['Num']) + '\n')

Fin pour

Fermer(f)

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier
i	entier
code	chaîne

La procédure remplir_fichier_resultat

Cette procédure lit le fichier Resultat.txt et affiche son contenu ligne par ligne à l’écran.

Procédure remplir_fichier_resultat()
    # Ouverture du fichier en écriture
    Ouvrir(f , "Resultat.txt", "r")
    codes <- Ecrire_lignes(f)
    Pour code dans codes faire
       Ecrire(code.strip('\n'))
    Fin pour
    Fermer(f)
Fin

Procédure remplir_fichier_resultat()

# Ouverture du fichier en écriture

Ouvrir(f , "Resultat.txt", "r")

codes <- Ecrire_lignes(f)

Pour code dans codes faire

Ecrire(code.strip('\n'))

Fin pour

Fermer(f)

Fin

Déclaration des objets

Objet	Type / Nature
f	fichier
codes	chaîne
code	chaîne

Solution en Python

from numpy import *

# --------------------------------------------------
# Création d'un tableau de 50 dictionnaires
# Chaque élément contiendra :
#  - Hex : nombre en hexadécimal (chaîne)
#  - Num : numéro d'ordre
#  - Dec : valeur décimale correspondante
# --------------------------------------------------
t = array([{}] * 50)

# --------------------------------------------------
# Fonction qui calcule n à la puissance e (n^e)
# --------------------------------------------------
def exposant(n, e):
    p = 1
    for i in range(e):
        p = p * n
    return p   

# --------------------------------------------------
# Fonction qui convertit un nombre hexadécimal
# (sous forme de chaîne) en nombre décimal
# --------------------------------------------------

def conversion_decimale(nombre_hexa):
    decimal = 0      # Résultat en base 10
    puissance = 1    # Représente 16^0 au départ
    
    # Parcours de la chaîne de droite à gauche
    for i in range(len(nombre_hexa) - 1, -1, -1):
        chiffre = nombre_hexa[i]
        
        # Conversion du caractère en valeur numérique
        if '0' <= chiffre <= '9':
            valeur = ord(chiffre) - ord('0')
        else:
            valeur = ord(chiffre) - ord('A') + 10
        
        # Ajout de la contribution du chiffre
        decimal += valeur * puissance
        
        # Passage à la puissance suivante de 16
        puissance = puissance * 16
    
    return decimal


# --------------------------------------------------
# Procédure qui lit le fichier ImgHexa.txt
# et remplit le tableau t avec des dictionnaires
# --------------------------------------------------
def remplir_tableau(t):
    global index
    
    # Ouverture du fichier en lecture
    f = open("ImgHexa.txt", "r")
    
    # Lecture de toutes les lignes du fichier
    nombres_hexa = f.readlines()
    
    for nombre_hexa in nombres_hexa:
        nombre_hexa = nombre_hexa.strip('\n')  # Suppression du retour à la ligne
        
        # Création d'un enregistrement sous forme de dictionnaire
        enregistrement = dict(
            Hex=str(),   # Valeur hexadécimale
            Num=int(),   # Numéro d'ordre
            Dec=int()    # Valeur décimale
        )
        
        # Remplissage du dictionnaire
        enregistrement['Hex'] = nombre_hexa
        enregistrement['Num'] = index + 1
        enregistrement['Dec'] = conversion_decimale(nombre_hexa)
        
        # Stockage dans le tableau
        t[index] = enregistrement
        index = index + 1 

# --------------------------------------------------
# Procédure qui affiche les n premiers éléments du tableau t
# --------------------------------------------------
def afficher_tableau(t, n):
    for i in range(n):
        print(t[i])

# --------------------------------------------------
# Procédure de tri du tableau selon la valeur décimale
# (tri par sélection croissant)
# --------------------------------------------------
def trier_tableau(t, n):
    for i in range(n - 1):
        min_index = i
        
        # Recherche du plus petit élément
        for j in range(i, n):
            if t[min_index]['Dec'] > t[j]['Dec']:
                min_index = j
        
        # Échange des éléments si nécessaire
        if min_index != i:
            temp = t[i]['Hex']
            t[i]['Hex'] = t[min_index]['Hex']
            t[min_index]['Hex'] = temp
            
            temp = t[i]['Num']
            t[i]['Num'] = t[min_index]['Num']
            t[min_index]['Num'] = temp
            
            temp = t[i]['Dec']
            t[i]['Dec'] = t[min_index]['Dec']
            t[min_index]['Dec'] = temp

# --------------------------------------------------
# Fonction qui génère un code à partir d'un nombre
# en utilisant la base 3 avec :
# 0 → "Ma", 1 → "Des", 2 → "Son"
# --------------------------------------------------
def generer(nb):
    mot = ''
    
    # Calcul du reste de la division par 3
    r = nb % 3
    
    match r:
        case 0:
            y = "Ma"
        case 1:
            y = "Des"
        case 2:
            y = "Son"
            
    mot = y + mot
    nb = nb // 3    
    
    # Conversion du reste du nombre
    while nb != 0:
        r = nb % 3
        match r:
            case 0:
                y = "Ma"
            case 1:
                y = "Des"
            case 2:
                y = "Son"
        mot = y + mot
        nb = nb // 3
    
    return mot

# --------------------------------------------------
# Procédure qui écrit les résultats dans Resultat.txt
# --------------------------------------------------
def remplir_fichier_resultat(t, n):
    
    # Ouverture du fichier en écriture
    f = open("Resultat.txt", "w")
    
    for i in range(n):
        code = generer(t[i]['Dec'])
        f.write(code + ' ' + str(t[i]['Num']) + '\n')
    
    f.close()

# --------------------------------------------------
# Procédure qui affiche le contenu du fichier Resultat.txt
# --------------------------------------------------
def afficher_fichier_resultat():
    f = open("Resultat.txt", "r")
    codes = f.readlines()
    
    for code in codes:
        print(code.strip('\n'))
    f.close()    

# --------------------------------------------------
# Programme principal
# --------------------------------------------------
index = 0

# Remplissage du tableau à partir du fichier
remplir_tableau(t)

# Tri du tableau selon la valeur décimale
trier_tableau(t, index)

print('*** Tableau T trie ***')
afficher_tableau(t, index)

# Génération du fichier résultat
remplir_fichier_resultat(t, index)

print('*** Contenu du fichier Resultat ***')
afficher_fichier_resultat()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

from numpy import *

# --------------------------------------------------

# Création d'un tableau de 50 dictionnaires

# Chaque élément contiendra :

# - Hex : nombre en hexadécimal (chaîne)

# - Num : numéro d'ordre

# - Dec : valeur décimale correspondante

# --------------------------------------------------

t = array([{}] * 50)

# --------------------------------------------------

# Fonction qui calcule n à la puissance e (n^e)

# --------------------------------------------------

def exposant(n, e):

p = 1

for i in range(e):

p = p * n

return p

# --------------------------------------------------

# Fonction qui convertit un nombre hexadécimal

# (sous forme de chaîne) en nombre décimal

# --------------------------------------------------

def conversion_decimale(nombre_hexa):

decimal = 0 # Résultat en base 10

puissance = 1 # Représente 16^0 au départ

# Parcours de la chaîne de droite à gauche

for i in range(len(nombre_hexa) - 1, -1, -1):

chiffre = nombre_hexa[i]

# Conversion du caractère en valeur numérique

if '0' <= chiffre <= '9':

valeur = ord(chiffre) - ord('0')

else:

valeur = ord(chiffre) - ord('A') + 10

# Ajout de la contribution du chiffre

decimal += valeur * puissance

# Passage à la puissance suivante de 16

puissance = puissance * 16

return decimal

# --------------------------------------------------

# Procédure qui lit le fichier ImgHexa.txt

# et remplit le tableau t avec des dictionnaires

# --------------------------------------------------

def remplir_tableau(t):

global index

# Ouverture du fichier en lecture

f = open("ImgHexa.txt", "r")

# Lecture de toutes les lignes du fichier

nombres_hexa = f.readlines()

for nombre_hexa in nombres_hexa:

nombre_hexa = nombre_hexa.strip('\n') # Suppression du retour à la ligne

# Création d'un enregistrement sous forme de dictionnaire

enregistrement = dict(

Hex=str(), # Valeur hexadécimale

Num=int(), # Numéro d'ordre

Dec=int() # Valeur décimale

)

# Remplissage du dictionnaire

enregistrement['Hex'] = nombre_hexa

enregistrement['Num'] = index + 1

enregistrement['Dec'] = conversion_decimale(nombre_hexa)

# Stockage dans le tableau

t[index] = enregistrement

index = index + 1

# --------------------------------------------------

# Procédure qui affiche les n premiers éléments du tableau t

# --------------------------------------------------

def afficher_tableau(t, n):

for i in range(n):

print(t[i])

# --------------------------------------------------

# Procédure de tri du tableau selon la valeur décimale

# (tri par sélection croissant)

# --------------------------------------------------

def trier_tableau(t, n):

for i in range(n - 1):

min_index = i

# Recherche du plus petit élément

for j in range(i, n):

if t[min_index]['Dec'] > t[j]['Dec']:

min_index = j

# Échange des éléments si nécessaire

if min_index != i:

temp = t[i]['Hex']

t[i]['Hex'] = t[min_index]['Hex']

t[min_index]['Hex'] = temp

temp = t[i]['Num']

t[i]['Num'] = t[min_index]['Num']

t[min_index]['Num'] = temp

temp = t[i]['Dec']

t[i]['Dec'] = t[min_index]['Dec']

t[min_index]['Dec'] = temp

# --------------------------------------------------

# Fonction qui génère un code à partir d'un nombre

# en utilisant la base 3 avec :

# 0 → "Ma", 1 → "Des", 2 → "Son"

# --------------------------------------------------

def generer(nb):

mot = ''

# Calcul du reste de la division par 3

r = nb % 3

match r:

case 0:

y = "Ma"

case 1:

y = "Des"

case 2:

y = "Son"

mot = y + mot

nb = nb // 3

# Conversion du reste du nombre

while nb != 0:

r = nb % 3

match r:

case 0:

y = "Ma"

case 1:

y = "Des"

case 2:

y = "Son"

mot = y + mot

nb = nb // 3

return mot

# --------------------------------------------------

# Procédure qui écrit les résultats dans Resultat.txt

# --------------------------------------------------

def remplir_fichier_resultat(t, n):

# Ouverture du fichier en écriture

f = open("Resultat.txt", "w")

for i in range(n):

code = generer(t[i]['Dec'])

f.write(code + ' ' + str(t[i]['Num']) + '\n')

f.close()

# --------------------------------------------------

# Procédure qui affiche le contenu du fichier Resultat.txt

# --------------------------------------------------

def afficher_fichier_resultat():

f = open("Resultat.txt", "r")

codes = f.readlines()

for code in codes:

print(code.strip('\n'))

f.close()

# --------------------------------------------------

# Programme principal

# --------------------------------------------------

index = 0

# Remplissage du tableau à partir du fichier

remplir_tableau(t)

# Tri du tableau selon la valeur décimale

trier_tableau(t, index)

print('*** Tableau T trie ***')

afficher_tableau(t, index)

# Génération du fichier résultat

remplir_fichier_resultat(t, index)

print('*** Contenu du fichier Resultat ***')

afficher_fichier_resultat()

Exécution du programme

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Balance électronique avec Arduino UNO et module HX711

Arduino 03-03-26

Balance électronique avec la carte ESP32 et module HX711

ESP32 02-03-26

Horloge réveil avec ESP8266 NodeMCU et le module RTC DS1302

ESP8266 26-02-26

Mesurer le poids avec la carte Micro:bit et le capteur HX711

Micro:bit 25-02-26

Horloge digitale avec alarme utilisant Arduino UNO et DS1302

Arduino 23-02-26

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 11548vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 11173vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 9792vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino 9381vues

Allumer une LED par la carte ESP32

ESP32 9374vues

Construction des robots

Tutoriels plus commentés

Premiers pas avec Micro:bit et MakeCode

Micro:bit 29 commentaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino 28 commentaires

Présentation du module capteur de lumière à LDR

Composants 20 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino 17 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Cryptage image – Bac pratique – Section informatique – 2021

Sujet (Algo et programmation - Bac 2021)

Solution Algorithmique

Algorithme du programme Principal

La fonction exposant

La fonction conversion_decimale

La procédure remplir_tableau

La procédure afficher_tableau

La procédure trier_tableau

La procédure remplir_fichier_resultat

La procédure remplir_fichier_resultat

Solution en Python

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles