CyBWarrior

1. Les informations génerales
2. Les informations d’en-tête
3. La palette
4. Les données
5. Exemple en QBasic

Bitmap, ça veut plus ou moins dire littéralement carte à points, ou carte à bit.
Et c’est bien ce genre d’informations que contient un fichier de ce type. Chaque pixel est enregistré dans
le bitmap. Aucune compression, que ce soit du type LZW ou par perte de données, n’est utilisée dans ce format.
C’est pourquoi la lecture et l’interprétation de ce genre de fichier reste relativement simple.
Un fichier bitmap est composé de 4 choses : les informations génerales, les informations d’en-tête,
la palette et les données.
Pour illustrer ceci, nous allons créér un lecteur d’images bitmap. Pour le faire, j’ai choisi un langage simple
et facilement compréhensible pour tous, même de ceux qui ne le connaissent pas : le QBasic. Vous pouvez télécharger
le code source de cet exemple ici :

Code source du lecteur de bitmap en QBasic (4.02 ko)

Les informations génerales

Les informations génerales commencent avec le début du fichier, c’est à dire de l’octet 0 et s’achévent à
l’octet 10.
Voici ces informations :

Offset (position)	Longueur (en octets)	Signification
0	2	Normalement, il doit y avoir BM pour confirmer que l’image est bien un bitmap
2	4	Taille du fichier, sans la partie d’en-tête
6	2	Réservé. Normalement à zéro (0)
8	2	Réservé. Normalement à zéro (0)
10	4	Offset à partir du quel commencent les données.

Hormis la confirmation du type d’image (Offset 0), ces informations sont rarement utilées. On passe généralement
directement au informations d’en-tête.

Les informations d’en-tête

Ces informations suivent directement les informations générales. Elles commencent donc au 14^ème octet.
Elles donnent des renseignements sur l’image proprement dite : largeur, hauteur, nombres de couleurs…

Offset (position)	Longueur (en octets)	Signification
14	4	Taille des information d’en-tête, soit 40, soit 12
18	4	Largeur de l’image, en pixels
22	4	Hauteur de l’image, en pixels
26	2	Nombre de plan, doit être à 1
28	2	Nombre de bits par pixels. Les valeurs peuvent être 1, 4, 8 ou 24
30	4	Compression, doit normalement être à zéro. Sinon, c’est une image RLE
34	4	Taille de l’image, en octets
38	4	Largeur de l’image, dans une autre unité
42	4	Hauteur de l’image, dans une autre unité
46	4	Nombre de couleurs utilisées par l’image. Si 0, alors toutes les couleurs sont utilisées.
50	4	Nombre de couleurs importantes. Si 0, alors toutes les couleurs sont importantes.

La palette

La palette représente les couleurs utilisées par l’image. Elles sont codées en RGB : Red, Green et
Blue. Selon les valeurs de ces composantes, on obtient différentes couleurs. Chaque composante peut varier de 0 à 255.
Attention! Pour les fichiers bitmap 24 bits, il n’y a pas de palette!
Voici comment obtenir ces couleurs :

Offset (position)	Longueur (en octets)	Signification
14 + Taille de l’en-tête	1	Intensité du Bleu de la couleur 0
14 + Taille de l’en-tête + 1	1	Intensité du Vert de la couleur 0
14 + Taille de l’en-tête + 2	1	Intensité du Rouge de la couleur 0
14 + Taille de l’en-tête + 3	1	Inutilisé. Doit être à zéro.
14 + Taille de l’en-tête + 4	1	Intensité du Bleu de la couleur 1
…	…	…

Les données

Les données représentent l’index de la couleur de chaque pixel de l’image.
Elles commencent dans le coin inférieur gauche de l’image. Chaque donnée de plus est un pixel vers la droite.
Ensuite, tout dépend du nombre de bits par pixels de l’image :

Bits par pixels	Représentation
1 (monochrome)	8 pixels (horizontaux) sont représentés dans un octet. Chaque bit de cet octet représente la couleur : 0 pour noir 1 pour blanc.
4 (16 couleurs)	Un octet représente 2 pixels de l’image. Les 4 bits de poids fort repésente la 1er couleur, et les 4 bits de poids faible la 2ème couleur de cet octet.
8 (256 couleurs)	Le plus simple. Chaque octet représente la couleur d’un pixel.
24 (16777216 couleurs)	Comme dit plus haut, pour ce type d’image, il n’y a pas de palette. Chaque pixel est représenté par 3 octets. Chacun de ces 3 octets correspond à l’intensité d’une des 3 (!) composantes RGB du pixel.

Exemple en QBasic

Voici un exemple de gestion des images bitmap avec un langage simple : le QBasic.
Attention! Cet exemple est MINIMUM. Il vous montre simplement la méthode pour exploiter
ce format d’image. Il n’est donc pas optimisé et est donc relativement lent.

DIM Octet AS STRING * 1			' 1 Octet
DIM Mot AS STRING * 2			' 2 Octets
DIM DMot AS STRING * 4			' 4 Octets

DIM HeadSize AS LONG			' Taille de l'en-tête
DIM BWidth AS LONG			' Largeur de l'image
DIM Bheight AS LONG			' Hauteur de l'image
DIM bpp AS INTEGER			' Bits par pixels

filename$ = "banniere.bmp"		' fichier à ouvrir

SCREEN 13				' Mode 256 couleurs
CLS

' Attention en QBasic, le fichier commence à 1 et non pas à 0 !
OPEN filename$ FOR BINARY AS #1
	' Lecture des informations d'en-tête
	GET #1, 15, DMot
	HeadSize = CVL(DMot)
	GET #1, 19, DMot
	BWidth = CVL(DMot)
	GET #1, 23, DMot
	Bheight = CVL(DMot)
	GET #1, 29, Mot
	bpp = CVI(Mot)

	' Lecture de la palette
	lengthpal = 4 * 2 ^ bpp
	StartPal = 15 + HeadSize
	EndPal = StartPal + lengthpal
	j = 0
	FOR i = 0 TO lengthpal STEP 4
		GET #1, i + StartPal, Octet
		bleu = INT(ASC(Octet) / 4)
		GET #1, i + StartPal + 1, Octet
		vert = INT(ASC(Octet) / 4)
		GET #1, i + StartPal + 2, Octet
		rouge = INT(ASC(Octet) / 4)
		PALETTE j, 65536 * bleu + 256 * vert + rouge
		j = j + 1
	NEXT i

	' Lecture des données
	y = Bheight
	DO
		x = 0
		DO
			GET #1, , Octet
			Index = ASC(Octet)
			SELECT CASE bpp
			CASE 1		' 1 bit
				FOR i = 0 TO 7
					PSET (x + 7 - i, y), (Index AND 2 ^ i) / 2 ^ i
				NEXT i
				x = x + 8
			CASE 4		' 4 bits
				PSET (x, y), Index AND 15
				PSET (x + 1, y), Index AND 240 / 16
				x = x + 2
			CASE 8		' 8 bits
				PSET (x, y), Index
				x = x + 1
			CASE 24		' 24 bits

			END SELECT
		LOOP UNTIL x >= BWidth
		y = y - 1
	LOOP UNTIL y <= 0
CLOSE #1

1. Un écran de veille, qu’est ce que c’est ?
2. Un exemple concret : Les balles rebondissantes
3. Notes de dernière minute

On m’a souvent posé la question. Je dois moi-même avouer que j’ai longtemps cherché. Et vous-même, je suis sûr
que vous avez bataillé des heures et des heures, la preuve, vous lisez ces lignes…

L’exemple ci-dessous est en Visual Basic 5.0.

Ce langage a pour défaut d’être lent, car il est plus ou moins interprété, mais à comme grand avantage d’être simple à comprendre, même pour
un non pratiquant.
Vous pouvez télécharger la source ici :

• Code source de l’écran de veille (14.2 ko)

Un écran de veille, qu’est ce que c’est ?

Vous allez rire quand je vais vous le dire si vous ne le saviez pas déjà. Les gars de chez
Microsoft ne se sont pas cassé la tête. Il ont bêtement changer l’extension EXE d’un fichier
exécutable en .SCR. Et ça suffit. C’est pas plus dur que cela. Bien sûr, après, il faut écrire
un peu de code.

Car vous l’aurez certainement remarqué, un écran de veille fonctionne de plusieurs façons :

• Le mode Ecran de veille : C’est lorsque l’écran de veille fonctionne
  de façon normale, lorsque l’on clique sur le bouton ‘Aperçu’ ou lorsque l’on attend un
  certain temps.


• Le mode Configuration : Ce mode permet de configurer l’écran de
  veille à l’aide de la boîte de dialogue appropriée. Quand vous cliquez sur le bouton
  ‘Configurer’ des propriétés d’affichage.

Pour lancer ces deux modes, Windows utilise la technique des arguments de commande. Vous

avez certainement fait du DOS. Lorsque vous tapez ‘DIR’, la liste des fichiers du répertoire en

cours apparaît. Maintenant, si vous tapez ‘DIR /W’, la liste des fichiers apparaît toujours, mais

en colonnes, car on a passé un argument de commande : /W.

Pour lancer le mode Ecran de veille, Windows utilise l’argument /S comme Screen Saver.

Pour le mode Configuration, c’est l’argument /C comme Config.

Un exemple concret : Les balles rebondissantes

Maintenant que la théorie a plus ou moins été détaillée, nous allons passer à un exemple pratique,

détaillé pas à pas en Visual Basic.

Allez dans Visual Basic et créez un nouveau projet ‘EXE standard’. Ajoutez à ce projet un module

et une autre feuille. Renommez le module en ‘basMain’, et les feuilles en ‘frmConfig’ et

‘frmScreensaver’. Dans la boîte de dialogue du menu ‘Projet/Propriété’, sélectionnez ‘Sub Main’

comme objet de démarrage.

Allez dans le module ‘basMain’ et créez la sub ‘Main’. Ecrivez ‘Public Sub Main’.

C’est le code situé dans cette procédure qui sera exécuté lors du démarrage. C’est donc ici

qu’il faudra traiter l’argument de la ligne de commande, soit /S, soit /C.

Pour reconnaître l’argument de commande, nous allons créer une fonction qui renverra l’argument

spécifié.

Voici le code de cette fonction :

Public Function GetArg(Arg As Integer) As String

Dim strArg()  As String

Dim strCommand      As String

Dim strChar         As String * 1

Dim intLength       As Integer

Dim intArg          As Integer

Dim i

Dim j

strCommand = Command()

intLength = Len(strCommand)

For i = 1 To intLength

    strChar = Mid(strCommand, i, 1)

    If strChar = « / » Then

        intArg = intArg + 1

        ReDim Preserve strArg(1 To intArg)

        strArg(intArg) = strArg(intArg) & strChar

        For j = i + 1 To intLength

            strChar = Mid(strCommand, j, 1)

            If strChar = « / » Then

                strArg(intArg) = Trim(strArg(intArg))

                Exit For

            End If

            strArg(intArg) = strArg(intArg) & strChar

        Next j

    End If

Next i
If Arg <= 0 Then

    GetArg = strArg(LBound(strArg))

ElseIf Arg > UBound(strArg) Then

    GetArg = strArg(UBound(strArg))

Else

    GetArg = strArg(Arg)

End If

End Function

Cette fonction permet de traiter facilement les arguments de commande. Il suffit de spécifier

le numéro de l’argument à retourner et le tour est joué !

Retournons maintenant à la Sub Main. Si l’argument est ‘/S’, on lance la feuille ‘frmScreensaver’.

Si c’est l’argument ‘/C’, c’est la feuille ‘frmConfig’ qui est lancée. Vous aurez remarqué que l’on

n’utilise que les 2 caractères les plus à gauche de l’argument. C’est parce que l’argument est suivi

d’un nombre que nous expliquerons dans un prochain sujet. Il faut également empêcher la création

de plusieurs instances de l’application, sinon, on va se retrouver avec une multitude d’écrans

de veille lancés en même temps, ce qui finirait par faire planter le PC.

Public Sub Main()

If App.PrevInstance = True Then End

Select Case Left(UCase(GetArg(1)), 2)

Case « /C »

    frmConfig.Show

Case « /S »

    frmScreensaver.Show

End Select
Do

Loop Until DoEvents = 0

End Sub

Pour tester votre écran de veille dans Visual Basic, il vous faut spécifier l’argument ‘/S’ ou

‘/C’ dans la boîte de dialogue de ‘Projet/Propriétés’.

Passons maintenant au code de l’écran de veille lui-même. Pour cela, placez-vous dans la procédure

‘Form_Load’ de la feuille ‘frmScreensaver’. Il nous faut redimensionner la fenêtre en plein

écran, faire disparaître la barre de titre et changer le fond en noir. Tout ceci doit se trouver

dans la procédure ‘Form_Load’. Vu que la propriété ‘BorderStyle’ est en lecture seule au moment

de l’exécution, vous devez la modifier dans la fenêtre ‘Propriétés’ :

Private Sub Form_Load()

With Me

    .BackColor = vbBlack

    .Move 0, 0, Screen.Width, Screen.Height

End With

End Sub

Comme vous le savez certainement, un écran de veille est arrêté par différents événements. Vous

devez donc décharger la feuille à l’aide du code suivant dans les procédures qui le demandent.

Le code est simple, c’est :

Private Sub Evénement()

Unload Me

End Sub

Vous devez écrire Unload Me pour les événements suivants :

• Form_Click
• Form_DblClick
• Form_Deactivate
• Form_KeyDown
• Form_KeyPress
• Form_KeyUp
• Form_LostFocus
• Form_MouseDown
• Form_MouseMove (voir ci-dessous)
• Form_MouseUp

Pour ‘Form_MouseMove’, il y a un petit problème. En effet, cet évènement est continuellement généré.

Il va donc falloir écrire du code pour éviter que l’écran de veille se termine même si la souris

ne bouge pas :

Private Sub Form_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single)

Static sngX     As Single

Static sngY     As Single

Static blnInit  As Boolean

If blnInit = False Then

    sngX = X

    sngY = Y

    blnInit = True

    Exit Sub

End If
If sngX + 5 < X Or sngX - 5 > X Or sngY + 5 < Y Or sngY - 5 > Y Then Unload Me
End Sub

Vous pouvez tester. Déjà, ça peut faire un écran de veille. (Souvenez-vous de l’écran vide

fourni avec Windows). Mais il y a un petit détail pas net : on voit le curseur de la souris.

Vous devez donc créer un Curseur Invisible avec votre éditeur d’image favori. Chargez ce curseur

dans la propriété ‘MouseIcon’ et sélectionnez ‘99 – Custom’ dans ‘MousePointer’.

Nous allons maintenant faire rebondir nos fameuses balles… Pour cela, nous allons créer un

type pour la balle. Allez dans la partie ‘Déclararation’ du module ‘basMain’ et écrivez le code

suivant :

Option Explicit

Public Const REG_SECT_BALLES    As String = « Balles »

Public Const REG_BALLES_NOMBRE  As String = « Nombre »
Public Type TBalle

    X       As Single

    Y       As Single

    CX      As Single

    CY      As Single

    Diam    As Integer

End Type
Public Balle()  As TBalle

L’Option Explicit, c’est selon que vous déclariez vos variables explicitement ou

implicitement.

Comme notre écran de veille va être un petit peu configurable, nous allons utiliser un nombre

de balles variables qui sera stocké dans la base de registre. C’est à ça que vont servir les

constantes que l’on a définies. Pour cela, nous allons créer une fonction qui renverra le nombre

de balles à utiliser :

Public Function GetNumBalles() As Integer

GetNumBalles = CInt(GetSetting(App.EXEName, REG_SECT_BALLES, REG_BALLES_NOMBRE, 1))
End Function

Allez dans la feuille ‘frmScreensaver’ est ajoutez un Timer. Renommer le en ‘tmrScreensaver’

et assignez la valeur 1 à la propriété ‘Interval’. Allez dans la procédure ‘tmrScreensaver_Timer’

et écrivez le code suivant :

Private Sub tmrScreensaver_Timer()

Static blnInit  As Boolean

Dim i

If blnInit = False Then

    ReDim Balle(GetNumBalles – 1)

    FillStyle = vbFSSolid

    For i = LBound(Balle) To UBound(Balle)

        Randomize Timer

        With Balle(i)

            .X = Rnd * Screen.Width

            .Y = Rnd * Screen.Height

            .CX = Rnd * 100 * IIf(Rnd > 0.5, -1, 1)

            .CY = Rnd * 100 * IIf(Rnd > 0.5, -1, 1)

            .Diam = Rnd * 500

        End With

    Next i

    blnInit = True

End If
For i = LBound(Balle) To UBound(Balle)

    With Balle(i)

        FillColor = BackColor

        Circle (.X, .Y), .Diam, BackColor

        .X = .X + .CX

        .Y = .Y + .CY

        FillColor = vbYellow

        Circle (.X, .Y), .Diam, vbYellow

        If .X – .Diam <= ScaleLeft Or .X + .Diam >= ScaleWidth Then .CX = -.CX

        If .Y – .Diam <= ScaleTop Or .Y + .Diam >= ScaleHeight Then .CY = -.CY

    End With

Next i

End Sub

Ca y est! Notre écran de veille est terminé! Mais il nous faut réaliser la deuxième partie de

l’écran de veille : le mode Configuration. Pour cela, allez dans la feuille ‘frmConfig’ et

assignez ‘Configuration de l’écran de veille’ à la propriété ‘Caption’ de la feuille et modifiez

la propriété ‘BorderStyle’ sur ‘3 – Fixed Dialog’

Dessinez (c’est à dire apposez) deux boutons de commande. Renommez l’un en ‘cmdOK’ et l’autre

en ‘cmdAnnuler’. Allez dans la procédure ‘cmdAnnuler_Click’ et écrivez le code suivant :

Private Sub cmdAnnuler_Click()

Unload Me

End Sub

Dessinez un Label et renommez sa propriété ‘Name’ en ‘lblExplain’ et écrivez ‘Nombre de balles :’

dans sa propriété ‘Caption’.

À coté, dessinez un contrôle TextBox et modifiez sa propriété ‘Name’ en ‘txtBalles’. Ensuite,

modifiez la propriété ‘Cancel’ sur ‘True’ et modifiez la propriété ‘Caption’ en écrivant ‘&Annuler’.

Allez dans la procédure ‘cmdOK_Click’ et écrivez le code suivant :

Private Sub cmdOK_Click()

If IsNumeric(txtBalles.Text) = False Then

    MsgBox « Nommbre de balles incorrect ! », vbExclamation

    Exit Sub

End If

SaveSetting App.EXEName, REG_SECT_BALLES, REG_BALLES_NOMBRE, txtBalles.Text
Unload Me

End Sub

Il faut aussi indiquer l’ancien nombre dans ce contrôle TextBox. Pour cela, placez-vous dans

la procédure ‘Form_Load’ de la feuille et écrivez :

Private Sub Form_Load()

txtBalles.Text = GetNumBalles

End Sub

Cette fois, c’est bel et bien fini. Il ne vous reste plus qu’à aller dans ‘Fichier/Créer Projet1′.

Dans le nom du fichier, changez l’extension .EXE en .SCR. Ensuite, déplacez ce fichier soit dans

le répertoire de Windows, soit dans le répertoire Système de Windows. Vous pouvez maintenant

l’utiliser comme un écran de veille standard.

Notes de dernière minute

Vous remarquerez cependant que cet écran de veille ne posséde pas d’aperçu. En effet, il

n’existe non pas deux mais trois arguments de la ligne de commande. Et ce toisième argument

(/P) sert à utiliser l’aperçu dans le petit écran de l’ordinateur du Panneau de configuration. Cet

argument est suivi d’un chiffre qui est l’handle d’un objet. Mais nous verrons prochainement

comment l’utiliser. Si vous avez des suggestions, n’hésitez pas…

1. Representation littérale
2. Schema à contact
3. Chronogramme
4. Table de verité
5. Equation logique
6. Logigramme

Cette fonction est similaire à la fonction NAND sur le fait que elle aussi se contente d’inverser
les états de sortie, mais dans ce cas, d’une fonction OU.

Representation littérale

Lorsqu’il n’y a pas l’entrée a = 1 OU l’entrée b = 1
=> la sortie S est active

Schema à contact

Chronogramme

Table de verité

Fonction NOR

a	b	S
0	0	1
0	1	0
1	0	0
1	1	0

Equation logique

De même que pour la fonction NAND, la fonction NOR est aussi un NON
par dessus un OU.
On obtient donc :

    _____
S = a + b

Logigramme

1. Vocabulaire
2. Commutativité
3. Associativité
4. Distributivité
5. Théorème de De Morgan

Le mathématicien britannique Georges Boole (Lincoln 1815 – Ballintemple, près de Cork, 1864) est considéré comme
le créateur de la logique mathématique moderne. L’heritage qu’il a laissé n’est pas des moindres : dans tous les
langages informatiques, les types de données ayant pour but de stocker des valeurs logiques sont appellés boolean.
L’algebre de Boole vise a étudier les relations logiques entre plusieurs variables.

Vocabulaire

Les fonctions logiques élementaires étudiées antérieurement, à savoir les fonctions OUI,
NON, ET et OU, sont des relations mathematiques,
comme le montre le tableau suivant :

Fonction	Relation	Symbole	Priorité
OUI	Egalité	=	4
NON	Négation (ou complement)	-	1
ET	Produit	•	2
OU	Somme	+	3

Les relations mathematiques classiques s’appliquent donc également aux relations logiques.
Les degrès de priorité sont numérotés du plus prioritaire au moins prioritaire.

Commutativité

Les sommes et les produits sont commutatifs.
Ainsi :

a • b = b • a
a + b = b + a

Associativité

Les sommes et les produits sont distributifs :

a • (b • c) = (a • b) • c
a + (b + c) = (a + b) + c

Distributivité

Les sommes et les produits sont distributifs :

a • b + a • c = a • (b + c)
(a + b) • (c + d) = a • c + a • d + b • c + b • d

Théorème de De Morgan

Le complement d’une somme est égale au produit de chaque terme complementé.

Le complement d’un produit est égale à la somme de chaque terme complementé.

Donc :

_____   _   _
a • b = a + b
_____   _   _
a + b = a • b

Le théorème de De Morgan s’applique tout particuliérement aux fonctions NAND et NOR, et
il se verfie :

• La fonction NAND :
  
  On voit bien que les contacts en parallèles a et b correspondent à l’equation.

• De même pour la fonction NOR :
  
  Pareil ici pour les contacts en série a et b

On a souvent tendance à l’oublier, mais au départ, un ordinateur n’est rien autre qu’un système electrique.
Pour schematiser, il est composé d’innombrables petit interrupteurs tout simples.
Or, un interrupteur ne connait que deux états :

Dans ce cas là, la lampe S est éteinte. Si maintenant, le contact a se ferme, la lampe S
va s’allumer.
Par convention, on note 0 lorsque la lampe est éteinte, et 1 lorsque elle est allumée. Il y a donc
2 états, d’où le mot : binaire.

Tout de suite, le problème apparait : « Mais comment puis-je faire, moi, l’humain qui compte jusqu’à 10, pour
pouvoir compter avec mon ami ordinateur ? »
C’est très simple. Analysons d’abord comment l’humain fait pour compter en base 10. Prenons par exemple le
nombre 421. Il peut être decomposé ainsi :

421 = 4 x 102 + 2 x 101 + 1 x 100

Rappelons qu’un nombre élevé à la puissance 0 est toujours égal à 1.
Un nombre binaire peut être lu de la même façon, à la différence qu’au lieu d’utiliser des puissances de 10,
on utilise des puissances de 2, vu que l’on est en base 2. Observons le nombre 110100101. On le décompose
ainsi :

110100101 = 1 x 28 + 1 x 27 + 0 x 26 + 1 x 25 + 0 x 24 + 0 x 23 + 1 x 22 + 0 x 21 + 1 x 20
          =     256 +     128 +      0 +      32 +       0 +      0 +       4 +       0 +      1
          = 421

En base binaire, on appel un BIT chaque chiffre composant un nombre. Les bits situés à la gauche d’un
nombre sont appelés les bits de poids fort, car ils sont très influents sur la valeur du nombre si ils
changent. Et à l’inverse, les bits situés à la droite sont appelés les bits de poids faible car peu influants.
On utilise rarement un bit tout seul. C’est pourquoi on les associe en goupe de 8, 16 et 32 :

Nom	Nombre de bits	Valeur maximum
Bit	1	20 – 1 = 1
Octet (ou Byte en anglais)	8	28 – 1 = 255
Mot (ou Word en anglais)	16	216 – 1 = 65535
Double mot (ou Double Word en anglais)	32	232 – 1 = 4294967295

2^ème question : « J’arrive maintenant à lire les nombres que me donne mon ami l’ordinateur, mais
comment puis-je faire pour qu’il puisse lire les miens ? ».
Il suffit de convertir ce nombre en base 10, en base binaire. La régle de conversion est simple : il suffit
de s’y prendre à l’envers.
Note : par convention, on note en indice à la droite du nombre la base dans laquelle est exprimée le chiffre
(ex : 421₁₀ pour 421 en base 10, ou 110100101₂ pour ce même nombre, mais en base 2).

666 / 29 = 1                --> reste 154
154 / 28 = 0                --> reste 154
154 / 27 = 1                --> reste  26
 26 / 26 = 0                --> reste  26
 26 / 25 = 0                --> reste  26
 26 / 24 = 1                --> reste  10
 10 / 23 = 1                --> reste   2
  2 / 22 = 0                --> reste   2
  2 / 21 = 1                --> reste   0
  0 / 20 = 0                --> reste   0

666 --> 1010011010 (lecture de haut en bas)

L’unité légale, c’est à dire reconue par le système international d’unités (SI), pour mesurer les distances
est le mètre (noté m). Mais cela n’empèche pas que pour des raisons partiques, nous utilisons par exemple des kilomètres (1 km = 1000 m).
En binaire, il n’y a pas d’unitès SI, mais on utilise l’octet comme référence (noté o). Il existe donc des kilo-octets
(noté ko), des méga-octets (noté mo) et même des giga-octets (noté go).
Attention ! On pourai croire que 1 ko = 1000 o, que 1 mo = 1000 ko, etc…
Et bien non : 1ko correspond à 2¹⁰ octets, c’est à dire à 10000000000₂ octets, donc à
1024 octets et non à 1000. Nous pouvons donc établir le tableau suivant :

Nom	Symbole	Equivalence en octets
octet	o	20 = 1 !
kilo-octet	ko	210 = 1 024
méga-octet	mo	220 = 1 048 576
giga-octet	go	230 = 1 073 741 824
tetra-octet	to	240 = 1 099 511 627 776

On s’aperçoit que 1 go = 1 mo x 2¹⁰ et que 1 mo = 1 ko x 2¹⁰.
Mon disque dur de 20 go peut donc contenir 20 x 2³⁰ = 21 474 836 480 octets, autement dit 21 474 836 480
caractères (on verra par la suite qu’un caractère equivaut à un octet), ce qui équivaut à approximativement
4170 Bibles, ancien et nouveau testaments réunis (la Bible n’étant pas non plus une unité SI !
Ça rend humble de savoir ça…

La notation hexadecimal est également un système de numération très utilisé en informatique, notament avec les
langages de programmation de bas niveau tel que l’assembleur.

Le fonctionnement de l’hexadecimal est identique à celui du decimal ou du binaire, sauf que dans ce cas, au
lieu de compter jusqu’à 9 ou 1, on va jusqu’à 15.
Mais là, problème : comment faire pour representer les chiffres au delà de 9 ? On utilise tout simplement les
lettres A, B, C, D, E et F.
Voici un tableau d’equivalence decimal <-> hexadecimal :

Decimal	Hexadecimal
0	0
1	1
2	2
3	3
4	4
5	5
6	6
7	7
8	8
9	9
10	A
11	B
12	C
13	D
14	E
15	F

Les rêgles de conversion restent les mêmes, donc pour convertir le nombre 7D2 en notation decimal, on
effectuera les calculs suivants :

7D2 = 7 x 162 + D x 161 + 2 x 160
    = 7 x 256 + 13 x 16 +   2 x 1
    =    1792 +     208 +       2
    = 2002

Evidemment, la conversion decimal <-> hexadecimal suit aussi les mêmes régles. Prenons pour exemple le
nombre 11259375 :

11259375 / 165 = 10 = A               --> reste 773615
  773615 / 164 = 11 = B               --> reste  52719
   52719 / 163 = 12 = C               --> reste   3567
    3567 / 162 = 13 = D               --> reste    239
      39 / 161 = 14 = E               --> reste     15
      15 / 160 = 15 = F               --> reste      0

11259375 --> ABCDEF (lecture de haut en bas)

Mais pourquoi utiliser la notation hexadecimal? Pour plusieurs raisons :

• Tout d’abord, la notation hexadecimal permet de representer facilement un octet (2⁸) en
  seulement 2 caractères (16²).
  Par exemple, 11111111₂ = FF₁₆. Le nombre de caractères à utiliser est divisé
  par 2, ce qui d’une part va plus vite à écrie, et d’autre part permet de réduire le risque d’erreur.

• 16 = 2⁴. La conversion binaire <-> hexadecimal devient beaucoup plus facile à
  réaliser, et vice-versa, car une lettre hexadecimal equivaut à 4 bits (exposant 4).
  Par exemple, prenons 3039₁₆ :

  3-> 0011
  0-> 0000
  3-> 0011
  9-> 1001
  
  303916 = 00110000001110012
  

  Et comme éconcé plus haut, la réciproque est aussi vrai. Prenons 1111111011011100 :

  1111-> F
  1110-> E
  1101-> D
  1100-> C
  
  11111110110111002 = FEDC16
  

Le système octal est très peu utilisé, mais il faut parfois s’en servir dans certaines opérations informatiques.
Les régles de conversions sont identiques à celles énoncées précedement.
Conversion de 98₁₀ en octal :

98 / 82 = 1                        –> reste 34

34 / 81 = 4                        –> reste  2

 2 / 80 = 2                        –> reste  0

98 –> 142 (de haut en bas)

Et maintenant, le 765₁₀ en décimal :

765 = 7 x 82 + 6 x 81 + 5 x 80

    = 7 x 64 +  6 x 8 + 5 x 8

    =    448 +     48 +    40

    = 536

1. Introduction
2. Representation littérale
3. Representation graphique (schema à contact)
4. Representation temporelle (chronogramme)
5. Représentation arithmétique (table de verité)
6. Représentation algébrique (equation logique)
7. Representation fonctionnelle (logigramme)

Introduction

Toute unité de traitement, automate ou programme est généralement destiné à traiter les informations qu’elle
reçoit afin de les re-transmettre à un utilisateur ou à un système.
Cette exploitation de l’information fait appel à la logique combinatoire et parfois à la logique
séquentielle (que nous étudierons par la suite).
Les rêgles élementaires de la logique combinatoire sont les suivantes :

• L’information ne peut prendre que deux états : 0 pour l’état inactif ou 1 pour l’état
  actif.
• Il y a toujours 2ⁿ combinaisons entre les variables, où n represente
  le nombre de variables.
• La même cause produit toujours le même effet. Per exemple, si j’appuis sur a, S sera toujours
  actif. Si je relache a, S sera toujours inactif.
• L’effet disparait dès que la cause disparait. Lorsque je relache a, S devient inactif
  instantanement.

Representation littérale

Cette representation de l’information logique est rarement utilisée, ou bien parfois dans des cahiers des charges.
Il s’agit tout simplement de d’écrire l’état du système lorsque sa sortie est active.
Par exemple :

Lorsque l’entrée a = 1
=> la sortie S est active

Representation graphique (schema à contact)

Tout comme un bit, un interrupteur electrique ne peut prendre que deux états :

• Ouvert : dans ce cas là, le courant ne passe pas, et la variable associée à ce contact est
  considérée comme inactive (0)
• Fermé : le courant passe. La variable associée est considérée comme active, donc à 1

L’exemple ci-dessus peut donc être modélisé comme suit :

Representation temporelle (chronogramme)

Le chronogramme vise à representer durant une durée donnée l’état de chaques variables et chaques sorties
d’une fonction logique.
Dans notre exemple, on obtient (avec Excel :

On voit bien sur ce chronogramme que la lampe S (en bleu) réagit en fonction
de l’interrupteur A (en vert).

Représentation arithmétique (table de verité)

On indique tout simplement dans un tableau l’état de la sortie pour chaque combinaison des entrées. Comme
énoncé plus haut, on a toujours 2ⁿ lignes.
Dans notre cas, c’est très simple, il y a 2¹ = 2 lignes :

Table de verité

a	S
0	0
1	1

Représentation algébrique (equation logique)

Lors d’une étude sur papier, c’est certainement la représentation la plus utilisé. C’est très simple : on
écrit simplement la sortie en fonction des variables.
Dans notre cas, c’est très simple :

S = a

Si a = 0, S = 0. Si a = 1, S = 1.

Representation fonctionnelle (logigramme)

Chaque opérateur logique est representé par un symbole. Il existe deux normes : la française et l’americaine.
La fonction logique que nous étudions depuis le début de cette page est la fonction OUI ou IDENTITE.
Les symboles sont les suivants :

1. Representation littérale
2. Schema à contact
3. Chronogramme
4. Table de verité
5. Equation logique
6. Logigramme

Representation littérale

Lorsque l’entrée a = 0
=> la sortie S est active

Schema à contact

Chronogramme

Table de verité

Fonction NON

a	S
0	1
1	0

Equation logique

    _
S = a

Logigramme

1. Representation littérale
2. Schema à contact
3. Chronogramme
4. Table de verité
5. Equation logique
6. Logigramme

Representation littérale

Lorsque l’entrée a = 1 ET l’entrée b = 1
=> la sortie S est active

Schema à contact

Chronogramme

Table de verité

Fonction ET

a	b	S
0	0	0
0	1	0
1	0	0
1	1	1

Equation logique

On symbolise la fonction ET par un point (•).

S = a • b

Logigramme