ISN relié

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche

Sections

Introduction[modifier | modifier le wikicode]

Ce livre contient de nombreux articles utiles aux étudiants de classe de Terminale qui sont inscrits à la spécialité Informatique et Sciences du numérique. Il est écrit en développant différentes parties du programme officiel du Ministère de l'Éducation Nationale.

première partie[modifier | modifier le wikicode]

La représentation de l'information[modifier | modifier le wikicode]

Dans un contexte informatique, l'information est représentée par des suites de nombres. La numérisation est l'opération qui associe à un objet réel du monde physique une description à l'aide d'un ensemble d'informations exploitables par un ordinateur ou, plus généralement, une machine numérique. À cause de l'échantillonnage sous-jacent, la numérisation induit des effets importants sur la qualité de l'information numérique. Elle entraîne des conditions spécifiques de création, de stockage, de traitement et de circulation de l'information.

Les capacités de traitement et de stockage des ordinateurs croissent de façon continue depuis leur apparition. Il est donc crucial d'organiser ces flux d'informations en local sur une machine ou de façon distribuée sur un réseau. L'intégration croissante du numérique dans les activités humaines et la numérisation de l'information suscitent des transformations culturelles, socio-économiques, juridiques et politiques profondes qui font apparaître de nouvelles opportunités, de nouveaux risques et de nouvelles contraintes qu'il convient d'étudier.

Source : programme officiel (www.education.gouv.fr/...bo=57572)

Les prochaines citations de ce programme officiel seront signalées par le logo suivant :

La représention binaire[modifier | modifier le wikicode]

Savoirs :

Un ordinateur est une machine qui manipule des valeurs numériques représentées sous forme binaire.

Capacités :

Manipuler à l'aide d'opérations élémentaires les trois unités de base : bit, octet, mot.

Observation :

On met en évidence, sous forme de questionnement, la présence du numérique dans la vie personnelle et professionnelle, au travers d'exemples.

Systèmes de numération[modifier | modifier le wikicode]

Quand des sociétés humaines ont commencé à compter, des systèmes de numération ont été mis au point, pour permettre de communiquer des nombres avec moins de mots.

Sceau-cylindre en jaspe et son impression : troupeau à l'étable, Mésopotamie, période d'Uruk (4100--3000 av. J.-C.).
Notice dans Wikimedia Commons : http://commons.wikimedia.org/wiki/File:Cylinder_seal_cowshed_Louvre_Klq17.jpg
Largeur pour LaTeX : 8cm

La numération la plus évidente à inventer consiste à montrer des collections de symboles. Des comptables de Mésopotamie ont utilisé des cylindres pour imprimer sur de l'argile des données commerciales. Les « imprimés » étaient complétés par des marques faites à l'aide d'un stylo en roseau, le calame.

Exercice

  • Pourquoi cette méthode a-t-elle été remplacée par d'autres plus tard ?
  • Retrouvez l'origine du mot calcul en Mésopotamie : qu'appelait-on les calculi ?

Les comptages simples, tels que des encoches sur un morceau de bois ou d'os, les collections de calculi dans une bourse en terre, deviennent plus pratiques quand on regroupe les unités par paquets. En Mésopotamie, la méthode utilisée consistait à faire des paquets de 60 : ça a mené à l'invention d'un système numérique à base 60.

Autres civilisations, autre mœurs, autres bases de numération, voici quelques exemples :

Époque Civilisation base de numération
Depuis -3000 Civilisation Sumérienne, puis Mésopotamienne, Chine, Inde Base sexagésimale (60) : on peut utiliser les pouces et les phalanges pour compter jusqu'à 60 avec les mains
Encore valide en 2013 Tous pays Base sexagésimale (60) : une heure compte 60 minutes, elles-même subdivisées en 60 secondes.
Jusqu'au XVIème siècle Civilisations aztèque, civilisation Maya Base vicésimale (20) : les calculs étaient faits dans cette base jusqu'à l'invasion espagnole
Moyen-Âge Pays européens Base vicésimale (20) : cette base était souvent utilisée en concurrence avec la base décimale. Il en reste de nombreux vestiges : le nombre « quatre vingt » toujours utilisé, le sou, égal à un vingtième de franc.
-200 Empire romain Base duodécimale (12). Le comptage par douze est souvent utilisé, et a laissé de nombreuses traces dans notre vocabulaire. Quelles sont les traces que vous connaissez ? Cherchez les sens du mot « grosse ».
Jusqu'à 1971 Empire brittanique Base duodécimale (12). La pièce de 1 shilling valait 12 pence (pluriel de penny)
Encore valide en 2013 États-Unis Base duodécimale (12). Un pied (mesure de longueur) se divise en 12 pouces


Questions sur les bases de numération[modifier | modifier le wikicode]

Plusieurs façons d'écrire des chiffres de base 10.

La base décimale que nous utilisons aujourd'hui vient de nos chiffres « arabes », qui ont été inventés en Inde.

  • Pourquoi la base 10 est-elle utilisée très largement partout ?
  • Est-ce la base la mieux appropriée dans tous les cas ?
  • Est-il facile de construire une machine à calculer qui fonctionne avec la base 10 ?

Exemple en base 5[modifier | modifier le wikicode]

Comme la majorité d'entre nous a cinq doigts aux membres, l'utilisation d'une base 5 paraît judicieuse.

Cette base est souvent utilisée, par exemple pour compter des points dans une rencontre sportive, ou pour compter des voix dans un bureau de vote.

Exercice résolu[modifier | modifier le wikicode]

Comment pourrions-nous noter le nombre de jours d'une année non bissextile, en base 5 ? Les symboles utilisés pour les chiffres seront 0, 1, 2, 3 et 4.

Solution Les calculs seront menés en base 10, qui nous est plus familière.

On divise 365 par 5 : , reste .

On divise 73 par 5 : , reste .

On divise 14 par 5 : , reste .

On divise 2 par 5 : , reste .

On s'arrête là, et on écrit la suite des restes à l'envers : . C'est la représentation en base 5 du nombre de jours d'une année non bissextile.

On peut vérifier que :

Convention de notation[modifier | modifier le wikicode]

On utilise souvent les premiers symboles de la suite 0123456789ABCDEF... (autant qu'il en faut, pas plus); comme symboles numériques pour une base donnée. Par exemple, pour la base 12, les symboles sont 0123456789AB.

Chaque fois qu'une ambiguïté est possible, on place un symbole de la base en indice du nombre écrit. Par exemple, le résultat de l'exercice résolu peut s'écrire , ou encore , ce qui signifie que 365 en base 10 (décimale) vaut 2430 en base 5 (quinaire).

La base 2 pour les ordinateurs[modifier | modifier le wikicode]

La base 5, ou base quinaire, semble adaptée pour les humains, à cause de leurs cinq doigts. Il existe des méthode de comptage avec les mains pour les bases 10, 12, 20 et 60.

Cependant les ordinateurs sont faits d'automatismes électroniques, où il est plus facile de distinguer deux états seulement : arrêt/marche, ou éteint/allumé, qu'on représente aussi souvent comme faux/vrai, ou 0/1.

Un composant de la famille 7400 TTL.

Exemple : les composants électroniques de la famille TTL (transistor-transistor logic) obéissent à la norme suivante :

  • les tensions utilisées sont toujours entre 0 et 5 V ;
  • les tensions entre 0 et 2 V correspondent à la valeur binaire  ;
  • les tensions entre 3 et 5 V correspondent à la valeur binaire  ;
  • les tensions ne restent presque jamais entre 2 et 3 V, et on s'arrange pour ne faire des calculs qu'en dehors des moments où existent des risques (aléas) d'avoir des tensions entre 2 et 3 volt.

Exercice résolu[modifier | modifier le wikicode]

Trouver la représentation en binaire de 365 en décimal.

Solution

On effectue la suite d'opérations suivantes :

Donc la solution est :

Vérifiez que...

Dans l'exemple précédent, on voit que pour représenter en binaire, 9 chiffres sont nécessaires. On peut retenir que pour un même nombre, l'écriture binaire est toujours environ trois fois plus longue que l'écriture décimale. Ce désavantage, pour les ordinateurs, est largement compensé par la grande simplicité des opérations que permet le système binaire.

La simplicité des opérations en binaire[modifier | modifier le wikicode]

Comparez les tables de multiplications en systèmes décimal et binaire !

Combien vous a-t-il fallu de temps pour mémoriser les tables de multiplication au cours de votre scolarité ? Les connaissez-vous bien ?

La table de multiplication en binaire est beaucoup plus simple ! (On a retiré la multiplication par zéro des tables de l'illustration, et on a un peu triché en supprimant les lignes et colonnes de 10 dans le cas de la table en base deux).

Exercices

  • Retrouvez les tables de multiplication complètes en système binaire. On doit tenir compte du chiffre zéro. Il faut la table de multiplication et la table d'addition. Ne pas oublier de signaler quand il y a une retenue.
  • Multipliez par , vérifiez que le résultat est le même que pour la multiplication de 365 par 3.

Conversions d'un nombre d'une base à l'autre[modifier | modifier le wikicode]

En vous inspirant des exercices ci-dessus, on peut décrire en toute généralité l'algorithme qui permet de convertir un nombre écrit en base X vers sa représentation en base Y. Il faut pour cela :

  1. passer de la suite des symboles représentant le nombre en base X au nombre entier représenté,
  2. puis de ce nombre vers la suite de symboles le représentant en base Y.

Algorithme pour passer de la représentation d'un nombre en base X à sa valeur[modifier | modifier le wikicode]

debut
 chaineConstante symboles := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 chaine nombreEnBaseX
 caractere c
 entier val := 0
 entier i
 entier X
 lire (nombreEnBaseX)
 lire (X)
 tantQue longueur(nombreEnBaseX) > 0 :
    val := X * val
    c := premierCaractereDe (nombreEnBaseX)
    nombreEnBaseX = sousChaine(nombreEnBaseX, debut=1)
    i := position (C, symboles)
    val := val + i
 fin tantQue
 resultat := val
fin

Exemple de fonctionnement

On lance le programme, et on répond "101" puis "2".

À ce stade, (ligne 10)

  • symboles vaut "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ",
  • val vaut 0,
  • nombreEnBaseX vaut "101",
  • X vaut 2.
  • Les valeurs de c et i sont indéterminées.

Au premier passage dans la boucle tantQue,

  • la longueur de nombreEnBaseX vaut 3, dont on entre dans la boucle.
  • val prend la valeur 2 * 0, il reste nul.
  • puis c prend la valeur "1" et
  • nombreEnBaseX est raccourci à gauche pour devenir "01".
  • i prend la valeur 1 (position de "1" dans la chaîne "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
  • puis val prend la valeur 0+1 = 1.

Au deuxième passage dans la boucle tantQue,

  • la longueur de nombreEnBaseX vaut 2, dont on entre dans la boucle.
  • val prend la valeur 2 * 1 = 2.
  • puis c prend la valeur "0" et
  • nombreEnBaseX est raccourci à gauche pour devenir "1".
  • i prend la valeur 0 (position de "0" dans la chaîne "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
  • puis val prend la valeur 2+0 = 2.

Au troisième passage dans la boucle tantQue,

  • la longueur de nombreEnBaseX vaut 1, dont on entre dans la boucle.
  • val prend la valeur 2 * 2 = 4.
  • puis c prend la valeur "1" et
  • nombreEnBaseX est raccourci à gauche pour devenir "".
  • i prend la valeur 1 (position de "1" dans la chaîne "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
  • puis val prend la valeur 4+1 = 5.

Il n'y a pas de quatrième passage dans la boucle tantQue, puisque la longueur de nombreEnBaseX vaut 0. On passe donc à la suite, ce qui établit le résultat à 5.

Exercice

  • Vérifiez que si on lance l'algorithme et qu'on répond "75" puis "8", le résultat vaut 61 (en base décimale).
  • Vérifiez que si on lance l'algorithme et qu'on répond "AA" puis "16", le résultat vaut 176 (en base décimale).

Algorithme pour passer d'une valeur entière à sa représentation base Y[modifier | modifier le wikicode]

debut
    chaineConstante symboles := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    entier val
    entier Y
    chaine repr := ""
    caractere c
    entier quotient
    entier reste
    lire (val)
    lire (Y)
    tantQue val > 0 :
       quotient := val div Y
       reste    := val mod Y
       val := quotient
       c := niemeCaractere (reste, symboles)
       repr := concatener (c, repr)
    fin tantQue
    resultat := repr
fin

Exemple de fonctionnement

On lance l'algorithme et on répond "5" et "2". À ce moment-là (à la ligne 11),

  • symboles vaut "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ",
  • val vaut 5, Y vaut 2 et
  • repr vaut "" (chaîne vide).
  • Les valeurs de c, quotient, reste sont indéterminées.

Au premier passage dans la boucle,

  • val vaut 5, donc on y entre.
  • quotient prend la valeur 2 et
  • reste prend la valeur 1 ;
  • val prend la valeur 2 ;
  • c devient "1" puisque c'est le caractère numéro 1 de "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
  • repr devient "1" attaché à "", donc "1".

Au deuxième passage dans la boucle,

  • val vaut 2, donc on y entre.
  • quotient prend la valeur 1 et
  • reste prend la valeur 0 ;
  • val prend la valeur 1 ;
  • c devient "0" puisque c'est le caractère numéro 0 de "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
  • repr devient "0" attaché à "1", donc "01".

Au troisième passage dans la boucle,

  • val vaut 1, donc on y entre.
  • quotient prend la valeur 0 et
  • reste prend la valeur 1 ;
  • val prend la valeur 0 ;
  • c devient "1" puisque c'est le caractère numéro 1 de "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
  • repr devient "1" attaché à "01", donc "101".

Il n'y a pas de quatrième passage dansla boucle, puisque val vaut 0. On passe donc à la suite et le résultat vaut "101".

Exercice

  • Vérifiez que si on lance l'algorithme et qu'on répond "61" puis "8", le résultat vaut 75 (en base octale).
  • Vérifiez que si on lance l'algorithme et qu'on répond "176" puis "16", le résultat vaut AA (en base hexadécimale).

D'autres bases pour les octets[modifier | modifier le wikicode]

La valeur est égale à .

Il est assez facile de repérer une faute de frappe quand on écrit 176, quand on se relit. Cependant, une faut de frappe telle que 10101110 au lieu de 10101010 peut passer plus facilement inaperçue. Et le risque augmente avec la longueur des nombres.

Remarquons que , cependant que . L'erreur est plus évidente à repérer en codage décimal.

Base hexadécimale (16)[modifier | modifier le wikicode]

On utilise très souvent la base hexadécimale pour représenter les octets, c'est à dire les nombres binaires à 8 chiffres, de 00000000 à 11111111. En effet, seize est égal à deux puissance quatre : autrement dit, chaque chiffre hexadécimal correspond directement à quatre chiffre binaires, sans erreur possible.

, cependant que . L'erreur est plus évidente à repérer en codage hexadécimal, et en plus, elle montre tout de suite que l'erreur se situe dans les quatre chiffre binaires de poids faible (à droite du nombre).

N.B. : en base hexadécimale, les chiffres sont 0123456789ABCDEF.

base octale (8)[modifier | modifier le wikicode]

De même que la base hexadécimale est très pratique pour exprimer des nombres binaires de quatre ou huit chiffres, la base octale va bien pour exprimer des nombres binaires de 3, 6, 9 ou 12 chiffres : en effet, huit est égal à deux à la puissance 3.

N.B. : en base octale, les chiffres sont 01234567.

Les opérations booléennes[modifier | modifier le wikicode]

Savoirs :

Présentation des opérations booléennes de base (et, ou, non, ou-exclusif).

Capacités :

Exprimer des opérations logiques simples par combinaison d'opérateurs de base.

Observation :

On découvre les opérations logiques de base à l'aide d'exercices simples et on met en évidence ces opérations dans les mécanismes de recherche. En parallèle avec les séances d'algorithmique, on peut expliquer le principe d'addition de deux octets.

Logique à deux états[modifier | modifier le wikicode]

On appelle « logique à deux états », ou logique booléenne, un système d'opérations qu'on peut faire sur des objets qui ne peuvent prendre que deux valeurs, appelées faux/vrai ou 0/1.

Schéma de brochage du compteur asynchrone décimal TTL 7490.

Les circuits logiques à deux états sont nombreux dans un ordinateur, il en existe plusieurs normes. Par exemple, selon le standard TTL, la valeur 0 est définie par un tension électrique comprise entre 0 et 0,5 V, la valeur 1 est définie par une tension comprise entre 2,4 et 5 V. On arrive à garantir que ces valeurs de tensions soient respectées en concevant correctement les montages logiques :

  • en contrôlant le courant maximal demandé à chaque porte logique ;
  • en utilisant une horloge pour déterminer à quel moment les valeurs logiques sont bien établies.

Circuits logiques CMOS[modifier | modifier le wikicode]

Le standard CMOS est plus récent que le standard TTL. Il est basé sur l'utilisation de transistors Complémentaires utilisant une technologie Metal-Oxyde-Semiconducteur (d'ou l'acronyme CMOS).

Coupe schématique d'un transistor à effet de champ MOS à canal dopé N.

Un transistor MOS peut être considéré comme un petit barreau de semi-conducteur (en silicium dopé), avec deux extrémités nommées drain (D) et source (S), dont la conductivité électrique est contrôlée par une électrode nommée la porte ou la grille (G) : cette électrode métallique est placée très près du barreau, elle n'en est séparée que par film isolant en oxyde de silicium très fin (quelques nm).

Pour le standard CMOS, la valeur FAUSSE (0) est définie par une tension comprise entre 0 V et la moitié de la tension d'alimentation, la valeur VRAIE (1) est définie par une tension coprise entre la 0,5 fois et une fois la tension d'alimentation. La tension d'alimentation peut varier entre 3 et 18 V, ce qui facilite l'emploi de ces circuits électroniques dans divers montages.

Autres circuits logiques[modifier | modifier le wikicode]

Il existe d'autres circuits logiques que les circuits logiques à deux états, par exemple des circuits dont la sortie peut être « fausse », « vraie » ou en haute impédance (ils se comporte alors comme s'ils étaient débranchés du circuit).

Opération booléenne NON[modifier | modifier le wikicode]

L'opération NON est ue opération unaire, c'est à dire à un seul opérande.

(NON a) est VRAI si A est FAUX; (NON a) est FAUX si a est VRAI.

(NON a) se note

Table de vérité du NON[modifier | modifier le wikicode]

0 1
1 0

Réalisation d'une porte NON avec un transistor MOS à effet de champ[modifier | modifier le wikicode]

Le barreau semi-conducteur entre drain et source peut changer de conductivité électrique :

  • quand la tension électrique entre grille et source est faible (valeur logique 0 ou FAUX), le "barreau" entre drain et source est isolant, on peut le considérer comme non existant dans le circuit électrique ;
  • quand la tension électrique entre grille et source est importante (valeur logique 1 ou VRAI), le "barreau" entre drain et source est conducteur, on peut le considérer comme un fil électrique.

Il est donc possible de réaliser un simple porte NON à l'aide d'un transistor et d'une résistance électrique. Voici un schéma qui montre comment, avec un signal logique 0 à l'entrée d'un tel montage, on obtient en sortie un signal de valeur logique 1 :

FET-g0V.svg FET-g0V-equiv.svg
la tension est nulle, le transistor est isolant tout se passe comme si le transistor n'était pas là, la sortie est reliée au pôle positif à travers la résistance

Le schéma suivant montre qu'avec un signal logique 1 à l'entrée du montage, on obtient en sortie un signal de valeur logique 0 :

FET-g5V.svg FET-g5V-equiv.svg
la tension est égale à , le transistor est conducteur on peut le remplacer par un fil électrique, la résistance n'intervient plus

Remarque : dans les circuits logiques CMOS, la résistance est remplacée par un autre transistor MOS dont le comportement est complémentaire : ça symétrise mieux le comportement des portes logiques.

Opération booléenne OU[modifier | modifier le wikicode]

le résultat de (a OU b) est VRAI si et seulement si plus d'une valeur boolénnes a et b sont VRAIES (une seule VRAIE, ou les deux VRAIES en même temps).

(a OU b) se note :

Table de vérité du OU[modifier | modifier le wikicode]

0 0 0
0 1 1
1 0 1
1 1 1

Réalisation d'une porte OU avec des transistors MOS[modifier | modifier le wikicode]

Le circuit ci-dessus fabrique à partir des signaux d'entrée et un signal intermédiaire (à l'intérieur du circuit), puis un signal de sortie , par action d'un transistor monté en porte NON.

On peut montrer que , ou, noté autrement, . Comme est la négation de et que la double négation revient à une copie en logique binaire, .

Exercice : dessiner le schéma d'une porte "OU NON", réalisée à l'aide de transistors MOS canal N et de résistances. La table de vérité du "OU NON" est la suivante :

0 0 1
0 1 0
1 0 0
1 1 0

Opération booléenne ET[modifier | modifier le wikicode]

le résultat de (a ET b) est VRAI si et seulement si les deux valeurs boolénnes de a et b sont VRAIES en même temps.

(a ET b) se note : ou encore

La table de vérité faux/vrai de l'opérateur booléen ET est exactement identique à la la table de multiplication de deux chiffres binaires.

Table de vérité du ET[modifier | modifier le wikicode]

0 0 0
0 1 0
1 0 0
1 1 1

autre présentation : table à deux entrées.

F V
F F F
V F V

la table à deux entrées correspond point par point à la table de multiplication en binaire :

0 1
0 0 0
1 0 1

Exercice : trouver un schéma d'une porte ET réalisée à l'aide de transistors MOS canal N et de résistances.

Opération booléenne OU EXCLUSIF[modifier | modifier le wikicode]

la valeur de est VRAIE si et seulement si une seule des valeurs ou est VRAIE (donc l'autre est fausse, en même temps).

Table de vérité du OU EXCLUSIF[modifier | modifier le wikicode]

0 0 0
0 1 1
1 0 1
1 1 0

Équation logique du OU EXCLUSIF[modifier | modifier le wikicode]

Cette opération peut se formuler comme : « a est VRAI ET b est FAUX, ou a est FAUX et B est VRAI ».

  • On peut traduire « a est VRAI ET b est FAUX » par  :
  • on peut traduire « a est FAUX et B est VRAI » par .

Donc l'équation logique de a OU EXCLUSIF b est :

Exercices sur les opérateurs logiques[modifier | modifier le wikicode]

N.B. : le symbole est celui de l'opération OU EXCLUSIF.

Exercice 1 :

Remplissez les cases de ce tableau de vérité :

0 0 1 1
0 1 1 0
1 0
1 1

Exercice 2 :

Montrez que est une autre expression possible pour OU EXCLUSIF .

Exercice 3 :

Donnez une expression logique pour l'opération "TRUC" dont la table de vérité est ci-dessous :

0 0 1
0 1 0
1 0 1
1 1 1

Montrer que l'opération "TRUC" peut aussi s'interpréter comme "a IMPLIQUE b", ou "si a est VRAI, alors b est VRAI".

Combinaisons de portes logiques[modifier | modifier le wikicode]

On peut schématiser les portes logiques comme des rectangles branchés à des fils électriques. Par convention, on place les fils de sorties des portes logiques du même côté, en général à droite quand c'est possible. Une inscription sur le rectangle rappelle la fonction de la porte logique.

On peut se procurer une « boîte à outils » contenant des portes logiques, par exemple en achetant des circuits intégrés logiques de la série CMOS, ou TTL. Les schémas de portes logiques ne contiennent pas les fils d'alimentation électrique qui permettent aux portes de fonctionne. Bien évidemment, quand on réalise un montage réel avec les portes logiques, il convient de bien brancher les fils d'alimentation.

Notre boîte à outils « de départ »[modifier | modifier le wikicode]

Notre boîte à outil de départ contient les portes ET, OU et NON. La sortie de chaque porte est du côté arrondi du rectangle.

porte ET porte OU porte NON

Exercices avec des portes logiques : quatre pour une[modifier | modifier le wikicode]

Trouvez la table de vérité de la porte logique obtenue par des combinaisons ci-dessous :

Cette table de vérité permet-elle de créer une nouvelle porte pour notre « boîte à outils » ?

Exercices avec des portes logiques : OU EXCLUSIF[modifier | modifier le wikicode]

Rappeler une formule logique utilisant les opérateurs ET, OU, NON, qui permet d'obtenir l'opération OU EXCLUSIF.

Câbler cette formule logique en utilisant des portes ET, OU, NON. À partir de là, on peut considérer qu'on a rajouté une porte OU EXCLUSIF à notre boîte à outils. On l'étiquettera "OUEX".

Exercices avec des portes logiques : demi-additionneur à 1 bit[modifier | modifier le wikicode]

Voici une table d'addition pour le système binaire :

0 1
0 0 1
1 1 0

L'étoile en exposant, dans la case en bas à droite de la table, signifie qu'il y a une retenue : « un et un fait zéro et je retiens un ».

Voici un schéma de montage qui additionne deux bits et (les chiffres binaires sont des Binary digITs), calcule le bit de somme et le bit de retenue :


Peut-on associer des montages de ce genre pour faire un additionneur qui traite les deux fois 8 bits de deux octes à additionner, d'un seul coup ? Justifier le nom "demi-additionneur" de ce circuit.

Exercices avec des portes logiques : additionneur complet[modifier | modifier le wikicode]

On trouve, publié dans Wikipedia, un schéma d'additionneur ; celui-ci se schématise comme ceci, avec notre convention de représentation des portes logiques :


Complétez la table de vérité de cette porte à trois entrées et deux sorties :

a b retenue entrante somme retenue sortante
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

Vérifier que cette porte est effectivement utilisable pour additionner des mots de plusieurs bits, en en associant autant que nécessaire.

Exercices de programmation[modifier | modifier le wikicode]

Recherche d'entiers pairs non divisibles par trois[modifier | modifier le wikicode]

On veut la liste de tous les nombres pairs et non divisibles par trois compris entre 1 et 100. On utilisera l'opération "modulo", qui permet d'obtenir le reste de la division d'un nombre par un autre.

Soit la proposition "le nombre est pair". Cette proposition peut se transcrire par l'expression .

x "modulo 2" est nul, signifie que le reste de la division de x par 2 est nul.

Soit la proposition "le nombre n'est pas divisible par 3". On peut la transcrire par l'expression

On peut donc utiliser l'algorithme suivant pour trouver la liste des nombres pairs non divisibles par trois :

debut
  entier i
  liste l := []
  booleen a
  booleen b
  pour i dans intervalle [1,100]
    a := (x mod 2 = 0)
    b := (x mod 3 = 0)
    si a et non b alors
      l := ajout(l, x)
    fin si
  fin pour
  resultat := l
fin

Programmer cet algorithme dans un ou plusieurs langages et tester les programmes.

Recherche de nombres premiers[modifier | modifier le wikicode]

Problème facile

La liste des nombres premiers inférieurs à 10 est : 2, 3, 5 et 7

Écrire un algorithme qui permet de trouver la liste des nombres premiers (c'est à dire divisibles seulement par eux-même et par 1) entre 11 et 49. Programmer l'algorithme et le tester.

Problème difficile

On donne un nombre, trouver la liste des nombres premiers plus petits que celui-ci.

Écrire un algorithme, programmer, tester.

Numérisation des données[modifier | modifier le wikicode]

Savoirs :

L'ordinateur manipule uniquement des valeurs numériques. Une étape de numérisation des objets du monde physique est donc indispensable.

Capacités :
  • Coder un nombre, un caractère au travers d'un code standard, un texte sous forme d'une liste de valeurs numériques.
  • Numériser une image ou un son sous forme d'un tableau de valeurs numériques.
    • Modifier format, taille, contraste ou luminance d'images numériques.
    • Filtrer et détecter des informations spécifiques.
    • Créer une image à l'aide d'un logiciel de modélisation.
Observation :

Il est ici utile de faire référence à des notions technologiques introduites à propos des architectures matérielles. Les images et les sons sont choisis comme contexte applicatif et sont manipulés via des logiciels de traitement ou de synthèse. Le traitement numérique de la lumière et du son est en lien avec les principes physiques sous-jacents, qu'il est utile d'évoquer au moment voulu.

Signal analogique, signal numérique[modifier | modifier le wikicode]

Un signal analogique se présente souvent sous forme d'une tension électrique qui varie avec le temps. On dit que le signal est analogique quand n'importe quelle valeur de la tension électrique a de la signification. Un signal numérique est aussi une tension qui varie avec le temps, mais seules quelques valeurs de tension ont une signification précise.

Numérisation d'un signal[modifier | modifier le wikicode]

Un convertisseur analogique numérique (CAN) reçoit en entrée un signal analogique (par exemple,le signal électrique venu d'un microphone,qui représente les variations de la pression acoustique), et un signal d'horloge. À chaque top de l'horloge, le convertisseur CAN doit présenter sur son bus de sortie une valeur binaire qui représente au mieux le signal analogique d'entrée.

Pour obtenir une numérisation de haute qualité, il faut :

  • un signal d'horloge assez rapide : le nombre de tops d'horloge à chaque seconde s'appelle la fréquence d'échantillonnage ; elle doit être plus rapide que les variations typiques du signal analogique à numériser.
  • une résolution suffisante pour les données en sortie : si le bus de sortie possède bits, alors il peut représenter valeurs numériques différentes.

Un exemple de numérisation[modifier | modifier le wikicode]

width=5cm width=5cm width=5cm
Graphique d'un signal analogique Numérisation du signal Graphique d'un signal numérique

Dans les exemples présentés ci-dessus, la numérisation du signal analogique a été réalisée en distinguant 32 valeurs différentes (et 32 seulement : codage possible sur 5 bits) dans l'intervalle compris entre -1 V et +1 V. Un millier d'échantillons de du signal analogique ont été évalués pour effectuer la numérisation.

Exercice : analogique/numérique[modifier | modifier le wikicode]

  • À quoi ressemblerait le signal numérique si celui-ci était codé sur 2 bits, c'est à dire que 4 valeurs différentes seulement du signal peuvent exister ?
  • Supposons que le signal numérique ait une forte résolution (par exemple 10 bits, ce qui permet 1024 valeurs significatives distinctes), mais que les échantillons soient peu nombreux. À quoi ressemblerait le signal numérisé s'il n' avait que deux échantillons numérisés pendant la durée représentée sur le graphique ?... et s'il n'y avait qu'un seul échantillon ?

Images numériques[modifier | modifier le wikicode]

Les appareils photo et les caméras les plus utilisés maintenant fonctionnent avec des capteurs CCD, qui sont des matrices formées de petits rectangles sensibles à la lumière. L'électronique associé au capteur CCD échantillonne sur commande les valeur des charges électriques apparues sur chaque petit rectangle, qui dépend de la lumière reçue. La valeur de chacune de ces charges électriques est numérisée, et un tableau de valeurs numériques est enregistré dans une mémoire.

Les appareils de bonne qualité utilisent de grandes quantités de mémoire, quand les images et les vidéos sont conservées sans chercher à comprimer les données (formats de type "RAW"). De nombreux appareils grand public compriment systématiquement les données afin de pouvoir en emmagasiner plus dans la même mémoire.

Comparaison entre formats de fichiers pour des images[modifier | modifier le wikicode]

Format de fichier BMP XPM PNG (couleurs indexées) JPG
principales caractéristiques non comprimé, 32 bits par pixel non comprimé, indexé, fichier texte lisible comprimé, sans perte comprimé, avec des pertes
Taille en kilo-octets 16,5 4,5 0,6 2,5

L'image choisie pour le tableau ci-dessus mesure pixels, elle comporte 4096 pixels indépendants. On peut remarquer que les tailles de certains fichiers non-comprimés sont prévisibles :

  • format BMP : Présence d'un en-tête, plus 4 octets par pixels : , pour un total de 16,6 kO.
  • format XPM : présence d'un en-tête, plus un octet par pixel : , pour un total de 4,5 kO.

Les systèmes de compression ont des efficacités variables selon le type d'image à encoder. Comme l'image choisie a un nombre limité de couleurs (huit) la compression PNG réussit très bien : le fichier pèse moins d'un kilo-octet. Le fichier JPG pèse plus du double. Observez bien les pixels de ce dernier fichier : on distingue des altérations.

Les composantes R, V, B d'une image en couleur[modifier | modifier le wikicode]

Les écran et les vidéoprojecteurs connectés aux ordinateurs utilisent la synthèse additive pour créer les palettes de couleurs qui nous sont présentées.

En synthèse additive, les couleurs primaires sont rouge, vert, bleu (RVB en français, RGB en anglais).

Ci dessous, voici une table de synthèse additive pour les couleurs primaires. Les notations rgb(x,y,z) sont des triplets de valeurs permettant de donner la composition d'une lumière. Les valeurs de x, y et z sont dans un intervalle de 0 (le minimum) à 255 (le maximum). Le couleurs primaires correspondent aux notation suivantes :

  • R rgb(255,0,0)
  • V rgb(0,255,0)
  • B rgb(0,0,255)
R V B
R J rgb(255,255,0) M rgb(255,0,255)
V J rgb(255,255,0) C rgb(0,255,255)
B M rgb(255,0,255) C rgb(0,255,255)

Le couleurs J, M, C sont respectivement le jaune, le magenta et le cyan. Le noir (N rgb(0,0,0)) est l'absence de lumière (ni R, ni V, ni B), le blanc (Bl rgb(255,255,255)) s'obtient en additionnant R, V et B.

Transformer une image par calcul[modifier | modifier le wikicode]

On peut représenter les images dans un ordinateur par un tableau rectangulaire de nombres représentant chacun un pixel de l'image. Il est quelque fois commode de considérer trois tableaux de même dimension, pour les trois composantes RVB de l'image.

Des calculs appliqués aux cases du tableau rectangulaire qui représente une image permettent de créer des images nouvelles aux propriétés intéressantes.

On peut par exemple remplacer le chiffre dans chaque case par une moyenne (avec coefficients) des chiffres de cases voisines. En choisissant bien les coefficients, on peut obtenir des opérations nommées « filtres », pour simuler un flou, un flou cinétique, pour accentuer les détails, ou pour extraire les bords d'objets contrastés.

Un exemple d'algorithme[modifier | modifier le wikicode]

debut
  {les données de l'images sont dans la table t}
  largeur, hauteur := taille(t)
  t1 := nouvelle table(hauteur,largeur)
  pour y dans intervalle(0,hauteur)
    pour x dans intervalle(0,largeur)
      t1[y,x] := traitement (t, y, x)
    fin pour
  fin pour
  resultat := t1
fin

Les données de l'image de départ se présentent sous forme d'une table t, organisée en hauteur lignes et largeur colonnes.

Une nouvelle table t1 de même dimension est créée pour contenir la nouvelle image.

Deux boucles indicées par les variables x et y permettent de parcourir chaque pixel de la table t1, qui résulte d'un calcul basé sur les valeurs contenues dans la table t et les coordonnées (x,y). Le calcul est réalisé par la fonction nommée traitement.

Les implémentations ci-dessous utilisent une petite table nommée « filtre » contenant un jeu de coefficients. Une moyenne est faite des valeurs de pixels de la table t, en utilisant les coefficients du filtre. Cette méthode permet entre autres de flouter l'image de départ.

Exemple en Python[modifier | modifier le wikicode]

  1 #!/usr/bin/python
  2 # -*- coding: utf-8 -*-
  3 
  4 import Image
  5 
  6 ##########################################################
  7 #   un filtre pour obtenir un peu de flou "gaussien"     #
  8 ##########################################################
  9 fFlou=[
 10     [0.5,0.7,0.5],
 11     [0.7,1.0,0.5],
 12     [0.5,0.7,0.5],
 13     ]
 14 
 15 #############################################################
 16 #   un filtre pour mettre en valeur les zones contrastées   #
 17 #############################################################
 18 fContraste=[
 19     [-0.05,-0.2,-0.05],
 20     [-0.2,1.01,-0.2],
 21     [-0.05,-0.2,-0.05],
 22     ]
 23 
 24 ##########################################################
 25 #   implémentation de l'algorithme suggéré plus haut     #
 26 ##########################################################
 27 def appliqueFiltre(t,f):
 28     """
 29     Applique un filtre sur un tableau d'image.
 30     Les valeurs du filtre sont des coefficients utilisées pour faire des
 31     moyennes pondérées entre pixels voisins
 32     @param t tableau encodant une image en gris
 33     @param f un filtre (tableau plus petit)
 34     @return un tableau de la même taille que t, après passage du filtre
 35     """
 36     h=len(t)     #hauteur de t
 37     w=len(t[0])  #largeur de t
 38 
 39     result=[]
 40     for y in range(h):
 41         line=[]
 42         for x in range(w):
 43             line.append(traitement(t, y, x, f))
 44         result.append(line)
 45     return result
 46 
 47 ##########################################################
 48 #   implémentation de la fonction "traitement"           #
 49 ##########################################################
 50 def traitement(t, y, x, f):
 51     """
 52     calcule la valeur d'un pixel nouveau en utilisant une image originale
 53     et un jeu de coordonnées. Une table de coefficients est utilisée.
 54     @param t la table del'image originale
 55     @param y désigne une ligne dans l'image
 56     @param x désigne une colonne dans l'image
 57     @param f une table de coefficients(un filtre)
 58     @return une valeur utilisable pour créer un nouveau pixel
 59     """
 60     h=len(f)     #hauteur de f
 61     w=len(f[0])  #largeur de f
 62     ifx=range(-w/2,(w+1)/2) # intervalle de même largeur que f centré sur 0
 63     ify=range(-h/2,(h+1)/2) # intervalle de même hauteur que f centré sur 0
 64     dfx=w/2 # décalage horizontal de f
 65     dfy=h/2 # décalage vertical de f
 66 
 67     h=len(t)     #hauteur de t
 68     w=len(t[0])  #largeur de t
 69     s=0
 70     n=0
 71     for iy in ify:
 72         for ix in ifx:
 73             jx=ix+x # coordonnées à prendre encompte dans
 74             jy=iy+y # le tableau de départ t
 75             kx=ix+dfx # coordonnées dans le filtre
 76             ky=iy+dfy # nécessairement positives ou nulles
 77             if jx in range(w) and jy in range(h):
 78                 # si les coordonnées sont dans le tableau t
 79                 coef=f[ky][kx]
 80                 n+=coef
 81                 s+=t[jy][jx]*coef
 82     return s/n
 83 
 84 ##########################################################
 85 #   quelques fonctions utilitaires ci-dessous, pour      #
 86 #   fabriquer des tables explicites à partir d'images    #
 87 #   en utilisant le module python Image.                 #
 88 ##########################################################
 89 def troisCanaux(filename):
 90     """
 91     Ouvre un fichier image et extrait troix canaux de couleur de l'image
 92     du fichier
 93     @param filename le nom du fichier à ouvrir
 94     @result un triplet d'images en niveau de gris pour rouge, vert et bleu
 95     """
 96     im=Image.open(filename)
 97     im=im.convert("RGB")
 98     return im.split()
 99 
100 def canalVersTable(canal):
101     """
102     récupère lesdonnées d'un canal de type L (valeurs de gris)
103     dans un tableau
104     @param canal un canal de gris
105     @return un tableau avec les valeurs organisées dedans
106     """
107     w,h=canal.size
108     result=[]
109     for y in range(h):
110         line=[]
111         for x in range(w):
112             line.append(canal.getpixel((x,y)))
113         result.append(line)
114     return result
115 
116 def tableVersCanal(t):
117     """
118     convertit une table rectangulaire de nombres
119     vers un canal de valeurs de gris d'image
120     """
121     h=len(t)
122     w=len(t[0])
123     result=Image.new("L",(w,h))
124     for y in range(h):
125         for x in range(w):
126             result.putpixel((x,y),t[y][x])
127     return result
128 
129 
130 
131 ########################################################
132 #  programme à effectuer quand ce fichier est invoqué  #
133 #  directement. On peut invoquer ce fichier suivi du   #
134 #  nom d'un fichier d'image, ou donner le nom d'un     #
135 #  fichier d'image interactivement pendant que ce      #
136 #  programme fonctionne.                               #
137 ########################################################
138 import sys, os.path
139 if __name__ == "__main__":
140     if len(sys.argv)>1:
141         nomFichier=sys.argv[1]
142     else:
143         nomFichier=raw_input("Tapez le nom d'un fichier d'image")
144     r, v, b = troisCanaux(nomFichier)
145     t=canalVersTable(r)
146     t1=appliqueFiltre(t,fFlou)
147     r1=tableVersCanal(t1)
148     r.show()
149     raw_input("Voici le canal R de %s. Appuyez sur Entrée" %nomFichier)
150     r1.show()
151     raw_input("Voici l'image obtenue après application du filtre de flou. Appuyez sur Entrée")
152     t2=appliqueFiltre(t,fContraste)
153     r2=tableVersCanal(t2)
154     r2.show()
155     raw_input("Voici l'image obtenue après le filtre d'accentuation. Appuyez sur Entrée")
156     t3=appliqueFiltre(t1,fContraste)
157     r3=tableVersCanal(t3)
158     r3.show()
159     raw_input("Enfin, on applique le filtre de flou après l'autre. Appuyez sur Entrée")
160 
161     # enregistre les nouvelles images.
162     path, ext = os.path.splitext(nomFichier)
163     nf="%s%d%s" %(path, 0, ext)
164     r.save(nf)
165     print "fichier sauvé :", nf
166     nf="%s%d%s" %(path, 1, ext)
167     r1.save(nf)
168     print "fichier sauvé :", nf
169     nf="%s%d%s" %(path, 2, ext)
170     r2.save(nf)
171     print "fichier sauvé :", nf
172     nf="%s%d%s" %(path, 3, ext)
173     r3.save(nf)
174     print "fichier sauvé :", nf
Exécution du programme[modifier | modifier le wikicode]

Voici une trace de l'exécution de ce programme dans une console :

$ ./filtreImages.py logo.png 
Voici le canal R de logo.png. Appuyez sur Entrée
Voici l'image obtenue après application du filtre de flou. Appuyez sur Entrée
Voici l'image obtenue après le filtre d'accentuation. Appuyez sur Entrée
Enfin, on applique le filtre de flou après l'autre. Appuyez sur Entrée
fichier sauvé : logo0.png
fichier sauvé : logo1.png
fichier sauvé : logo2.png
fichier sauvé : logo3.png

L'image d'origine est celle- ci : Pidgin-logo-orig.png

Voici les images affichées :

  • le canal R de l'image : Pidgin-logo0.png
  • le canal R de l'image après application du filtre de flou : Pidgin-logo1.png
  • le canal R de l'image après application du filtre d'accentuation : Pidgin-logo2.png
  • le canal R de l'image après application des deux filtres : Pidgin-logo3.png

Exemple en Javascript[modifier | modifier le wikicode]

Utilisation d'un logiciel de traitement d'image[modifier | modifier le wikicode]

Les formats de données pour les ordinateurs[modifier | modifier le wikicode]

Savoirs :

Les données numériques sont agencées de manière à en faciliter le stockage et le traitement. L'organisation des données numériques respecte des formats qui sont soit des standards de fait, soit des normes.

Capacités :
  • Identifier quelques formats de documents, d'images, de données sonores.
  • Choisir un format approprié par rapport à un usage ou un besoin, à une qualité, à des limites.
Observation :

Le choix d'un format approprié pose le problème de l'interopérabilité, qui est le fait d'assurer un usage sans restriction des mêmes données sur un système différent.

Pour représenter une donnée conséquente, comme une image, un son, une vidéo, un texte structuré, un plan d'architecte ... il existe plus d'une façon d'organiser les valeurs numériques qui les représentent dans un fichier. Chaque programmeur, chaque entreprise qui produit du logiciel, peuvent choisir d'utiliser un format particulier.

Avantages d'utiliser un format non standardisé[modifier | modifier le wikicode]

Dans un premier temps, on peut penser que l'utilisation d'un format inconnu des autres personnes permet de se réserver l'exclusivité de l'exploitation d'un programme.

Cette idée n'est peut-être pas si forte : durant la deuxième guerre mondiale, des formats « non standardisés » très sophistiqués ont été utilisés pour l'échange entre armées allemandes. Les machines Enigma, fleurons de la technologie de cryptage, n'ont pas empêché des mathématiciens anglais, menés par Allan Turing, de casser les codes utilisés.

Avantages d'utiliser un format standardisé[modifier | modifier le wikicode]

Quand un format standard est utilisé, les programmeurs peuvent se focaliser vers le développement de nombreuses applications travaillant avec ce format-là, et les échanges de données sont facilités. Si on veut protéger une donnée confidentielle encodée dans un format standard, on peut utiliser une méthode de chiffrement générique ; nous disposons de méthodes de chiffrement fortes, elles aussi standardisées.

Formats ouverts[modifier | modifier le wikicode]

Un exemple de format fermé : le DOC[modifier | modifier le wikicode]

Il existe des standards de fait, ça a été le cas du format DOC, utilisé par la compagnie Microsoft pour le format texte structuré. Ce format n'est pas spécifié dans un document public, ce qui n'a pas empêché de créer des lecteurs du format DOC pour les concurrents. Il y a plus d'un exemple de fichier DOC enregistré avant 1995 que le logiciel Word de Microsoft ne savait pas ouvrir en l'an 2000, et qu'on a pu récupérer à l'aide du logiciel StarOffice (fabriqué par une société concurrente), qui comportait un filtre d'importation fonctionnant correctement.

Le format GIF[modifier | modifier le wikicode]

La spécification du format GIF était publiée, mais ce format n'était pas ouvert tant que son utilisation était limitée par la législation des brevets. Le dernier brevet portant sur le format GIF s'étant éteint en 2001, on peut le considérer comme ouvert maintenant.

Liste de formats ouverts[modifier | modifier le wikicode]

Un format ouvert, c'est un format de fichier dont on peut trouver une spécification claire et complète, accessible librement à tous.

Utiliser des formats ouverts, c'est s'assurer que les données fabriquées aujourd'hui resteront lisibles dans le futur.

domaine d'utilisation nom desformats
représentation d'images GIF, PNG, JPG, TIFF, TGA, XBM, XPM, MNG, ICO, PPM
représentation de sons WAV, RIFF, FLA, AU, OGG
représentation de vidéos Theora/Vorbis, WebM
représentation de textes structurés TXT, RTF, ODT, DocBook XML, HTML, DOCX à condition que le logiciel n'utilise pas certaines « extensions »
Représentation de pages 2D PS, PDF

Exercices[modifier | modifier le wikicode]

Formats pour traiter le texte[modifier | modifier le wikicode]

Visitez le site de l'organisation Gutenberg et téléchargez une oeuvre du domaine public de taille conséquente, à un format que vous pourriez travailler avec un traitement de texte : par exemple, le tome I de la Légende des siècles de Victor Hugo.

Ouvrez ce fichier, puis enregistrez-le aux formats suivants :

  • TXT : format texte pur
  • RTF :format de texte enrichi
  • ODT : format texte OpenDocument
  • DOC (Word 97) : format texte de Microsoft Word
  • DOCX : format texte actuel de Microsoft Word

Ensuite,

  • comparez les tailles de ces fichier
  • essayez de les visualiser avec un simple pageur, qui permet de présenter à l'écran la suite de codes composant le fichier, en format hexadécimal et/ou décodé selon le code ASCII.
  • essayez de décompresser les fichiers dont le code est « illisible » directement avec le pageur, puis examinez et décrivez lz résultat.

Note:
faites votre travail dans un répertoire séparé, pour faciliter la gestion des divers fichiers.

Formats pour traiter le son[modifier | modifier le wikicode]

Trouvez un site qui permette de télécharger de la musique sous une licence Creative Commons, et récupérez un fichier représentant quelques minutes de musique au plus.

Ouvrez ce fichier à l'aide d'un éditeur de son, puis notez tous les renseignements techniques au sujet de l'encodage des sons qui y sont contenu (résolution utilisée, fréquence d'échantillonnage).

Sélectionnez un extrait de moins de trente secondes de ce fichier et jetez le reste. Enregistrez cet extrait aux formats WAV, OGG, MP3. Si possible essayez de varier les paramètres de compression quand ceux-ci sont disponibles. Comparez les tailles des fichiers enregistrés.

Fermer l'éditeur de musique, puis écouter avec attention le même extrait à l'aide d'un logiciel de rendu musical. Y a-t-il des différences qualitatives entre les écoutes des divers formats que vous aviez enregistrés ?

Formats pour traiter des images[modifier | modifier le wikicode]

À l'aide d'une webcam, faites un auto-portrait, puis recadrez-le à l'aide d'un logiciel de traitement d'image, pour faire une sorte de photo d'identité. Normalisez la taille de l'image afin que sa largeur fasse environ 100 pixels (un peu comme pour faire un avatar). Ensuite, enregistrez cette photo aux formats suivants : PNG, XPM, JPG, GIF.

Des paramètres particuliers sont-ils applicables pour l'enregistrement dans certains formats ? Notez bien les paramètres choisis le cas échéant.

Après fermeture du logiciel de traitement d'image, comparez les tailles des divers fichiers. Voyez le contenu du fichier XPM à l'aide d'un éditeur de texte, comparez à d'autres formats (au format texte).

Rouvrez les images des divers fichiers et comparez finement les différences existant entre elles.

En supplément : jusqu'à quel niveau de (basse) qualité pouvez-vous dégrader votre portrait au format JPG, avant de devenir moins reconnaissable ?

À la recherche de formats ouverts[modifier | modifier le wikicode]

Trouvez quels formats sont utilisables pour représenter un plan d'architecte.

Parmi ces formats, lequels sont ouverts ? Justifiez votre sélection.

Compression des données[modifier | modifier le wikicode]

Savoirs :
  • Notion de compression de données.
  • Compression avec et sans perte d'information.
Capacités :

Utiliser un logiciel de compression.

Observation :

On met en évidence l'effet de la compression d'une image ou d'un son en comparant deux systèmes de compression (avec ou sans perte).

La plupart des données qui intéressent les humains sont très redondantes, si bien qu'on sait mettre au point des façons d'en compresser efficacement la représentation numérique.

Voici un exemple de fichier « significatif », enregistré sans compression et avec compression :

Description du fichier taille du fichier
Le fichier non comprimé (image de au format BMP) 22934 octets
Le fichier comprimé (image de au format GIF) 884 octets
Le fichier comprimé (image de au format PNG) 225 octets
Le fichier comprimé (image de au format JPG) 1443 octets

L'information dans ce fichier d'image est très redondante : par exemple, la phrase en langue française ...

Un rectangle de 100 x 150 pixels accolés de gauche à droite, bleu, blanc, rouge, ne contient que 80 octets, ce qui bien encore mieux que l'encodage PNG... et on pourrait certainement faire encore mieux... Comment ?

Exercice : examiner un fichier comprimé[modifier | modifier le wikicode]

Récupérez le fichier (267 octets), et voyez comment il est comprimé (utilisez un logiciel capable de prendre en charge plusieurs standards de compression). Quelle est la structure de ce fichier après décompression ?

Comparez-le au fichier (587 octets). Essayez de visualiser ce fichier à l'aide d'un logiciel approprié au format SVG (Standard Vector Graphics). La compression au format SVGZ peut-elle être considérée comme efficace ?

Notion de compression de données[modifier | modifier le wikicode]

Pour comprimer un fichier, on peut faire en sorte d'y repérer des redondances, puis d'encoder les parties redondantes d'une façon plus efficace.

Exemple simple 1[modifier | modifier le wikicode]

proposez une façon simple d'encoder le texte suivant :

BBBBBBBBBBWWWWWWWWWWRRRRRRRRRR

qui mesure 30 octets, en moins de 30 octets.

Une fois que le texte est comprimé, de quoi a-t-on besoin pour le décompresser, c'est à dire pour le rétablir à l'identique ?

Exemple simple 2[modifier | modifier le wikicode]

112233445566778899

est une version comprimée du texte d'origine suivant :

122333444455555666666777777788888888999999999

devinez une méthode simple pour la décompression. Une fois la méthode trouvée, décompressez le code suivant :

164794581484

Cette méthode de compression/décompression a des inconvénients : est-il possible de deviner facilement si on a affaire à un objet comprimé ou à un objet non comprimé ? ... Qu'obtient-on si on essaie de comprimer le texte « 164794581484 » ?

Quelques points communs de logiciels de compression standards[modifier | modifier le wikicode]

  • les fichiers comprimés à l'aide de ces logiciels contiennent un signe simple permettant de suggérer le type de compression utilisé.
  • les compressions se font souvent en deux temps au moins :
    • repérage de redondances caractéristiques souvent constatées dans le type de fichier qu'on traite le plus souvent (par exemple, pour un texte, présence de certains mots souvent utilisés)
    • utilisation d'algorithmes généraux permettant une bonne compression dans les cas généraux : algorithme de Huffmann par exemple.

Compression avec et sans perte d'information[modifier | modifier le wikicode]

Dans le cas de fichiers décrivant des sons et des images, on peut obtenir d'excellents taux de compression si on admet de perdre quelques informations que les sens humains distinguent difficilement.

Exemple de deux fichiers de même poids, issus du même original[modifier | modifier le wikicode]

Voici deux versions de la même image, la première version est comprimée avec l'algorithme JPG, qui perd des informations, et la deuxième version est comprimée avec l'algorithme PNG qui ne perd pas d'information. On s'est forcé à choisir deux fichiers pesant environ le même nombre d'octets.

fichier image au format JPG (70 kO) fichier image au format PNG (72 kO)

La photo de gauche semble beaucoup plus riche en information que la photo de droite, bien que son fichier soit plus léger de quelques 2 kilo-octets. Cependant, quand on y regarde de plus près, on peut apercevoir des déformations dans laphoto de gauche, qui sont dues au procédé JPG, qui change l'information initiale (et perd irrémédiablement certaines des données).

Mise en évidence de la perte d'information[modifier | modifier le wikicode]

Ci-dessous on a agrandi 8 fois les dimensions d'une petite partie de la photo enregistrée au format JPG : il apparaît de légères déformations, visibles dans la partie verte floue, au voisinage du bord du pétale. Ces déformations n'existent pas dans le fichier PNG (vérifiez-le). On peut aussi examiner l'image d'origine en haute résolution, qui pèse plus de 600 kilo-octets.


agrandissement d'un détail de la photo qui était encodée en JPG fichier image d'origine en haute résolution (format XCF, valide pour le logiciel libre GIMP)

Concluez : avantage/désavantage de la compression avec pertes ?[modifier | modifier le wikicode]

Quelle est la compression préférable pour l'image,

  • quand la place pour les données est limitée ? (exemple :limite à 75 kilo-octets) ;
  • quand la place pour les données est moins strictement limitée ? (exemple : limite à 1 méga-octet).

Structuration et organisation de l'information[modifier | modifier le wikicode]

Savoirs :

On manipule de grandes quantités d'informations. Il est nécessaire de les organiser.

Capacités :

Classer des informations, notamment sous forme d'une arborescence.

Observation :

On peut ici étudier le système d'organisation de fichiers en dossiers. Un ensemble de documents unis par des liens hypertextes fournit un exemple de classement de type graphe.

Imaginez une encyclopédie de cinq mille pages, dont les articles ne seraient pas ordonnés, elle serait difficilement utilisable pour y retrouver un article en particulier.

Les dictionnaires et encyclopédies possèdent une organisation, le classement par ordre alphabétique du mot qui y est défini ou illustré. Cette organisation est cependant insuffisante pour de nombreux exemples de recherches. Comment feriez-vous par exemple, pour trouver rapidement tous les mots du dictionnaire qui s'écrivent en quatre lettres ?

Pour faciliter les recherches dans une encyclopédie, on utilise des index ; il peut exister plus d'un index pour la même encyclopédie, qu'on utilisera dans des circonstances différentes.

Systèmes de classifications efficaces[modifier | modifier le wikicode]

Quand on peut définir une relation d'ordre dans une collection d'articles, on peut trier les articles. S'il y a plus d'une relation d'ordre, c'est préférable de réaliser un index pour chacune des relations. Les index les plus efficaces ont une structure d'arbres binaires.

Exemple trivial de classement[modifier | modifier le wikicode]

Prenons comme « articles » les lettres de l'alphabet, et comme ordre, l'ordre alphabétique.

Un index séquentiel évident est :

 a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z
 1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

On peut préférer un index arborescent :

width=15cm

Supériorité de l'index organisé en arbre[modifier | modifier le wikicode]

Si on veut faire un traitement automatique des informations, on peut se préoccuper de la durée du traitement.

Comparons les durées de classement d'un lettre de l'alphabet tirée au hasard, en supposant que la durée augmente comme le nombre de comparaisons alphabétiques à faire :

  • pour l'index séquentiel, ça peut aller très vite (si on doit classer un A) ou 26 fois plus lentement (si on doit classer un Z). On peut supposer qu'en moyenne, on doit faire 13 comparaisons ;
  • pour l'index arborescent, on doit faire entre 4 et 5 comparaisons (moyenne 4,5).

L'avantage de l'index arborescent devient de plus en plus évident quand on dispose d'un grand nombre de données à classer :

  • pour un index séquentiel, la durée moyenne de classement double quand le nombre de données double. Par exemple pour un million de données, on fait en moyenne un demi-million de comparaisons pour classer un nouvel article.
  • pour un index arborescent, il suffit d'une comparaison de plus chaque fois que le nombre de données est doublé. Pour un million de données, une vingtaine de comparaisons est suffisante !

Organisations en arbre souvent utilisées[modifier | modifier le wikicode]

Systèmes de fichiers : répertoires et fichiers[modifier | modifier le wikicode]

Les disques durs utilisés en 2013 contiennent couramment des centaines de giga-octets, c'est à dire,

  • quelques centaines de films, ou
  • quelques millions de photos,
  • quelques milliards de pages imprimables,
  • etc.

Pour arriver à maintenir de telles collections de données, une simple liste séquentielle est tout à fait inappropriée.

Un système d'arbre est utilisé : les répertoires (ou dossiers) sont les noeuds del'arbre, les fichiers sont les feuilles.

Dans les systèmes de fichiers Unix et Mac OS, un seul arbre permet de regrouper tous les fichiers. Pour Windows, il peut y avoir 26 arbres distincts, correspondant à autant de « lecteurs différents », nommés de A: à Z:.

Les index de bases de données[modifier | modifier le wikicode]

Les systèmes de gestion de base de données relationnelles (MySQL, PostgreSQL, Oracle, Access) permettent de définir des index pour permettre un accès plus rapide aux données. Créer un index est utile pour tous les champs qui peuvent faire l'objet d'une recherche : l'exemple trivial ci-dessus montre qu'un index semble « rentable » dès qu'on a plus de huit articles différents à gérer.


Exercices[modifier | modifier le wikicode]

Compter les fichiers de votre ordinateur[modifier | modifier le wikicode]

Documentez-vous sur la commande find, puis trouvez une façon de compter le nombre de fichiers existant sur le disque dur de votre ordinateur.

Astuces :

  • on peut renvoyer la sortie de find vers un fichier, puis compter les lignes de ce fichier à l'aide d'un éditeur de texte.
  • il est possible d'utiliser la commande wc.

Déterminez la profondeur maximale de l'arbre de votre système de fichiers[modifier | modifier le wikicode]

Cette profondeur peut être trouvée en retraitant le fichier contenant la sortie de la commande find précédente, en comptant le nombre de caractères « séparateurs » de chemin dans les noms de fichier : le slash pour Unix, l'antislash pour Windows ...

Voici une ligne de commande Unix qui permet d'afficher le nombre de répertoires/fichier le long d'un chemin, pour chaque ligne du fichier find.txt qu'on aura fabriqué à l'exercice précédent :

1   cat find.txt | awk -F / '{print NF}'

La commande cat permet de dérouler le contenu d'un fichier ; la barre verticale | sert à « piper » (en mauvais franglais), c'est à dire à « tuyauter » le flux de sortie de la commande cat dans l'entrée standard de la commande awk.

Lisez la page de manuel de la commande awk, pour trouver la signification de l'option "-F /", et la signification de la variable NF.

Astuces :

Utilisez les commandes sort et uniq (après avoir consulté leurs pages de manuel) pour clarifier le résultat de la commande awk.

Persistance de l'information[modifier | modifier le wikicode]

Savoirs :

Les données, notamment personnelles, sont susceptibles d'être mémorisées pour de longues périodes sans maîtrise par les personnes concernées.

Capacités :
  • Prendre conscience de la persistance de l'information sur les espaces numériques interconnectés.
  • Comprendre les principes généraux permettant de se comporter de façon responsable par rapport au droit des personnes dans les espaces numériques.
Observation :

La persistance de l'information se manifeste tout particulièrement au sein des disques durs mais aussi des mémoires caches. Elle interagit avec le droit à la vie privée et fait naître une revendication du « droit à l'oubli ».

Exercices[modifier | modifier le wikicode]

Votre grand-père ou votre grand-mère veut créer une page « Feacebouqué », mais ils ne savent pas très bien comment faire, et ont entendu qu'il faut se méfier quand même de ne pas faire n'importe quoi.

  • Rédigez dans un langage soutenu une suite de recommandations à votre grand-père ou à votre grand-mère, pour leur permettre de garder le contrôle sur les informations qu'ils présenteront au public.
  • Cherchez dans le passé récent des cas où des données personnelles ont été dévoilées à tort, avec des conséquences indésirables. Rédigez un court signalement d'un de ces cas.
  • Les organismes français qui conservent des données personnelles sur vous sont censés obéir à la loi « Informatique et Libertés ». Cette loi les oblige à vous communiquer les données qui vous concernent si vous le leur demandez. Choisissez un de ces organismes et demandez la communication des données qui vous concernent (vous pouvez arguer du fait que vous faites cette démarche dans le cadre de vos enseignements obligatoires).

La non-rivalité de l'information[modifier | modifier le wikicode]

Savoirs :

Existence de lois régissant la détention et la circulation de données numériques.

Capacités :

Prendre conscience de la non-rivalité des biens immatériels. Distinguer différents types de licences (libres, propriétaires).

Observation :

La non-rivalité d'un bien se définit par le fait que son usage par une personne n'en limite pas l'usage par d'autres (ainsi, le poste de radio est rival mais l'émission ne l'est pas). À l'occasion d'exposés suivis de débats, on sensibilise les élèves à l'évolution des valeurs et du droit (en France et ailleurs) induite par l'émergence de biens immatériels.

deuxième partie[modifier | modifier le wikicode]

Algorithmique[modifier | modifier le wikicode]

Un algorithme se définit comme une méthode opérationnelle permettant de résoudre, en un nombre fini d'étapes clairement spécifiées, toutes les instances d'un problème donné. Cette méthode peut être exécutée par une machine ou par une personne.

Les élèves ont été confrontés aux algorithmes très tôt dans leur parcours scolaire (avec les quatre opérations arithmétiques) et régulièrement de nouvelles situations de nature algorithmique leur ont été proposées ; ainsi, la construction de figures en géométrie euclidienne, la transcription des « formules » moléculaires en chimie, le code génétique ou encore l'analyse fonctionnelle en technologie sont autant de situations évoquant des algorithmes. Les programmes de mathématiques des classes de seconde et première contiennent une initiation à l'algorithmique sur laquelle il convient de s'appuyer. À travers l'étude de quelques algorithmes, on développe la faculté de lire et comprendre un algorithme conçu par d'autres, puis d'en concevoir de nouveaux. Ces algorithmes sont exprimés dans un langage de programmation et exécutés sur une machine ou bien définis de manière informelle.

Source : programme officiel (www.education.gouv.fr/...bo=57572)

Les prochaines citations de ce programme officiel seront signalées par le logo suivant :

Algorithmes simples[modifier | modifier le wikicode]

Savoirs :
  • rechercher un élément dans un tableau trié par une méthode dichotomique ;
  • trier un tableau par sélection ;
  • ajouter deux entiers exprimés en binaire.
Capacités :
  • Comprendre un algorithme et expliquer ce qu'il fait.
  • Modifier un algorithme existant pour obtenir un résultat différent.
  • Concevoir un algorithme.
  • Programmer un algorithme.
  • S'interroger sur l'efficacité d'un algorithme.
Observation :

On présente simultanément les notions d'algorithme et de programme, puis on les distingue. L'objectif est une compréhension de ces algorithmes et la capacité à les mettre en œuvre. Les situations produisant une erreur (division par zéro, dépassement de capacité) sont mises en évidence.

Algorithmes plus avancés[modifier | modifier le wikicode]

Savoirs :
  • tri par fusion ;
  • recherche d'un chemin dans un graphe par un parcours en profondeur (DFS) ;
  • recherche d'un plus court chemin par un parcours en largeur (BFS).
Capacités :
  • Comprendre et expliquer (oralement ou par écrit) ce que fait un algorithme.
  • S'interroger sur l'efficacité d'un algorithme.
Observation :

L'objectif se limite à une compréhension des principes fondamentaux sans exiger leur programmation.

troisième partie[modifier | modifier le wikicode]

Langages et programmation[modifier | modifier le wikicode]

La programmation est l'expression d'un algorithme dans un langage exécutable par une machine et joue un rôle central dans le développement des systèmes et produits informatiques.

L'apprentissage de la programmation vise d'une part à savoir programmer un algorithme décrit en langue naturelle et d'autre part à comprendre un programme et exprimer en langue naturelle l'algorithme sous-jacent. On commence par rappeler les éléments de base de tout langage de programmation (affectation, séquence, test et boucle) tels qu'ils ont été présentés en mathématiques en classe de seconde et consolidés en classe de première. On introduit alors la notion de fonction qui permet d'éviter des redondances, de structurer les programmes et d'organiser leur conception. Enfin, on met en évidence la qualité des programmes en les testant sur différents jeux de données. On insiste sur la clarté et la documentation qui facilitent la reprise du code par d'autres programmeurs. On montre enfin l'universalité de la notion de langage au-delà de la programmation. L'enseignant choisit un langage de programmation selon les critères suivants : simplicité d'utilisation, liberté d'installation, présence d'outils associés, existence d'une communauté d'utilisateurs et de bibliothèques facilitant le développement.

Source : programme officiel (www.education.gouv.fr/...bo=57572)

Les prochaines citations de ce programme officiel seront signalées par le logo suivant :

Types de données[modifier | modifier le wikicode]

Savoirs :
  • nombre entier ;
  • virgule flottante ;
  • booléen ;
  • caractère ;
  • tableau ;
  • chaîne de caractères.
Capacités :

Choisir un type de donnée en fonction d'un problème à résoudre.

Observation :

On adapte la présentation de ces notions en fonction du langage de programmation retenu.

Pourquoi typer des données[modifier | modifier le wikicode]

Dans un ordinateur, tout est représenté par des uns et des zéros. Alors, pourquoi vouloir distinguer des types de données ?

Pour l'essentiel, c'est une question de codage !

Prenons l'exemple du nombre , il pourrait représenter :

un entier court,
le nombre décimal 65, codé sur un seul octet ;
un réglage particulier d'options (tableau booléen),
supposons 8 options de personnalisation d'une automobile vraies ou fausses, par exemple :
toit ouvrant freinage assisté GPS intégré lecteur multimedia MP3 jantes larges couleur métallisée système de détection de collision assistance au créneau
0 1 0 0 0 0 0 1

 ;

un caractère ASCII,
ici, c'est le « A » ;

Pour des données plus longues, il existe de nombreuses autres interprétations possibles. Décider quel codage s'applique, c'est typer la donnée.

Bien connaître les types de données[modifier | modifier le wikicode]

Si on ignore les types de données, des bugs étranges et incompréhensibles peuvent se produire.

Le type entier[modifier | modifier le wikicode]

Selon les ordinateurs et les systèmes utilisés, un entier peut être codé sur une longueur fixe :

1 octet (8 bits)
il est dans l'intervalle [0, 255] (entier non signé), ou dans l'intervalle [-128, 127] (entier signé)
2 octets (16 bits)
il est dans l'intervalle [0, 65535] (entier non signé), ou dans l'intervalle [-32768, 32767] (entier signé)

Exercice

Quelles sont les limites qui concernent la représentation d'un entier sur 64 bits ?

Des bibliothèques de programmes existent pour faire du calcul en précision arbitraire. Dans ce cas, un entier peut être représenté par un nombre varaible d'octets, selon les besoins.

Le type virgule flottante[modifier | modifier le wikicode]

Un ordinateur n'utilise que des zéros et et des uns. Même si vous utilisez plusieurs giga-octets pour représenter un nombre tel que ou , la représentation sera toujours fausse.

On représente donc les nombres « réels » par une suite limitée de chiffre binaires. Un type à virgule flottante contient quelques bits pour donner l'ordre de grandeur (un exposant positif ou négatif pour faire une puissance de deux), et un nombre entier qui est multiplié par cette puissance de deux.

Extrait de l'article Virgule flottante de Wikipedia

  Encodage Signe Exposant Mantisse Valeur d'un nombre Précision Chiffres significatifs
Simple précision 32 bits 1 bit 8 bits 23 bits 24 bits environ 7
Double précision 64 bits 1 bit 11 bits 52 bits 53 bits environ 16

Le type booléen[modifier | modifier le wikicode]

Il s'agit d'un type de donnée qui ne peut avoir que deux valeurs différentes : vrai/faux ou 1/0.

La plupart des ordinateurs n'ont de mécanismes simples que pour accéder à des octets ; alors, il arrive que les valeurs vrai/faux soient encodées par les octets 11111111 et 00000000. Ce n'est pas un problème pour des systèmes riches en mémoire. Pour des micro-systèmes disposant d'une mémoire très limitée, il peut être bon de considérer des méthodes d'empaquetage de plusieurs booléens dans un seul octet, pour économiser une ressource précieuse.

Le type caractère[modifier | modifier le wikicode]

Le tableau suivant résument l'encodage de caractères non accentués, du code ASCII (début de l'UNICODE). Il a été adapté d'une page de Wikipedia.

0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
000
NUL
SOH
STX
ETX
EOT
ENQ
ACK
VT
FF
SO
SI
001
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
EM
SUB
FS
GS
RS
US
002
003
004
005
006
007

Pour connaître le code d'un caractère, prendre le chiffre hexadécimal en début de ligne, puis le chiffre hexadécimal en tête de colonne. Par exemple, 0041 est le code hexadécimal du caractère « A »

Évidemment, ce ne sont pas les seuls caractères qu'on ait à encoder dans le monde.

Le type tableau[modifier | modifier le wikicode]

Le type tableau se présente le plus souvent dans la mémoire de l'ordinateur comme une succession de données du même type (entiers, ou flottants, etc...), les unes à la suite des autres.

La particularité du tableau c'est qu'on doit pouvoir accéder à une des « cases » de ce tableau en donnant sont « index » : un seul numéro (tableaux à une dimension), ou plusieurs (tableaux à plusieurs dimensions).

Le type chaîne de caractères[modifier | modifier le wikicode]

Une chaîne de caractères, ça peut être implémenté comme un tableau de caractères.

Dans certains cas, cependant, on préfère réserver une code particulier qui signifie « fin de la chaîne de caractères ». Par exemple, en langage C, le premier octet nul marque la fin de la chaîne de caractères.

Une autre méthode (utilisée par certains langages Pascal), consiste à coder tout au début de la chaîne un entier qui représente la longueur de la chaîne de caractères.

Exercice

  • Trouver au moins un inconvénient de la méthode du caractère terminal (pensez à ce qui se passe si à la suite d'un bug, ce caractère disparaît);
  • Trouver au moins un inconvénient de la méthode de longueur encodée en début de chaîne.

Fonctions[modifier | modifier le wikicode]

Savoirs :
  • notion de fonction ;
  • portée des variables et passage d'arguments ;
  • définition récursive de fonctions.
Capacités :

Concevoir l'entête (ou l'interface) d'une fonction, puis la fonction elle-même.

Observation :

On adapte la présentation de ces notions en fonction du langage de programmation retenu.

Correction d'un programme[modifier | modifier le wikicode]

Savoirs :
  • test ;
  • instrumentation ;
  • situations d'erreur ou bugs.
Capacités :
  • Mettre un programme au point en le testant, en l'instrumentant.
  • Utiliser un outil de mise au point.
Observation :

On évoque les risques issus des programmes incorrects et des bugs qui en résultent, aux conséquences parfois graves.

Langages de description[modifier | modifier le wikicode]

Savoirs :

Présentation du langage HTML et du principe de séparation du contenu et de la mise en forme.

Capacités :

Créer et analyser une page web en langage HTML.

Observation :

On met en valeur le double usage du langage, lisible par un humain et interprétable par une machine. On utilise HTML pour écrire une page « à la main », puis on insiste sur le fait que ce langage sert aussi de cible à des générateurs de pages. On évalue la qualité des pages du point de vue de la correction syntaxique et de l'efficacité du message.

quatrième partie[modifier | modifier le wikicode]

Architectures matérielles[modifier | modifier le wikicode]

Exprimer un algorithme dans un langage de programmation a pour but de le rendre exécutable par une machine numérique. La découverte de l'architecture de ces machines constitue une étape essentielle d'une initiation à l'informatique. De plus, mieux comprendre cette organisation est nécessaire pour programmer de manière efficace, en tenant compte des capacités et limitations des machines numériques.

La progression pédagogique suit la chronologie du développement des systèmes informatiques : d'abord centralisés autour des machines à accès direct, ensuite connectés par l'intermédiaire d'une liaison série point à point et enfin répartis grâce aux réseaux où le transport des informations repose sur des méthodes de routage. Le développement de ces réseaux et leur utilisation massive ont induit des questions sociétales majeures qu'il est préférable d'aborder sous forme d'activités pluridisciplinaires. Finalement, l'étude d'un minirobot permet de découvrir les mécanismes de pilotage et de communication dans l'exécution de tâches complexes, interférant directement avec le monde physique.

Source : programme officiel (www.education.gouv.fr/...bo=57572)

Les prochaines citations de ce programme officiel seront signalées par le logo suivant :

ISN Architecture des ordinateurs

Éléments d'architecture[modifier | modifier le wikicode]

Savoirs :

Composants de base (unité centrale, mémoires, périphériques).

Capacités :

Expliquer le rôle des constituants d'un ordinateur.

Observation :

On se limite à une présentation générale de ces concepts autour d'une machine à accès direct (Random Access Machine).

Jeu d'instructions[modifier | modifier le wikicode]

Savoirs :

Instructions simples (chargement, stockage, opérations arithmétiques et logiques, saut conditionnel).

Capacités :

Savoir dérouler l'exécution d'une séquence d'instructions simples de type langage machine.

Observation :

On propose des activités sous forme d'exercices sur papier sans utiliser d'ordinateur.

ISN Réseaux

Transmission point à point[modifier | modifier le wikicode]

Savoirs :

Principes de base d'une transmission d'informations numériques entre un émetteur et un récepteur.

Capacités :

Établir une communication sérielle entre deux machines.

Observation :

On s'interroge sur la qualité d'une liaison série point à point. On se limite à l'analyse d'un trafic de type « chat » (échange de caractères codés). On introduit la notion de protocole (règles, formats et conventions, sur lesquels il est nécessaire de s'accorder pour communiquer). Au-delà de deux machines, le modèle de la liaison point à point ne convient plus.

Adressage sur un réseau[modifier | modifier le wikicode]

Savoirs :

Mécanismes d'adressage pour identifier des machines distantes.

Capacités :
  • Décrire une situation d'adressage sur un type de réseau particulier.
  • Analyser le trafic (trames) sur un réseau et mettre ainsi en évidence la notion de protocole.
Observation :

On introduit ces notions en comparant différents types d'adressages existants (téléphone, courrier postal). On fait appel à un outil d'analyse pour visualiser la transmission des trames nécessaires au dialogue entre machines numériques.

Routage[modifier | modifier le wikicode]

Savoirs :

Mécanismes induits par la communication sur un réseau dont la structure est de type graphe. Notions de paquets, de chemins, de routage.

Capacités :

Analyser les entêtes de messages électroniques, pour décrire le chemin suivi par l'information.

Observation :

On se limite à la mise en œuvre d'une séance de travaux pratiques, avec analyse d'entêtes de courriels prédéfinis reçus (aspect distribué et non fiable des réseaux de grande taille, difficulté du passage à l'échelle). On explique la différence entre les réseaux de type arborescent et de type graphe.

La supranationalité des réseaux[modifier | modifier le wikicode]

Savoirs :

Supranationalité des réseaux

Capacités :

Prendre conscience du caractère supranational des réseaux et des conséquences sociales, économiques et politiques qui en découlent.

Observation :

On met en évidence le fait que certains pays autorisent la mise en ligne d'informations, services ou contenus numériques dont la consultation n'est pas permise dans d'autres pays.

ISN Initiation à la robotique

Découverte d'un système robotique et de sa programmation[modifier | modifier le wikicode]

Savoirs :

Découverte d'un système robotique et de sa programmation

Capacités :
  • Identifier les différents composants d'un minirobot et comprendre leurs rôles respectifs.
  • Décrire un système à événements simple à l'aide d'une machine à états finis.
  • Programmer (dans un langage de haut niveau) un minirobot pour lui faire exécuter une tâche complexe.
Observation :

On propose des activités adaptées aux équipements et logiciels disponibles dans l'établissement.