Académique Documents
Professionnel Documents
Culture Documents
M16 Informatique Industriel
M16 Informatique Industriel
Module M16
Informatique industrielle
Sommaire
Spécialité : Technicien Spécialisé Diagnostic Et Electronique
Embarquée Automobile.
Niveau :Technicien Spécialisé
Secteur : Réparation des Engins à Moteur
Résumé de Théorie Informatique industriel
SOMMAIRE
Résume théorique 5
Matériel et logiciels 5
Principe ETS 6
Représentation interne des données 6
Systèmes arithmétiques 7
Structure d'un ordinateur 8
Communication des données 11
Transmission de données 11
Télétransmission de données 13
Sauvegarde et protection des données 14
OFPPT/DRIF/ISTA 2 SAFI 2
Résumé de Théorie Informatique industriel
PRESENTATION DU MODULE
OFPPT/DRIF/ISTA 2 SAFI 3
Résumé de Théorie Informatique industrielle
Module : 16
Informatique industrielle
RESUME THEORIQUE
OFPPT/DRIF/ISTA 2 SAFI 4
Résumé de Théorie Informatique industrielle
TECHNOLOGIE INFORMATIQUE
Vu la quantité croissante d'informations et de données qui doivent être élaborées toujours plus
rapidement, il est nécessaire de disposer de systèmes toujours plus performants pour traiter
celles-ci de manière informatisée, que ce soit dans le domaine de la technique, des sciences, du
commerce ou de l'administration. On distingue :
• les systèmes individuels, p. ex. les PC;
• les systèmes interconnectés, p. ex. les réseaux serveur-client.
Illustration 1: système PC
OFPPT/DRIF/ISTA 2 SAFI 5
Résumé de Théorie Informatique industrielle
Les données sont les informations qui peuvent être saisies, élaborées et restituées par
l'ordinateur. On différencie les données numériques, alphabétiques et graphiques. (ill. 2). La
combinaison des différentes données est appelée chaîne de caractères (string).
Le traitement des données fonctionne généralement selon le principe de structure ETS (ill. 3).
Entrée. L'utilisateur introduit les données dans l'ordinateur, p. ex. au moyen d'un clavier.
Traitement Le microprocesseur de l'ordinateur élabore les données par l'intermédiaire d'un
programme de traitement prédéfini. Les données résultantes peuvent alors être enregistrées
dans la mémoire de travail de l'ordinateur.
OFPPT/DRIF/ISTA 2 SAFI 6
Résumé de Théorie Informatique industrielle
Sortie. Les données traitées peuvent être affichées sur une unité de sortie, p. ex. un écran, par
l'intermédiaire d'un programme de traitement.
Chacun de ces deux états de branchement représente ainsi la plus petite unité d'information: 1
bit (de l'anglais binary digit = symbole à double valeur).
Si une source d'information est composée de 2 bits, comme p. ex. les feux clignotants d'un
véhicule, chaque bit peut comporter l'information 0 (clignotant éteint) ou l'information 1
(clignotant allumé (tableau 2).
OFPPT/DRIF/ISTA 2 SAFI 7
Résumé de Théorie Informatique industrielle
Un feu de signalisation routier transmet des informations aux usagers de la route au moyen de 3
lampes. Cela correspond à un contenu d'information de 3 bits. Il en résulte 2 3 = 8 possibilités de
branchement dont seules 4 sont utilisées (la combinaison du feu vert et du feu rouge p. ex.
n'aurait aucun sens dans ce cas, tableau 2).
Huit bits sont nécessaires pour pouvoir différencier toutes les lettres (minuscules et majuscules),
tous les chiffres, les signes spéciaux et les signes de contrôle.
Pour le traitement des données, les systèmes arithmétiques suivants sont utilisés:
· système décimal;
· système binaire;
· système hexadécimal.
Le système décimal est composé de 10 chiffres (base 10), le système binaire de 2 et le système
hexadécimal de 16.
En principe, les ordinateurs traitent les données au moyen du système binaire. Toutefois, afin de
pouvoir simplifier les longues chaînes de chiffres du système binaire, le système hexadécimal
est souvent utilisé.
Une combinaison des systèmes binaire et hexadécimal peut aussi être utilisée dans les
systèmes bus.
A titre d'exemple, le chiffre 123 est représenté dans les différents systèmes arithmétiques
tableau 1 ci-après.
8 bits = 1 byte
1 KB = 210 byte = 1 024 byte
1 MB = 220 byte = 1 048576 byte
1 GB = 230 byte = 1 073 741 824 byte
OFPPT/DRIF/ISTA 2 SAFI 8
Résumé de Théorie Informatique industrielle
Carte-mère (motherboard). Les composants principaux suivants y sont connectés (ill. 2):
- Microprocesseur - Mémoires internes
- Unités entrée et sortie - Bus système
Microprocesseur (CPU - Central Processing Unit). C'est là que sont exécutées pas à pas les
instructions provenant d'un programme. La fréquence d'impulsions par seconde est la vitesse
avec laquelle le processeur est entraîné d'un pas du programme à l'autre, p. ex. à 4 GHz, le
CPU exécute chaque seconde 4 000 000 000 de pas de travail.
Mémoire interne. Elle comprend la mémoire en lecture seule et la mémoire de travail.
Mémoire en lecture seule (ROM- Read Only Memory). C'est là que sont enregistrés les
programmes et les données inaltérables, comme p. ex. le programme de démarrage de
l'ordinateur. Celui-ci permet, après l'enclenchement de l'ordinateur, de transférer les
programmes du système d'exploitation des supports externes vers la mémoire de travail (RAM)
et de les démarrer. Les informations mémorisées dans la ROM y restent conservées après le
déclenchement de l'ordinateur.
OFPPT/DRIF/ISTA 2 SAFI 9
Résumé de Théorie Informatique industrielle
Mémoire de travail (RAM - Random Access Memory). C'est dans cette mémoire vive que les
programmes et les données servant au fonctionnement actuel de l'ordinateur sont stockés. Lors
du déclenchement de l'ordinateur ou par suite d'une commande logicielle, cette mémoire est
effacée.
Bus système, Il comprend le bus de contrôle pour les signaux de commande, le bus d'adresse,
p. ex. pour l'attribution des emplacements de stockage et le bus de données par lequel transitent
les données, les commandes et les adresses.
Unités d'entrée/sortie (interface E/S). Elles servent à piloter l'échange de données entre le
CPU, la mémoire vive et les périphériques, p. ex. souris, clavier.
Interfaces. Ce sont les liaisons par l'intermédiaire desquelles les signaux sont transmis d'un
système à un autre, p. ex. du PC à l'imprimante. Les interfaces peuvent se présenter sous forme
de cartes internes ou de connecteurs (ill.1). On distingue les interfaces parallèles et les
interfaces sérielles (tableau 1).
Les interfaces parallèles transmettent 8 bits simultanément (en parallèle) par le biais d'une
liaison à 8 fils séparés, p. ex. pour la liaison avec une imprimante. Pour ce faire, on utilise une
prise à 25 pôles du côté de l'ordinateur et une prise à 36 pôles du côté de l'imprimante (prise
Centronics).
Les interfaces sérielles transmettent chaque bit l'un après l'autre (en série) p. ex. pour la
connexion d'une souris. Cette interface externe est également appelée interface V.24 ou RS
232. Les prises pour ces liaisons disposent en général de 9 pôles.
OFPPT/DRIF/ISTA 2 SAFI 10
Résumé de Théorie Informatique industrielle
1 MByte/s=8MBit/s
Tableau 1 : les interfaces de l’ordinateur
Appellation Type Vitesse de transmission Usage
LPT 1 Parallèle 3 MByte/s Pour imprimante, scanner
COMiRS232 Sérielle — Pour modem, souris sérielle
LAN/RJ45 Sérielle 10/100 Mbit/s Ethernet, réseaux
IrDA Sérielle Jusqu'à 14,4 KByte/s Interface infrarouge
PS/2 Sérielle — Pour souris, clavier
USB Sérielle 1,5 MByte/s Interface universelle pour imprimante, scanner, clé de stockage
IDE, ATA Parallèle Jusqu'à 150 MByte/s Pour disque dur (sur la carte-mère)
SCSI Parallèle Jusqu'à 160 MByte/s Pour disque dur professionnel, serveur
Bluetooth Sérielle 1 MBit/s Interface de communication sans fil (trm.) .
Firewire Sérielle Jusqu'à 400 MBit/s Interface universelle pour caméra, téléphone portable
OFPPT/DRIF/ISTA 2 SAFI 11
Résumé de Théorie Informatique industrielle
Réseaux de données. Il s'agit de liaisons informatiques par lesquelles des données sont
transmises, sous forme de paquets d'informations. Dans de petits réseaux, comme celui d'un
véhicule automobile, on transmet également des signaux de commande. Les données sont
transmises en série, bit par bit, et les informations peuvent être utilisées par tous les membres
du réseau.
Les systèmes d'échange de données, comme p. ex. ceux qui sont utilisés à l'intérieur d'une
entreprise, dans un bureau ou dans un véhicule, sont appelés LAN (Local Area Network) ou
réseaux locaux. L'échange de données entre des PC, des micro-ordinateurs, des ordinateurs
centraux et tous les périphériques ont lieu à des vitesses de transmission élevées (de 10 Mbit/s
à 100 Mbit/s env.). Cela signifie que tous les membres du réseau peuvent accéder à toutes les
données pratiquement simultanément, afin de les traiter ou de les modifier. Les éléments de
liaison entre les ordinateurs sont constitués par des câbles de données, des connexions et des
cartes-réseaux qui sont montés dans les ordinateurs.
Structures des réseaux. Selon l'implantation des ordinateurs reliés à une ligne de données
commune, on distingue:
• la structure en étoile la structure en anneau
• la structure par bus
Structure en étoile active. Elle permet la connexion de nombreux ordinateurs sans tirer trop de
câbles. Chaque station de travail est reliée à une station de transmission (nœud). Il s'agit la
plupart du temps d'un serveur ou d'un hub. Si l'une des stations de travail est hors service, les
autres membres du réseau ne subissent aucune perturbation. Si, par contre, la station de
transmission est en panne, l'ensemble du réseau ne fonctionne plus.
Structure en étoile passive. Tous les postes de travail ont les mêmes droits. C'est le nœud de
liaison qui fait office d'interface entre les postes. Si l'un des postes de travail est en panne, le
réseau continue à fonctionner.
Structure en anneau (ill. 2). Avec cette structure, les stations de travail avoisinantes sont
directement reliées entre elles. Les données sont transmises d'une station à la suivante dans
une direction ou l'autre. Il est facile d'ajouter un ordinateur supplémentaire en l'intercalant dans
le réseau. Par contre, si un ordinateur est hors service dans l'anneau, l'ensemble du réseau peut
être bloqué.
OFPPT/DRIF/ISTA 2 SAFI 12
Résumé de Théorie Informatique industrielle
Structure en arbre (ill. 2). Elle permet l'émission et la réception de données à partir de chaque
station par un câble commun. Etant donné que chaque station peut émettre et recevoir, la
circulation des données doit être régie par un protocole adéquat. Chaque place de travail peut
émettre si le bus est "libre". Le réseau peut être agrandi de façon simple par l'introduction d'une
station de travail supplémentaire. De plus, la panne d'une station ne perturbe pas l'ensemble du
réseau. Par contre, les informations émises peuvent être réceptionnées ("écoutées") par toutes
les stations.
Réseau peer to peer. Il s'agit d'un réseau simple avec une structure par bus, dans laquelle tous
les ordinateurs sont reliés entre eux de manière indépendante par une ligne de données. Ils ont
tous les mêmes droits. Ainsi, des données peuvent être échangées facilement entre deux
ordinateurs.
OFPPT/DRIF/ISTA 2 SAFI 13
Résumé de Théorie Informatique industrielle
Routeur. Il relie deux ou plusieurs réseaux et retransmet les données de manière intelligente.
Réseau serveur-client
Serveur (régisseur de service). Dans un réseau, il met à disposition les données, les
programmes et la puissance de calcul. Le serveur peut mémoriser de grandes quantités de
données et donc ainsi décharger l'ordinateur client.
Le terme client désigne les autres ordinateurs du réseau. Ils utilisent les services du serveur en
y stockant les données, en faisant appel à ses programmes et à sa puissance de calcul. De tels
réseaux se trouvent dans les grandes exploitations automobiles (ill. 1).
Elle permet l'échange d'informations entre différents réseaux, tel que la transmission de sons,
d'illustrations, de textes ou de données au travers des services de télécommunication avec
liaisons par câbles ou transmission radio.
WAN (Wide Area Networks = réseaux de données à grande surface). Il s'agit de systèmes de
communication pouvant être étendus au monde entier. Les entreprises de télécommunication
mettent leurs réseaux téléphoniques à disposition pour les transmissions de données. Pour
assurer la liaison à des services de télécommunication, des terminaux de communication et des
installations de transmission des données sont nécessaires.
Installation de transmission des données. Elle est indispensable pour la coordination des
signaux de données entre le terminal de communication et le câble de transmission. Pour ce
faire, on utilise des adaptateurs RNIS, des modems, p. ex. des modems ADSL. Par le biais d'un
logiciel de communication adéquat, l'échange de données entre les ordinateurs est alors assuré
par des interfaces sérielles ou parallèles.
OFPPT/DRIF/ISTA 2 SAFI 14
Résumé de Théorie Informatique industrielle
Services en ligne
Il s'agit d'entreprises de services qui offrent et vendent des informations, comme p. ex. les cours
de la bourse, les nouvelles, des données spécifiques à certaines entreprises et des informations
qui sont déposées dans des banques de données. D'autre part, elles offrent à leurs clients un
grand nombre de possibilités de communications privées et professionnelles, comme le
homebanking, le teleshopping, le telelearning, le teleworking (ill. 2).
OFPPT/DRIF/ISTA 2 SAFI 15
Résumé de Théorie Informatique industrielle
Par sauvegarde des données, on entend toutes les mesures, méthodes et dispositifs qui
permettent de se protéger contre la perte des données, une utilisation illicite ou une diffusion
dénaturée de celles-ci.
Copies de sécurité. Ce sont des copies des données importantes, p. ex. sur CD-Rom, qui
peuvent être utilisées en cas de perte des données originales.
Protection contre l'écrasement des données. Elle empêche l'écrasement accidentel des
données sur des mémoires externes. Lors de la procédure d'enregistrement, le programme peut
afficher un message, de type "Voulez-vous remplacer le fichier existant?" , avant que le système
ne remplace le fichier d'origine par le nouveau.
Protection par mot de passe. Chaque utilisateur d'une installation de traitement des données
dispose d'un mot de passe qu'il doit saisir au début de son travail à l'ordinateur. Si l'ordinateur
reconnaît ce mot de passe, il autorise alors l'utilisateur à accéder à des domaines déterminés de
la mémoire externe.
OFPPT/DRIF/ISTA 2 SAFI 16
Résumé de Théorie Informatique industrielle
Programmes antivirus. Des programmes antivirus sont utilisés afin de détecter les infections
virales informatiques, de les éliminer ou de les neutraliser. Actuellement, de nouveaux virus
apparaissent régulièrement, d'où la nécessité de maintenir les programmes antivirus
constamment à jour.
La base juridique de la protection des données est constituée par la loi fédérale sur la protection
des données (LPD).
Le but de la protection des données est d'empêcher tout abus lors de la mémorisation, la
transmission, la modification et l'effacement des données.
Au sens de la loi sur la protection des données, les données protégées sont, p ex des
données de nature personnelle, qui ne sont pas susceptibles d'être accessibles à tout un
chacun, à l'image des inscriptions dans un annuaire téléphonique.
• des informations matérielles, p. ex. salaire mensuel, fortune, dettes, propretés foncières.
Aujourd'hui toutefois, la mémorisation des données des personnes, en vue d'un travail rationnel
et rapide, p. ex pour la réalisation de tâches administratives, est devenue incontournable. C'est
pourquoi chaque individu doit pouvoir bénéficier, lors de la saisie de ses données personnelles,
des droits suivants:
La protection des données en bonne et due forme, selon la législation sur la protection des
données, est contrôlée par des préposés à la protection des données.
OFPPT/DRIF/ISTA 2 SAFI 17
Guide des travaux pratiques Informatique industrielle
Module :
Informatique industrielle
GUIDE DES TRAVAUX PRATIQUES
OFPPT/DRIF/ISTA 2 SAFI 18
Guide des travaux pratiques Informatique industrielle
Le but de ces TP est de permettre aux stagiaires de comprendre, à travers des réalisations sur
carte Arduino, de comprendre les détails du fonctionnement d’un calculateurs en automobile et
aide ainsi à bien comprendre la gestion de plusieurs systèmes à savoir l’injection essence, le
Common rail, l’ABS, l’ESP…
La première annexe traitre les notions de la conception d’un programme ou ce qu’en appel
algorithme.
Pour réaliser un TP, on commence par analyser l’objectif du TP, puis on commence par
concevoir les algorithmes nécessaires et en fin traduire ces algorithmes en langage C.
OFPPT/DRIF/ISTA 2 SAFI 19
Guide des travaux pratiques Informatique industrielle
Gestion du clavier
OFPPT/DRIF/ISTA 2 SAFI 20
Guide des travaux pratiques Informatique industrielle
Objectifs spécifiques :
Le but de ce TP est de commander une diode LED à l’aide d’une carte Arduino UNO.
A la fin du TP, l’étudiant sera capable de réaliser un clignotement et un jeu de lumière à l’aide de
plusieurs diodes LED.
1 Présentation :
La diode électroluminescente (LED) émet de la lumière. Elle est polarisée: la patte “+” est la plus
longue, l’autre patte est la patte “-”. Les broches numériques de l’Arduino, lorsqu’elles sont
configurées en sorties et qu’elles sont à l’état
1 ou haut (HIGH), fournissent une tension de 5 volts, supérieure à ce que peut accepter une LED.
Les LED doivent donc être couplées en série avec une résistance (sauf pour la broche numérique
13 qui est déjà câblée en série avec une résistance de valeur moyenne pour une LED ( 1K ohm ),
on peut donc, dans la plupart des cas, directement lui brancher une LED).
OFPPT/DRIF/ISTA 2 SAFI 21
Guide des travaux pratiques Informatique industrielle
2 Manipulation 01 :
Le but de cette manipulation est de faire clignoter une diode LED toutes les secondes.
OFPPT/DRIF/ISTA 2 SAFI 22
Guide des travaux pratiques Informatique industrielle
Une fois la dernière ligne exécutée, la carte revient au début de la troisième phase et recommence
sa lecture et son exécution des instructions successives. Et ainsi de suite. Cette boucle se déroule
des milliers de fois par seconde et anime la carte.
A présent, il faut vérifier la syntaxe du programme et s’il n’y a aucune erreur l’envoyer vers la carte
ARDUINO.
3 Manipulation 02 :
Modifiez le programme précédent pour commander deux diodes LED (choisissez les broches de
votre choix)
4 Manipulation 03 :
OFPPT/DRIF/ISTA 2 SAFI 23 8
Guide des travaux pratiques Informatique industrielle
Le but de ce TP est la gestion du bouton poussoir. A la fin du TP l’étudiant sera capable de lire
l’état d’un bouton et de réaliser un traitement selon cet état (commander une diode LED ou afficher
un message)
1 Présentation :
Les boutons sont les capteurs les plus simples. En appuyant sur un bouton, on connecte ses fils,
de telle sorte que le bouton agit comme un interrupteur. En relâchant le bouton, on interrompt le
circuit. Il existe des boutons de différentes tailles et formes. Quand on utilise une plaque à essais,
il est pratique d’employer un bouton avec quatre fils. Les fils fonctionnent par paires, si bien que
deux fils adjacents sont toujours connectés l’un à l’autre.
2 Manipulation 01 :
Au cours de cette manipulation, nous allons commander une diode LED à l’aide d’un bouton
poussoir. Lorsqu’on appuie sur le bouton, la LED va allumer et lorsqu’on relâche le bouton la LED
s’éteindra.
OFPPT/DRIF/ISTA 2 SAFI 24
Guide des travaux pratiques Informatique industrielle
Réalisez le montage de la figure qui suit et n’oubliez pas d’ajouter la LED à la broche de votre
choix.
Pour lire l’état du bouton poussoir vous devez utiliser la fonction : digitalRead (broche).
3 Manipulation 02 :
Modifiez le programme précédent de telle sorte que le premier appui sur le bouton poussoir allume
la diode LED et que le second appuie l’éteint.
4 Manipulation 03 :
Nous allons réaliser un dé numérique à l’aide de trois diodes LED. L’appuie sur le bouton poussoir
va générer un numéro aléatoire entre 1 et 6 ; le numéro obtenu sera codé de la façon suivante :
Bonus :
Pour générer un numéro aléatoire, vous devez utiliser les fonctions randomSeed() et random().
OFPPT/DRIF/ISTA 2 SAFI 25
Guide des travaux pratiques Informatique industrielle
TP 3 : GESTION DU CLAVIER
Objectifs spécifiques :
Le but de ce TP est la gestion du clavier. L’étudiant sera capable à la fin de ce TP de lire un code
à partir du clavier pour réaliser un traitement spécifique en sortie.
1 Présentation :
Le clavier dispose de 12 touches arrangées selon la matrice des téléphones sur une grille de 3X4.
Les touches sont reliées sur une matrice, il suffit donc de 7 pins d'un microcontrôleur pour pouvoir
l'utiliser (3 colonnes et 4 lignes).
Au cours de cette manipulation, vous devez réaliser un montage qui permet de lire le numéro du
bouton appuyé par l’utilisateur et d’envoyer son code sur le moniteur série de l’Arduino.
OFPPT/DRIF/ISTA 2 SAFI 26
Guide des travaux pratiques Informatique industrielle
Pour réaliser votre programme, vous devez utiliser la bibliothèque Arduino spécifique du clavier
matriciel (keypad en anglais). A noter que cette librairie n'est pas installée par défaut et qu'il faut la
télécharger. Lancez le logiciel ARDUINO, ensuite allez à Croquis>Inclure une bibliothèque>Gérer
les bibliothèques. Tapez le mot « keypad », « more info » puis « installer ».
Pour communiquer avec le moniteur série de l’Arduino, il faut utiliser la bibliothèque Serial
(Serial.begin, Serial.print, Serial.println,...)
Vous pouvez vous inspirer de l’exemple « HelloKeypad » de la bibliothèque Keypad.
3 Manipulation 02 :
OFPPT/DRIF/ISTA 2 SAFI 27
Guide des travaux pratiques Informatique industrielle
Objectifs spécifiques :
Le but de ce TP est de commander un afficheur LCD. L’étudiant sera capable d’afficher des
messages et gérer la position du curseur de l’afficheur
1 Présentation :
Les afficheurs LCD (Liquid Crystal Display) sont devenus incontournables dans toute application
qui demande la visualisation de paramètres, il s’agit donc d’une interface Homme/Machine. Ils sont
très utilisés dans les montages à microcontrôleur, et permettent une grande convivialité. Au cours
de ce TP nous allons utiliser un afficheur LCD alphanumérique de 2x16 caractères représenté par
la figure ci-dessous :
N.B :Les broches 15 et 16 ne sont présentes que sur les afficheurs LCD avec rétroéclairage avec :
15 : A : Anode rétroéclairage (+5V)
16 : K : Cathode rétroéclairage (masse)
OFPPT/DRIF/ISTA 2 SAFI 28
Guide des travaux pratiques Informatique industrielle
3 Manipulation 01 :
Le but de cette première manipulation et d’afficher un texte fixe sur l’écran LCD (votre nom et
prénom par exemple)
Branchez l’écran LCD à votre carte Arduino comme indiqué dans le schéma suivant :
OFPPT/DRIF/ISTA 2 SAFI 29
Guide des travaux pratiques Informatique industrielle
Bonus :
Ajouter une animation au texte affiché : clignotement, défilement à droite, défilement à gauche.
Pour se faire, utilisez les fonctions lcd.scrollDisplayLeft() et lcd.scrollDisplayRight()
4 Manipulation 02 :
5 Manipulation 03 :
Vous allez réaliser un jeu où il faut deviner un nombre choisi au hasard par le programme (fonction
random(Min,MAX+1)) . Le jeu commence par afficher le message « Devine un nombre entre Min
et Max » (avec Min et Max : les limites inférieure et supérieure des nombres à deviner). Après
chaque tentative, le programme vous dira si le nombre que vous avez proposé est trop grand, trop
petit, ou si vous avez trouvé la bonne réponse et après combien d’essais.
Exemple d’exécution : Devine un nombre de 1-30 :
15
Trop petit 22
Trop grand
17
Trop grand
16 Exact
4 essais
OFPPT/DRIF/ISTA 2 SAFI 30
Guide des travaux pratiques Informatique industrielle
1 Présentation :
En plus des pattes numériques, l’Arduino possède 6 pattes (A0..A5) qui peuvent être utilisées
comme entrées analogiques. Ces entrées prennent un voltage (entre 0 et 5V) et le convertissent
en un nombre compris entre 0 (0V) et 1023 (5V) (résolution de 10 bits). Un composant très utile
qui utilise ces entrées est le potentiomètre (aussi appelé résistance variable). Quand il est
connecté avec 5V entres ces pattes extérieures, la patte centrale ressort des valeurs comprises
entre 0 et 5V en fonction de l’angle selon lequel son axe est tourné (ex : 2,5V au milieu). Cette
valeur peut être ensuite utilisée comme variable dans le programme.
Lors de cette manipulation, vous allez réaliser un programme qui permet de lire la valeur
analogique délivrée par le potentiomètre sur l’une des entrées analogiques et d’afficher le résultat
sur le moniteur série de l’Arduino.
OFPPT/DRIF/ISTA 2 SAFI 31
Guide des travaux pratiques Informatique industrielle
3 Manipulation 02 :
Lors de la précédente manipulation, vous avez remarqué que les valeurs affichées sur le moniteur
série sont comprises entre 0 et 1023. Modifiez votre programme pour qu’il calcule les valeurs
réelles de la tension lue (comprises entre 0 et 5V) et les affiche sur un afficheur LCD.
Bonus :
Vous pouvez utiliser la fonction map() pour passer de la valeur numérique (0-1023) à la valeur
analogique (0-5).
4 Manipulation 03 :
5 Manipulation 04 :
Commandez la luminosité d’une diode LED à l’aide du potentiomètre : plus la valeur de la tension
lue est grande, plus la luminosité de la diode augmente et inversement.
Bonus :
Il faut brancher la diode LED sur l’une des pins de l’ARDUINO (3, 5, 6, 9, 10 et 11) qui utilisent le
PWM. Pour commander la diode LED, utilisez la commande AnalogWrite(). Il est à noter que le
rapport cyclique de la sortie PWM varie de 0 à 255. Pensez à utiliser encore une fois la fonction
map().
OFPPT/DRIF/ISTA 2 SAFI 32
Guide des travaux pratiques Informatique industrielle
6 Manipulation 05 :
Réalisez une jauge électronique à l’aide de 5 diodes LED : plus la tension augmente plus le
nombre de diodes allumées augmente
3
4
OFPPT/DRIF/ISTA 2 SAFI 33
Guide des travaux pratiques Informatique industrielle
TP 6 : L’ACQUISITION DE LA TEMPERATURE
ET DE L’HUMIDITE : LE CAPTEUR DHT11
Objectifs spécifiques :
Le but de ce TP est de faire l’acquisition de l’information envoyée par le capteur numérique DHT11.
L’étudiant sera capable de gérer une communication OneWire et d’exploiter les informations
acquises à savoir la température et l’humidité
1 Présentation :
Le capteur DHT11 est constitué d’un senseur de température à base d'une thermistance à
coefficient négatif de température et d’un capteur d’humidité résistif. Un microcontrôleur intégré
s’occupe de faire les mesures, de les convertir et de les transmettre. Le DHT11 fait partie des
circuits numériques qui dialoguent au moyen d'une seule ligne série bidirectionnelle de type
OneWire (Un fil).
OFPPT/DRIF/ISTA 2 SAFI 34
21
Guide des travaux pratiques Informatique industrielle
2 Manipulation 01 :
3 Manipulation 02 :
Modifiez le programme précédent pour afficher les valeurs de la température et de l’humidité sur un
afficheur LCD.
Ajoutez deux diodes LED l’une pour contrôler la température et l’autre pour l’humidité (les LED
s’allumeront lorsqu’on atteint un seuil bien déterminé de température ou d’humidité ; essayez de
faire varier les valeurs de température et d’humidité pour atteindre ces seuils et allumer les LED)
Bonus :
La ligne de connexion (DATA) peut faire jusqu'à 20 m de longueur entre le capteur et la carte
Arduino, dans ce cas il faut diminuer la valeur de R à 4,7 kW.
OFPPT/DRIF/ISTA 2 SAFI 35
Guide des travaux pratiques Informatique industrielle
Objectifs spécifiques :
1 Présentation :
Le capteur HC-SR04 utilise les ultrasons pour déterminer la distance d'un objet. Il offre une
excellente plage de détection sans contact, avec des mesures de haute précision et stables. Son
fonctionnement n'est pas influencé par la lumière du soleil ou des matériaux sombres, bien que des
matériaux comme les vêtements puissent être difficiles à détecter.
1.1 Caractéristiques :
· Dimensions : 45 mm x 20 mm x 15 mm
· Plage de mesure : 2 cm à 400 cm
· Résolution de la mesure : 0.3 cm
· Angle de mesure efficace : 15 °
· Largeur d'impulsion sur l'entrée de déclenchement (Trigger Input Pulse width) : 10 µs
Le capteur dispose de 4 bornes :
· Vcc : alimentation en 5V
· Trig : entrée. Une impulsion (5V) supérieure à 10µs permet de lancer la mesure.
· Echo : sortie. La durée de l’impulsion correspondra à la distance.
· Gnd : commun
OFPPT/DRIF/ISTA 2 SAFI 36
Guide des travaux pratiques Informatique industrielle
Pour déclencher une mesure, il faut présenter une impulsion "high" (5 V) d'au moins 10 µs sur
l'entrée "Trig". Le capteur émet alors une série de 8 impulsions ultrasoniques à 40 kHz, puis il
attend le signal réfléchi. Lorsque celui-ci est détecté, il envoie un signal "high" sur la sortie "Echo",
dont la durée est proportionnelle à la distance mesurée.
La distance parcourue par un son se calcule en multipliant la vitesse du son, environ 340 m/s par le
temps de propagation, soit : d = v · t (distance = vitesse · temps).
Le HC-SR04 donne une durée d'impulsion en dizaines de ris. Il faut donc multiplier la valeur
obtenue par 10 ris pour obtenir le temps t.
On sait aussi que le son fait un aller-retour. La distance vaut donc la moitié. d = 34000 cm/1000000
ris · 10us · durée / 2
En simplifiant d =170000 /1000000 cm · durée
Finalement, d = 17/100 cm · durée
La formule d = durée/58 cm figure aussi dans le manuel d'utilisation du HC-SR04 car la fraction
17/1000 est égale à 1/58.8235.
Note : A grande distance, la surface de l'objet à détecter doit mesurer au moins 0.5 m2
2 Manipulation 01 :
OFPPT/DRIF/ISTA 2 SAFI 37
Guide des travaux pratiques Informatique industrielle
Ajoutez un deuxième capteur à votre montage. Le but est de réaliser un détecteur d’obstacle. Le
premier capteur détecte un obstacle à droite (distance inférieure à 5 cm par exemple) et votre
programme affiche le message « obstacle à droite » sur le moniteur série et le deuxième capteur
détecte un obstacle à gauche et le programme affiche « obstacle à gauche ».
Bonus :
Vous pouvez ajouter deux diodes LED pour signaler l’approche d’un obstacle (une de chaque côté)
4 Manipulation 03 :
Modifier le montage précédent en ajoutant un afficheur LCD. Le but de cette manipulation est
d’afficher tous les messages sur l’écran de l’afficheur au lieu de les envoyer au moniteur série
OFPPT/DRIF/ISTA 2 SAFI 38
Guide des travaux pratiques Informatique industrielle
1 Présentation :
Les servomoteurs sont des actionneurs très utilisés en modélisme et dans l’industrie. Ils ont comme
caractéristique principale leur « couple », c'est-à-dire la force de rotation qu’ils peuvent exercer.
Plus un servomoteur aura de couple et plus il pourra actionner des « membres » lourds comme
déplacer un bras qui porte une charge.
Pour la robotique de loisirs, les servomoteurs ont en général peu de couple et sont de taille réduite,
bien adaptée à un encombrement minimal et à une énergie disponible limitée.
Figure 22 Le servomoteur
Les servomoteurs sont pilotés par un fil de commande et alimentés par deux autres fils.
Habituellement, ces 3 fils sont rassemblés dans une prise au format standard.
Un fil rouge est relié à l’alimentation positive (+5 ou +6 V selon le servomoteur), le fil noir est relié à
la masse (GND) et le fil jaune est utilisé pour la commande.
2 Commande du servomoteur
Pour commander un servomoteur il faut envoyer sur son fil de commande (fil jaune) une impulsion
dont la durée correspond à l’angle désiré. Historiquement, cette impulsion était délivrée par un
circuit oscillateur (exemple : NE555).
Avec la programmation de l’Arduino, le circuit oscillateur n’est plus nécessaire ; la bibliothèque «
Servo » permet de piloter un servomoteur en lui transmettant simplement l’angle sur lequel il
souhaite se positionner (cet angle est compris entre 0° et 180°).
OFPPT/DRIF/ISTA 2 SAFI 39
Guide des travaux pratiques Informatique industrielle
3 Manipulation
Le servomoteur accepte généralement une plage d’alimentation comprise entre 4.5V et 6V. Si on
n’a besoin d’utiliser qu’un ou deux servomoteurs, on peut les brancher sur la sortie 5V de la carte
Arduino. Si le montage demande plus, il serait bon d’envisager une alimentation externe (shields
moteur) car le régulateur de l’Arduino n’est pas fait pour délivrer trop de courant, on risque de le
griller.
Branchez le servomoteur conformément à la figure suivante :
OFPPT/DRIF/ISTA 2 SAFI 40
Guide des travaux pratiques Informatique industrielle
4 Manipulation 02 :
5 Manipulation 03 :
OFPPT/DRIF/ISTA 2 SAFI 41
Guide des travaux pratiques Informatique industrielle
Le but de ce TP est de s’initier à l’interfaçage entre le logiciel Labview et la carte Arduino UNO.
L’étudiant sera capable d’établir cet interfaçage en manipulant les différents outils et logiciels
nécessaires à l’établissement de cette communication. Il pourra aussi commander les
Entrées/Sorties de l’Arduino à l’aide de Labview en exploitant des exemples simples fournis par
labVIEW.
Ce TP sera une initiation aux étudiants pour l’année suivante (3ème année, spécialité SEM) qu’ils
pourraient la développer et l’exploiter pour la réalisation des mini projets au niveau du module
Projet Professionnel Personnalisé (PPP).
1 Présentation :
Le but de cet atelier est de découvrir comment se fait l’interfaçage entre le logiciel LabVIEW avec
un Arduino. C’est aussi de comprendre comment récupérer les données de différents capteurs,
comment par l’appuie sur un bouton il sera possible d’allumer une LED ou faire tourner un
servomoteur
LabVIEW est un logiciel développé par National Instruments permettant de coder à l’aide de
diagramme. Grâce à ce logiciel il est possible de créer des outils de mesure et de contrôle.
Pour établir cette communication, un certain nombre d’outils et logiciels sont nécessaires :
Télécharger et installer Labview (en s’inscrivant sur le site officiel de
National Instruments, on peut télécharger une version d’évaluation
de Labview)
Une fois tous les logiciels installés, lancez VIPM. Le but est d’installer dans labVIEW les
instruments virtuels (VI) d’Arduino.
Pour cela, il existe deux types de VI :
OFPPT/DRIF/ISTA 2 SAFI 42
Guide des travaux pratiques Informatique industrielle
3 Interfaçage labVIEW-Arduino
OFPPT/DRIF/ISTA 2 SAFI 43
Guide des travaux pratiques Informatique industrielle
Le firmware LIFA est disponible après installation de labVIEW 2015 dans le répertoire «C:\Program
Files (x86)\National Instruments\LabVIEW 2015\vi.lib\LabVIEW Interface for
Arduino\Firmware\LIFA_Base». Au niveau de ce répertoire, on trouve plusieurs fichiers dont les
trois principaux sont :
- le sketch « LIFA_Base.ino » : c’est ce sketch que vous compilerez et transfèrerez à la carte
Arduino
- le sketch « LabVIEWInterface.ino » : il contient l’implémentation de toutes les fonctions utilisées
par LabVIEW pour dialoguer avec la carte Arduino
- le fichier d’inclusion « LabVIEWInterface.h » : ce fichier d’en-tête est particulièrement intéressant
puisque c’est lui qui contient les « define » que vous pouvez modifier pour adapter LIFA.
Finalement, il faut charger le sketch « LIFA_Base.ino » dans l’environnement Arduino, le
compilez puis programmez la carte Arduino ; ainsi la carte est prête à fonctionner avec labVIEW
L’installation de MakerHub(LINX) est beaucoup plus facile. Pour ce faire connecter la carte Arduino
sur le port USB du pc et lancer labVIEW. Choisir dans le menu principal outils > MakerHub > LINX
> LINX Firmwar Wizard.
Au niveau de la fenêtre qui s’ouvre, choisir les options suivantes :
- Devise Family : Arduino
- Devise Type : Arduino Uno
- Firmware Upload Method : Serial/USB
En cliquant sur suivant, on se retrouve avec la fenêtre du choix du numéro du port serie :
OFPPT/DRIF/ISTA 2 SAFI 44
Guide des travaux pratiques Informatique industrielle
OFPPT/DRIF/ISTA 2 SAFI 45
Guide des travaux pratiques Informatique industrielle
4 Fonctionnement de labVIEW :
Un programme LabVIEW se compose de deux parties. Une partie appelée « Front_Panel » est
l’interface sur laquelle l’utilisateur va interagir pour commander son Arduino. Puis une partie «
Block-Diagram » où le programme sera écrit.
CORRECTION DES TP
OFPPT/DRIF/ISTA 2 SAFI 47
Guide des travaux pratiques Informatique industrielle
Manipulation 03 :
En utilisant six diodes LED, réalisez un jeu de lumière (exemple : un chenillard)
OFPPT/DRIF/ISTA 2 SAFI 48
Guide des travaux pratiques Informatique industrielle
Manipulation 02 :
Modifiez le programme précédent de telle sorte que le premier appui sur le bouton poussoir allume la diode
LED et que le second appuie l’éteint :
OFPPT/DRIF/ISTA 2 SAFI 49
Guide des travaux pratiques Informatique industrielle
Lors de l’exécution de ce programme, on remarque que la diode LED ne suit pas toujours l’appui sur le bouton
poussoir ; il y’a l’effet rebond (un seul appui sur le bouton, correspond réellement à plusieurs fronts successifs) : du
coup, parfois la diode reste éteinte ou bien au contraire reste allumée. Pour remédier à ce disfonctionnement, il
faut sauvegarder l’état précédent du bouton poussoir et n’inverser l’état de la diode LED que si l’état du bouton est
différent de son ancien état et qu’il est haut. Ce qui nous donne le programme suivant :
Manipulation 03 :
Nous allons réaliser un dé numérique à l’aide de trois diodes LED. L’appuie sur le bouton poussoir va générer un
numéro aléatoire entre 1 et 6 :
OFPPT/DRIF/ISTA 2 SAFI 50
Guide des travaux pratiques Informatique industrielle
Pour générer un numéro aléatoire, il faut utiliser les fonctions randomSeed() et random() :
Pour récupérer la valeur renvoyée par random() bit par bit, il suffit d’appliquer des masques avec les valeurs
binaires B001, B010 et B100.
OFPPT/DRIF/ISTA 2 SAFI 51
Guide des travaux pratiques Informatique industrielle
TP 3 : GESTION DU CLAVIER
Manipulation 01 :
Au cours de cette manipulation, vous devez réaliser un montage qui permet de lire le numéro du bouton
appuyé par l’utilisateur et d’envoyer son code sur le moniteur série de l’Arduino.
Manipulation 02 :
Au cours de cette manipulation vous allez réaliser une serrure codée.
Un code à plusieurs chiffres (4 chiffres par exemple) doit être saisi pour ouvrir une porte. Le programme
commence par envoyer le message « Saisir code » sur le moniteur série. Si le code saisi est correct, une diode
LED s’allume et le message « code correct » est envoyé sur le moniteur série, sinon on envoie le message « code
erroné » suivi de « Saisir code » (dans notre exemple le code correct est : 1234).
OFPPT/DRIF/ISTA 2 SAFI 52
Guide des travaux pratiques Informatique industrielle
OFPPT/DRIF/ISTA 2 SAFI 53
Guide des travaux pratiques Informatique industrielle
Résultat d’exécution :
OFPPT/DRIF/I
STA 2 SAFI 54
Guide des travaux pratiques Informatique industrielle
Résultat exécution :
OFPPT/DRIF/ISTA 2 SAFI 55
Guide des travaux pratiques Informatique industrielle
lcd.scrollDisplayLeft() : Décale le contenu de l'écran (texte et curseur) d'un espace vers la gauche ; puisque la
chaine « Mohamed Ben Ali » contient 15 caractères, il faut décaler le curseur 15 fois à gauche pour la faire
disparaitre de l’écran.
lcd.scrollDisplayRight() : Décale le contenu de l'écran (texte et curseur) d'un espace vers la droite ; notre but est
de faire réapparaitre le texte ensuite le décaler vers la droite pour le faire disparaitre. Du coup, il nous faut un
décalage de 31 fois (15 : longueur de la chaine + 16 : longueur d’une ligne de l’écran).
Une fois le texte disparait vers la droite, il faut le faire réapparaitre avec un deuxième décalage à gauche de 16
caractères et revenir à la situation initiale.
Résultat d’exécution :
Manipulation 02 :
Reprenez la manipulation du TP précédent (serrure codée) et utilisez l’afficheur LCD à la place du moniteur série.
OFPPT/DRIF/ISTA 2 SAFI 56
Guide des travaux pratiques Informatique industrielle
Résultat d’exécution :
OFPPT/DRIF/ISTA 2 SAFI 57
Guide des travaux pratiques Informatique industrielle
Manipulation 03 :
Vous allez réaliser un jeu où il faut deviner un nombre choisi au hasard par le programme :
OFPPT/DRIF/ISTA 2 SAFI 58
Guide des travaux pratiques Informatique industrielle
Résultat d’exécution :
OFPPT/DRIF/ISTA 2 SAFI 59
Guide des travaux pratiques Informatique industrielle
Manipulation 02 :
Lors de la précédente manipulation, vous avez remarqué que les valeurs affichées sur le moniteur série sont
comprises entre 0 et 1023. Modifiez votre programme pour qu’il calcule les valeurs réelles de la tension lue
(comprises entre 0 et 5V) et les affiche sur un afficheur LCD.
OFPPT/DRIF/ISTA 2 SAFI 60
Guide des travaux pratiques Informatique industrielle
L’utilisation de la fonction map(), permet de calculer la tension d’entrée à partir de la valeur numérique (l’équivalent
de la règle de trois). La conversion se fait par rapport à 5000 pour avoir plus de précision et ne pas se retrouver avec
uniquement six valeurs (0, 1, 2, 3, 4, 5). Ensuite le résultat obtenu est divisé par 1000 pour retrouver la valeur de la
tension en volts.
Manipulation 03 :
Commandez le clignotement d’une diode LED à l’aide du potentiomètre : plus la valeur de la tension lue est
grande, plus le clignotement de la diode est rapide et inversement.
Il suffit de gérer l’intervalle d’attente entre le changement d’état de la diode LED par la valeur de la tension lue
à partir du potentiomètre.
Manipulation 04 :
Commandez la luminosité d’une diode LED à l’aide du potentiomètre : plus la valeur de la tension lue est grande,
plus la luminosité de la diode augmente et inversement.
OFPPT/DRIF/ISTA 2 SAFI 61
Guide des travaux pratiques Informatique industrielle
Résultat d’exécution :
La diode est branchée sur la sortie 9 qui utilise le module PWM. La valeur lue à partir du potentiomètre ne
pourra pas être renvoyée directement vers la diode LED. Elle doit être formatée à l’aide de la fonction map() qui
nous permettra de passer d’une valeur comprise entre 0 et 1023 (sortie du CAN sur 10 bits) à une valeur
comprise entre 0 et 255 (rapport cyclique du PWM).
Manipulation 05 :
Réalisez une jauge électronique à l’aide de 5 diodes LED : plus la tension augmente plus le nombre de diodes
allumées augmente
OFPPT/DRIF/ISTA 2 SAFI 62
Guide des travaux pratiques Informatique industrielle
Explication de l’instruction digitalWrite(pin[i],(niveau >= i)?HIGH : LOW) : si « niveau » est supérieur ou égal à « i
», alors « pin[i] » reçoit « HIGH » sinon elle reçoit « LOW ».
OFPPT/DRIF/ISTA 2 SAFI 63
Guide des travaux pratiques Informatique industrielle
TP 6 : L’acquisition de la température et de
l’humidité : le capteur DHT11
Manipulation 01 :
Téléchargez la bibliothèque DHT11.h et ajoutez-la au dossier des bibliothèques de l’Arduino.
Testez le bon fonctionnement du programme en affichant les résultats sur le moniteur série.
DHT11-RETRY_DELAY : c’est le délai minimum entre deux lectures successives du capteur. Ce délai est fixé
par la datasheet du capteur et au niveau de sa bibliothèque à 1000 ms.
OFPPT/DRIF/ISTA 2 SAFI 64
Guide des travaux pratiques Informatique industrielle
Manipulation 02 :
Modifiez le programme précédent pour afficher les valeurs de la température et de l’humidité sur un afficheur LCD.
Ajoutez deux diodes LED l’une pour contrôler la température et l’autre pour l’humidité (les LED s’allumeront
lorsqu’on atteint un seuil bien déterminé de température ou d’humidité ; essayez de faire varier les valeurs de
température et d’humidité pour atteindre ces seuils et allumer les LED)
Résultat d’exécution :
OFPPT/DRIF/ISTA 2 SAFI 65
Guide des travaux pratiques Informatique industrielle
Ecrire un programme qui permet de lire la distance à partir du capteur et d’envoyer l’information sur le
moniteur série de l’Arduino (la distance doit être exprimée en cm).
Résultat d’exécution :
Manipulation 02 :
Ajoutez un deuxième capteur à votre montage. Le but est de réaliser un détecteur d’obstacle. Le premier
capteur détecte un obstacle à droite (distance inférieure à 5 cm) et votre programme affiche le message «
obstacle à droite » sur le moniteur série et le deuxième capteur détecte un obstacle à gauche et le programme
affiche « obstacle à gauche ».
OFPPT/DRIF/ISTA 2 SAFI 66
Guide des travaux pratiques Informatique industrielle
Résultat d’exécution :
Manipulation 03 :
Modifier le montage précédent en ajoutant un afficheur LCD. Le but de cette manipulation est d’afficher
tous les messages sur l’écran de l’afficheur au lieu de les envoyer au moniteur série.
OFPPT/DRIF/ISTA 2 SAFI 67
Résultat d’exécution :
Guide des travaux pratiques Informatique industrielle
OFPPT/DRIF/ISTA 2 SAFI 68
Guide des travaux pratiques Informatique industrielle
Lancez l’exemple de la bibliothèque « Sweep » qui permet de piloter le servomoteur, avec un pas de 1°, de 0° à 180°
et inversement d’une façon continue.
Manipulation 02 :
Le but de cette manipulation est de commander le servomoteur à l’aide d’un potentiomètre ; lorsque l’axe du
potentiomètre tourne, le bras du servomoteur doit tourner à son tour et dans le même sens.
OFPPT/DRIF/ISTA 2 SAFI 69
Guide des travaux pratiques Informatique industrielle
Manipulation 03 :
Reprenez le programme de la manipulation 02 du TP8 (utilisation de deux capteurs pour détecter les
obstacles à droite et à gauche). Modifiez ce programme pour qu’il commande le servomoteur de telle sorte
que lorsque l’obstacle détecté est à gauche, il fait tourner le ras du servomoteur à droite et inversement.
OFPPT/DRIF/ISTA 2 SAFI 70
Guide des travaux pratiques Informatique industrielle
OFPPT/DRIF/ISTA 2 SAFI 71
Guide des travaux pratiques Informatique industrielle
- Face avant :
OFPPT/DRIF/ISTA 2 SAFI 72
Guide des travaux pratiques Informatique industrielle
- Fenêtre du diagramme :
1 : c’est la partie de configuration ; elle est équivalente à la fonction setup() dans le sketch Arduino. C’est
à ce niveau qu’on fait la configuration du port série
2 : c’est la fonction digitalWrite() équivalente à la fonction Arduino qui prend en argument le numéro de la
sortie et la valeur à envoyer ( un appui sur le bouton poussoir envoie un niveau haut)
3 : c’est le rectangle gris qui encadre tous les autres éléments ; il s’agit de la boucle infinie voidloop()
Manipulation 02 :
- Face avant de l’exemple de la commande du servomoteur :
OFPPT/DRIF/ISTA 2
SAFI 73
Guide de travaux pratiques Informatique industrielle
- Face Diagramme :
1 : initialisation de la sortie vers le servomoteur (cette sortie restera occupée tant que
la connexion avec le servomoteur est active
2 : envoi de la valeur du rapport cyclique à la sortie PWM vers le servomoteur
3 : fermeture de la connexion avec le servomoteur
OFPPT/DRIF/ISTA 2 SAFI 74
Annexes Informatique industrielle
Annexe 1 :
Introduction à l'algorithmique
PRÉSENTATION
PRÉSENTATION INFORMELLE
Ces notions sont très répandues dans la vie courante. Un algorithme peut
par exemple y prendre la forme :
RAPIDE HISTORIQUE
OFPPT/DRIF/ISTA 2 SAFI 75
Annexes Informatique industrielle
En résumé, il doit être bien clair que cette notion d'algorithme dépasse, de
loin, l'informatique et les ordinateurs. Nécessite un vocabulaire partagé, des
opérations de base maîtrisées par tous et de la précision.
LANGAGE DE DESCRIPTION
PREMIERS ÉLÉMENTS
Instructions de sorties
OFPPT/DRIF/ISTA 2 SAFI 76
Annexes Informatique industrielle
VARIABLES ET TYPES
Une variable est constitué d'un nom et d'un contenu, ce contenu étant d'un
certain type. Les types différents : booléen, caractère, chaîne de caractères,
nombre entier, nombre réel, etc.
Le rôle des boucles est d'itérer un bloc d'instructions, soit un nombre précis
de fois, soit relativement à une condition.
OFPPT/DRIF/ISTA 2 SAFI 77
Annexes Informatique industrielle
Si Alors Sinon
Algorithme QueFaireCeSoir
Début
Si Pluie
Alors
MangerPlateauTélé
SeCoucherTot
Sinon
MangerAuRestaurant
AllerAuCinema
Fin si
Fin
Boucle Fois
Fois 3 faire
Avancer
Fin Fois
Boucle Pour
Par exemple,
OFPPT/DRIF/ISTA 2 SAFI 78
Annexes Informatique industrielle
D'abord, avec la boucle tant que (il faut initialiser i avant la boucle, et
l'augmenter de 1 à chaque passage) :
Algorithme CompteJusqueCentVersionTQ
Variable i : entier
Début
i ← 1
Tant que (i ≤ 100) faire
Écrire(i)
ALaLigne
i ← i+1
Fin tant que
Fin
De même avec la boucle répéter (noter que la condition d'arrêt est ici la
négation de la condition du tant que):
Algorithme CompteJusqueCentVersionRepeter
Variable i : entier
Début
i ← 1
Répéter
Écrire(i)
ALaLigne
i ← i+1
Jusqu'à (i > 100)
Fin
OFPPT/DRIF/ISTA 2 SAFI 79
Annexes Informatique industrielle
Alors
Écrire(n)
ALaLigne
CompteJusqueCentRecursif(n+1)
Fin si
Fin
TYPES ABSTRAITS
FORMALISME
opérations et signature
pré-conditions et axiomes
opérations complexes
Constructeurs
zero : ∅ → Entier
succ : Entier → Entier
prec : Entier → Entier
pré-condition pour prec(n) : estnul(n) est faux
Testeur
estnul : Entier → Booléen
Afficheur
afficheentier : Entier → ∅
Axiomes
estnul(zero()) = vrai
estnul(succ(n)) = faux
succ(prec(n)) = n
prec(succ(n)) = n
OFPPT/DRIF/ISTA 2 SAFI 80
Annexes Informatique industrielle
Constructeurs
pilevide : ∅ → Pile
ajoute : Élément × Pile → Pile
Accesseur
sommet : Pile → Élément
pré-condition pour sommet(p) : estvide(p) est faux
Modifieur
depile : Pile → Pile
pré-condition pour depile(p) : estvide(p) est faux
Testeur
estvide : Pile → Booléen
Afficheur
affichepile : Pile → ∅
Copieur
copiepile : Pile → Pile
Axiomes
estvide(pilevide()) = vrai
estvide(ajoute(e,p)) = faux
sommet(ajoute(e,p)) = e
depile(ajoute(e,p)) = p
OFPPT/DRIF/ISTA 2 SAFI 81
Annexes Informatique industrielle
Constructeurs
créer_étudiant : Texte × Texte × Texte → Étudiant
Accesseurs
nom_étudiant : Étudiant → Texte
prénom_étudiant : Étudiant → Texte
naissance_étudiant : Étudiant → Texte
noteinfo_étudiant : Étudiant → Entier
notemath_étudiant : Étudiant → Entier
notediscipline_étudiant : Texte × Étudiant → Entier
Modifieur
modifier_noteinfo : Étudiant × Entier → Étudiant
modifier_notemath : Étudiant × Entier → Étudiant
Afficheur
afficher_étudiant : Étudiant → ∅
Axiomes
nom_étudiant(créer_étudiant(n,p,d)) = n
prénom_étudiant(créer_étudiant(n,p,d)) = p
naissance_étudiant(créer_étudiant(n,p,d)) = d
noteinfo_étudiant(modifier_noteinfo(e,n)) = n
notemath_étudiant(modifier_notemath(e,n)) = n
notediscipline_étudiant('info',modifier_noteinfo(e,n)) = n
notediscipline_étudiant('math',modifier_notemath(e,n)) = n
Première version.
Type abstrait « Tableau »
Utilise « Entier » et « Élément »
Constructeurs
créer_tableau : Entier → Tableau
Accesseurs
contenu : Tableau × Entier → Élément
taille : Tableau → Entier
pré-condition pour contenu(t,n) : 1 ≤ n ≤ taille(t)
Modifieur
fixecase : Tableau × Entier × Élément → Tableau
pré-condition pour fixecase(t,n,e) : 1 ≤ n ≤ taille(t)
Afficheur
affichetableau : Tableau → ∅
Copieur
copietableau : Tableau → Tableau
OFPPT/DRIF/ISTA 2 SAFI 82
Annexes Informatique industrielle
Axiomes
taille(créer_tableau(n)) = n
contenu(fixecase(t,n,e),n) = e
Constructeurs
créer_tableau : Entier → Tableau
Accesseurs
_[_] : Tableau × Entier → Élément
taille : Tableau → Entier
pré-condition pour contenu(t,n) : 1 ≤ n ≤ taille(t)
Modifieur
_[_] = _ : Tableau × Entier × Élément → Tableau
pré-condition pour t[n]=e : 1 ≤ n ≤ taille(t)
Afficheur
affichetableau : Tableau → ∅
Copieur
copietableau : Tableau → Tableau
Axiomes
taille(créer_tableau(n)) = n
contenu(fixecase(t,n,e),n) = e
ALGORITHMES DE BASE
OFPPT/DRIF/ISTA 2 SAFI 83
Annexes Informatique industrielle
4 2 5 1 3
I MAX
- 4
2 4
3 5
4 5
5 5
Pour mesurer la complexité d'un algorithme, il faut tout d'abord désigner une
ou plusieurs opérations élémentaires utilisées par l'algorithme. Dans le cas de
la recherche du maximum d'un tableau, ces opérations pourront être :
OFPPT/DRIF/ISTA 2 SAFI 84
Annexes Informatique industrielle
Algorithme général :
Algorithme Recherche (e : entier ; t : tableau d'entiers)
{ Indique si l'élément e est présent ou non dans le tableau t }
Variable i : entier
Début
OFPPT/DRIF/ISTA 2 SAFI 85
Annexes Informatique industrielle
i ← 1;
Tant que (i ≤ taille(t)) et (t[i] ≠ e) faire
i ← i+1
Fin tant que
Si (i>taille(t))
Alors Écrire("l'élément recherché n'est pas présent")
Sinon Écrire("l'élément recherché a été découvert")
Fin si
Fin
Mais si les éléments du tableau sont ordonnés, nous pour vous pouvons
tirer parti de cette caractéristique.
Algorithme RechercheO (e : entier ; t : tableau d'entiers)
Variable i : entier
trouve : booléen
Début
i ← 1
Tant que (i ≤ taille(t)) et (t[i] < e) faire:
i ← i+1
Fin TQ
Si (i ≤ taille(t)) et (t[i]=e) alors
Écrire('oui')
Sinon
Écrire('non')
Fin si
Fin
OFPPT/DRIF/ISTA 2 SAFI 86
Annexes Informatique industrielle
Algorithme d'échange
Algorithme Échange (t : tableau d'entiers ; i,j : entiers)
{ Échange le contenu des cases i et j dans le tableau t }
Variable pro : entier
Début
pro ← t[i]
t[i] ← t[j]
t[j] ← pro
Fin
Tri insertion
Algorithme TriInsertion (t : tableau d'entiers)
{ Trie par ordre croissant le tableau t }
Variable i : entier
Début
Pour i ← 2 à taille(t) faire
Insertion(t,i-1,t[i])
Fin Pour
Fin
Tri extraction
Tri à bulles
Algorithme TriBulles (t : tableau d'entiers)
{ Trie par ordre croissant le tableau t contenant n éléments }
Variables i,j : entier
OFPPT/DRIF/ISTA 2 SAFI 87
Annexes Informatique industrielle
Début
Pour i ← 1 à taille(t)-1 faire
Pour j ← 1 à taille(t)-i faire
Si t[j] > t[j+1]
Alors Échange(t,j,j+1)
Fin Si
Fin Pour
Fin Pour
Fin
Pour que cette méthode soit la plus efficace possible, il faut que le pivot
coupe le tableau en deux sous-tableaux de tailles comparables.
Ainsi, si l'on choisit à chaque le plus petit élément du tableau comme pivot,
on se retrouve dans le cas de l'algorithme de tri par extraction : la taille du
tableau de diminue que d'un à chaque alors que le but est de diviser cette
taille par deux.
OFPPT/DRIF/ISTA 2 SAFI 88
Annexes Informatique industrielle
Début
Si d<f alors
k ← Placer(t,d,f)
TriRapideBoucle(t,d,k-1)
TriRapideBoucle(t,k+1,f)
Fin si
Fin
Complexité
Dans le but de mesurer la complexité d'un algorithme de tri, deux quantités
sont à observer :
• le nombre d'échanges effectués,
• le nombre de comparaisons effectuées entre éléments du tableau.
COMPLEXITÉ
complexité en 2n (exponentielle)
RÉFLEXIONS
Loi de Moore : la rapidité des processeurs double tous les 18 mois. Dans le
cas du voyageur de commerce, le fait de doubler la vitesse de calcul ne
permet, dans le même temps, que de traiter une ville supplémentaire.
OFPPT/DRIF/ISTA 2 SAFI 89
Annexes Informatique industrielle
Pour cela, considérons l'algorithme suivant qui n'est qu'une simple utilisation
de l'algorithme TestArrêt.
Nous devons conclure qu'une telle ville avec de tels habitants ne peut
exister et, de la même manière, l'algorithme TestArrêt n'existe pas non plus.
CONCLUSION
OFPPT/DRIF/ISTA 2 SAFI 90
Annexes Informatique industrielle
OFPPT/DRIF/ISTA 2 SAFI 91
Annexes Informatique industrielle
Annexe 2
LANGAGE C
Les bases
I- Introduction ____________________________________________________________
II- Notions de base. _________________________________________________________
1- Compilateur sensible à la casse. ____________________________________________
2- Commentaires. __________________________________________________________
3- Types de base. ___________________________________________________________
a- Caractère :char. _____________________________________________________________
b- Entiers : int. ______________________________________________________________
c- Réels. _____________________________________________________________________
4- Représentation des valeurs ________________________________________________
a- Valeurs caractères. __________________________________________________________
b- Valeurs chaines de caractères. _________________________________________________
c- Valeurs entières. ____________________________________________________________
d- Valeurs réelles. _____________________________________________________________
5- Déclarations. ____________________________________________________________
a- constantes symboliques. ______________________________________________________
b- Variables. __________________________________________________________________
III- Les opérateurs. ________________________________________________________
1- Affectation. _____________________________________________________________
2- Incrémentation / Décrémentation. __________________________________________
3- Opérateurs arithmétiques. _________________________________________________
4- Opérateurs relationnels.___________________________________________________
5- Opérateurs logiques. _____________________________________________________
6- Opérateurs de bits. _______________________________________________________
7- Opérateur conditionnel. ___________________________________________________
8- Opérateur virgule. _______________________________________________________
9- Affectation composée. ____________________________________________________
10- Forceur de type. _______________________________________________________
11- Précédences. __________________________________________________________
12- Impression formatée. ___________________________________________________
OFPPT/DRIF/ISTA 2 SAFI 92
Annexes Informatique industrielle
OFPPT/DRIF/ISTA 2 SAFI 93
Annexes Informatique industrielle
OFPPT/DRIF/ISTA 2 SAFI 94
Annexes Informatique industrielle
OFPPT/DRIF/ISTA 2 SAFI 95
Annexes Informatique industrielle
I- Introduction
.
Langage créé dans les années 70, par la Bell Tel Lab, par Kernighan Ritchie pour
l’écriture du système UNIX.
Conçu comme :
super assembleur :
mais :
2- Commentaires.
/* texte commentaire */
3- Types de base.
a- Caractère :char.
OFPPT/DRIF/ISTA 2 SAFI 96
Annexes Informatique industrielle
Le type char est signé à cause de la marque de fin de fichier EOF qui vaut -1.
b- Entiers : int.
Les entiers peuvent être signés ou non (signed ou unsigned), courts ou long
(short ou long). Par défaut, il s’agit d’entiers courts signés.
int (ou short int ou signed int ou signed short int) : sur 2 octets
Valeurs comprises entre -32768 et +32767
unsigned int (ou unsigned short int) : sur 2 octets
Valeurs comprises entre 0 et +65535
long int (ou long ou signed long int) :sur 4 octets
Valeurs comprises entre -2.147.483.648 et +2.147.483.647
unsigned long int : sur 4 octets
Valeurs comprises entre 0 et +4.294.967.295
c- Réels.
Pour stocker les réels, on dispose de deux types, le type flottant simple précision
(float) et le type flottant double précision (double).
float : sur 4 octets (1octet pour l’exposant et son signe, 3 octets pour la mantisse et
son signe)
Valeurs absolues comprises entre 9,9x 10-38 et 9,9x 10+38
double : sur 8 octets (11 bits pour l’exposant et son signe, 53 bits pour la mantisse et
son signe)
Valeurs absolues comprises entre 9,9x 10-307 et 9,9x 10+307
a- Valeurs caractères.
1 caractère entre ‘ ‘
Combinaison de caractères
‘\n’ passage à la ligne
‘\t’ tabulation
‘\b’ back space
‘\r’ retour chariot
‘\f’ saut de page
OFPPT/DRIF/ISTA 2 SAFI 97
Annexes Informatique industrielle
″ chaîne ″
″ exemple de \n texte sur \n 3 lignes ″
un marqueur de fin de chaîne est ajouté ‘\0’ NUL ASCII
Une chaîne occupe toujours un octet de plus que le nombre de caractères.
c- Valeurs entières.
Par défaut, les valeurs entières sont exprimées en base 10 et stockées sur des short
int.
Exemples : -32 5678
Si on veut qu’elles soient stockées en long int, il faut faire suivre la valeur de L.
Exemple : 1234567L
Si on veut exprimer les valeurs en base 8 (ou 16), il faut faire précéder la valeur de O
(ou Ox ou OX). Exemples : 020 correspond à (16)10 0x20 à (32)10
d- Valeurs réelles.
Elles sont exprimées en notation virgule fixe ou virgule flottante, et stockées en
double.
5- Déclarations.
a- constantes symboliques.
#define PI 3.14592358
#define E 2.718281828
#define entier int
#define debut {
#define fin }
OFPPT/DRIF/ISTA 2 SAFI 98
Annexes Informatique industrielle
Remarque :
les mot-clés commençant par # sont des directives de précompilation, qui sont traitées
avant la compilation. La directive #define permet de remplacer dans le texte source
toutes les occurrences de <ident> par <expression>.
b- Variables.
Exemples :
int i, j ;
double t ;
long k ;
char reponse ;
int tab[10] ; /* tableau de10 entiers*/
Initialisation à la déclaration :
int i = 0 ;
double t = 0.1 ;
1- Affectation.
<ident> = <expression> ;
L’affectation peut être vue comme une fonction renvoyant la valeur affectée, on peut
donc enchaîner les affectations.
i = 3 ;
f = -5E3 ;
k = total + 1 ;
c = 2 ;
a = (b = c) + 4 ; /* a vaut 6*/
Le membre de gauche doit être d’un type de base (pas d’affectation de tableau).
2- Incrémentation / Décrémentation.
OFPPT/DRIF/ISTA 2 SAFI 99
Annexes Informatique industrielle
++
préfixé sur une variable => avant accès
ou postfixé sur une variable => après accès
--
i=2;j=2 ;
i=2;j=2 ;
3- Opérateurs arithmétiques.
En ce qui concerne la division, si l’une des expressions est réelle, alors la division est
réelle, sinon il s’agit d’une division entière.
Pour le modulo (reste de la division entière), le signe du reste est celui du dividende.
Exemples :
15%2 /* vaut 1 */
-15%2 /* vaut -1 */
15%-2 /* vaut 1 */
-15%-2 /* vaut -1 */
b * (a/b)+ a%b ≡ a
4- Opérateurs relationnels.
En C, il n’y a ni type ni valeur booléens. Les booléens sont exprimés par des int, la
valeur 1 correspondant à VRAI et la valeur 0 à FAUX.
5- Opérateurs logiques.
6- Opérateurs de bits.
~ <exp2> /* complément à 1 */
<exp1> & <exp2> /* ET bit à bit */
<exp1> | <exp2> /* OU inclusif bit à bit */
<exp1> ^ <exp2> /* OU exclusif bit à bit */
La valeur de <exp1> est décalée à droite de valeur de <exp2> bits. Si <exp1> est
unsigned, remplissage à gauche par des 0. Sinon, remplissage par des 0 si <exp1>
positive ou nulle, ou remplissage par des 1 si <exp1> est négative (Mais à vérifier en
fonction du compilateur).
7- Opérateur conditionnel.
8- Opérateur virgule.
<exp1>,<exp2>
L’opérateur virgule est un séquenceur d’actions. <exp1> est d’abord évaluée, mais
son résultat n’est pas pris en compte, puis <exp2> est évaluée et retournée. Une telle
formulation n’a de sens que si <exp1> produit un « effet de bord ».
Exemple :
a=b +(c=2,++c) ;
for(i=0,j=MAX;i<MAX;i++,j--)
{-----}
9- Affectation composée.
Exemples :
i +=3 ; /* i=i+3 */
x *= y+1 ; /* x=x*(y+1) */
a /= b–c ; /* a=a/(b–c) */
(<nouveau-type> ) <exp>
11- Précédences.
Dans ce tableau, les opérateurs sont présentés selon leurs priorités décroissantes du
haut vers le bas. La plupart des opérateurs sont binaires, sauf ceux marqués
explicitement unaires, ainsi que l’opérateur ternaire ?:.
Lorsqu’une expression comporte des opérateurs de même priorité, l’évaluation se fait
de la gauche vers la droite, sauf en ce qui concerne les opérateurs de la seconde ligne
et de l’avant dernière ligne du tableau.
Exemples :
printf(″\nBonjour″);
Exemples :
caractères, qui sont en fait des tableaux de caractères, ce ne sera pas nécessaire, car le
nom d’un tableau est identique à l’adresse de son premier élément.
char libelle[MAX];
-----
scanf(″%d%f″,&pourcentage,&prix);
scanf(″%s″,libelle);
Exemple :
scanf(″%d%*s%d%*s%d%*s″,&heures,&minutes,&secondes) ;
17 H 35 min 30 secondes
Affectations produites:
Heures 17
Minutes 35
Secondes 30
1- Séquence.
{ a1 ; a2 ; }
; terminaison d’instruction
{
<déclarations locales>
<suite instructions> joue le rôle d’une instruction
}
2- Répétitions.
. do <instructions> while(<expression>)
Test en fin de boucle => exécuté au moins une fois.
. for(<exp1>;<exp2>;<exp3>)<inst> ;
Test de continuation
Initialisation avant boucle
for(i=0;i<n;i++)
if(tab[i]==a)break; /*récupère i correspondant à tab[i]= a
*/
3- Choix.
a- Choix simple.
if(<exp>) <inst> ;
if(<exp>) <inst1> else <inst2>
if(a<b)
if(c<d)u=0;
else i=j;
if(a>b)
{ if(c<d)u=v;}
else i = j ;
b- Choix multiple
switch ( <exp0> )
{
case < exp1 >: < suite inst1 > ; break;
case < exp2 >: < suite inst2 > ; break;
...
case < expn >: < suite instn > ; break;
default : <inst>
}
Plusieurs cas peuvent correspondre à la même suite d’instructions, ce qui permet de
faire un OU logique entre plusieurs cas. Exemple :
char rep ;
rep=getchar() ;
switch(rep)
{case ‘o’:
case ‘O’:printf(“\nLa réponse est oui”);break;
case ‘n’:
case ‘N’ :printf(“\nLa réponse est non”);break;
default : printf(« \nLa réponse est inconnue ») ;
}
switch(cara)
{case ‘a’:
case ‘e’:
case ‘i’:
case ‘o’:
case ‘u’ :
case ‘y’ :nb_voyelles++;break;
default : nb_consonnes++ ;
}
4- Instruction vide.
Exemples :
Remarques :
c=0;
if(c=0) <inst1>;
else <inst2>; /* on passe toujours par inst2 */
rep=‘n’;
while(rep==‘0’||‘0’) /* toujours vrai */
{…}
V- Les sous-programmes en C.
1- Généralités.
Une seule classe de sous-programme, la fonction, qui regroupe les notions de fonction
et de procedure de PASCAL ou ADA.
Une seule syntaxe de déclaration, mais deux syntaxes différentes d’appel, selon qu’il
s’agisse d’une fonction ou d’une procedure.
Toutes les fonctions d’un programme sont au même niveau, il n’y a pas d’imbrication
possible.
2- Déclaration de fonction.
en C KR
<type-résultat> <ident-fonction>(<liste de paramètres
formels>)
<déclarations de paramètres formels>)
{ <déclarations locales>
<instructions>
}
Attention, ici, la spécification, c’est-à-dire l’en-tête, ne mentionne pas les types des
paramètres.
En C ANSI
<type-résultat> <ident-fonction>( <déclarations de
paramètres formels>)
{ <déclarations locales>
<instructions>
}
Ici, la spécification, c’est-à-dire l’en-tête, mentionne les types des paramètres, ce qui
est plus rigoureux, surtout dans le cadre de l’utilisation de bibliothèques.
<type-résultat> qui indique le type du résultat renvoyé par la fonction, doit être un
type de base ou un pointeur. Ce ne peut être un tableau ou une structure (sauf en C
ANSI). Si <type-résultat> est absent, il est considéré comme int.
Remarques :
Si la fonction joue le rôle d’une procedure, <type-résultat> doit être remplacé par
void, et le corps de la fonction ne comportera pas de return.
Exemple d’une fonction renvoyant le maximum de 2 entiers passés en paramètres :
3- Appel de fonction.
Syntaxe :
<ident-fonction>(liste de paramètres effectifs)
Les paramètres effectifs sont des expressions du même type que les paramètres
formels correspondants.
Fonction
appelée
Appel fonction
Les paramètres formels jouent le rôle de variables locales dans lesquelles sont
recopiées les valeurs des paramètres effectifs correspondants. Dans ce mode de
transmission, l’information venant des paramètres est entrante vis-à-vis du sous-
programme.
Si l’on veut modifier de l’information dans l’appelant par le biais des paramètres, il
faut que les paramètres formels soient déclarés comme pointeurs, et travailler par
indirection dans le corps de la fonction.
Remarque :
a- Variables locales.
toute variable déclarée dans un bloc est locale à ce bloc et globale pour toute la
hiérarchie descendante des blocs imbriqués. Le domaine de visibilité est le bloc de
déclaration.
static : variable locale ayant la propriété de rémanence, non allouée dans la pile. Si
elle est l’objet d’une initialisation à le déclaration, cette dernière n’a lieu que lors du
premier appel à la fonction.
register : attribut réservé aux variables entières ou pointeur, très utilisées qui vont
être représentées par un registre. Cette possibilité est plutôt dédiée à la programmation
système.
c- Variables externes.
fichier1.c fichier2.c
int i ;
int f1(int n)
extern int i ;
{-------;
int f4(float y)
--------
{-------;
--------
--------
}
--------
float f2(int n)
}
{-------;
float f5()
--------
{-------;
--------
--------
}
--------
void main()
}
{-------;
--------
--------
}
int f1(int n)
{-------;
--------
--------
}
float f2(int n)
{-------;
--------
--------
}
void main()
{-------;
--------
m = f1(10) ;
y = f2(21) ;
--------
}
soit :
int f1(int );
float f2(int );
void main()
{-------;
--------
m = f1(10) ;
y = f2(21) ;
--------
}
int f1(int n)
{-------;
--------
--------
}
float f2(int n)
{-------;
--------
--------
}
Il est à noter que dans la première configuration, f2() peut appeler f1() mais
f1() ne peut appeler f2().
module1.h module2.h
int f1(int n) ; int f3(int n) ;
float f2(int n); float f4(int n);
principal.exe
1- Déclaration de tableau.
Syntaxe de déclaration :
Il est préférable, en général, de déclarer une constante pour la taille des tableaux :
#define N 100
---------
---------
int tab[N] ;
Déclaration d’un tableau de 100 entiers. Les éléments sont numérotés de 0 à 99.
#define N 4
int tab[N]={2,12,24,26} ;
S’il manque des valeurs dans l’accolade, par rapport au nombre d’éléments
déclarés, les valeurs manquantes sont initialisées à 0.
En C ANSI, il est possible d’initialiser les tableaux locaux à la déclaration, mais s’il
existe des valeurs manquantes, elles sont indéterminées.
Pour les chaînes de caractères, qui, en C, sont des tableaux de caractères comportant
un caractère terminateur de chaîne, ‘\0’, il est possible de procéder de deux
manières :
char chaine[8]={‘b’,’o’,’n’,’j’,’o’,’u’,’r’,’\0’} ;
Ou bien :
ident-tableau> [ <expression-entière> ]
1- Définition.
Un pointeur est une variable contenant l’adresse mémoire d’une autre variable.
2- Déclaration de pointeur.
aux déclarations factorisées, l’étoile doit être répétée. On a déclaré ici, un pointeur
d’entier, un pointeur de caractère et deux pointeurs de réels.
3- Opérateur adresse.
4- Opérateur d’indirection.
i 2
*p = 2; /* i prend la valeur 2 */
k = *P + 1 ; /* k prend la valeur 3 */
Soit un tableau de 4 entiers. Le nom du tableau, nous le verrons plus tard, contient
l’adresse du premier élément.
Mémoire
tab
Nous avons vu qu’il n’y a qu’un seul mode de transmission des paramètres en C, la
transmission par valeur. Si nous voulons avoir le mode par variable de PASCAL ou in
out de ADA, il faut le simuler en déclarant le paramètre formel comme un pointeur, et
en passant comme paramètre effectif l’adresse de la variable à modifier dans
l’appelant.
Exemple d’une fonction travaillant comme une procedure en ADA, doublant la valeur
de la variable entière passée en paramètre :
void doubleEntier(int * p)
{
* p= 2 * (*p) ;
}
main()
{int i= 10 ;
doubleEntier(&i) ;
printf("\n%d",i) ;/*affiche 20 */
main()
{int i= 10 ,j= 20;
echange(&i,&j) ;
printf("\n%d,%d ",i,j) ;/*affiche 20,10 */
}
a- Tableaux monodimensionnels.
L’expression d’indexation est traduite par le compilateur par une translation d’adresse
suivie d’une indirection:
Attention, il est possible (bien que totalement déconseillé) d’effectuer une indexation
sur une variable qui n’a pas été déclarée comme tableau. Ainsi :
somme+=tab[i];
return somme;
}
main()
{int T[4]={10,20,30,40};int s ;
s=sommeElements(T, 4)
printf("\n%d",s) ;/*affiche 100 */
}
b- Tableaux multidimensionnels.
tab 0
1
2
3
4
tab[1] 10
11
12
13
14
tab[2] 20
21
22
23
24
tab[i][j]=*(tab + i * taille_ligne + j)
Généralités.
Il n’y a pas de type chaîne de caractères en C. Une chaîne est représentée par un
tableau de caractères contenant un caractère marqueur de fin de chaîne, ‘\0’. Toute
fonction standard manipulant une chaîne devra connaître l’adresse de début de la
chaîne, c’est-à-dire l’adresse de son premier caractère, et terminera son travail à la
rencontre du caractère de fin ‘\0’.
char texte1[10]={‘e’,’x’,’e’,’m’,’p’,’l’,’e’,’\0’} ;
Nous reviendrons plus tard sur le travail de la notation "". C alloue de la mémoire
pour représenter la chaîne avec son ‘\0’, puis recopie cette zone mémoire dans la
zone réservée pour le tableau texte2 . 10 octets ont été réservés, alors que 8
suffisaient.
Dans ce cas, 8 octets ont été réservés, c’est-à-dire exactement la taille utile.
b- Pointeur de caractères.
texte4 est un pointeur de caractères pointant vers cette zone mémoire allouée par
"".
texte4
exemple\0
fruit
fruit[0] pomme\0
fruit[1] abricot\0
fruit[2] orange\0
fruit
pomme\0
abricot\0
Orange\0
3- Saisie de chaîne.
Attention
char * nom ;
scanf("%s",nom) ;
ne produira pas d’erreur de compilation, mais les caractères lus vont être installés
n’importe où en mémoire, puisqu’aucune place mémoire n’a été réservée.
4- Impression de chaîne.
printf({"%s",<adresse début de chaine>)
puts(<adresse début de chaine>)
b- Concaténation de chaînes.
c- Comparaison de chaînes.
strcmp(<adresse chaine1>, <adresse chaine2>)
d- Longueur de chaîne.
strlen(<adresse chaine1>)
1- Structures.
struct <ident-structure>
{ <type1> <ident1> ;
<type2> <ident2> ;
-----------------
-----------------
<typen> <identn> ;
}
<ident-structure>.<ident-champ>
3- Imbrication de structures.
5- Structures récursives.
tete
10 49 -5
NULL
En C KR, ce n’est pas possible. Dans ce cas, il faut passer en paramètres des pointeurs
de structures. Exemple d’une fonction comparant les champs année de 2 dates :
Remarque :
La combinaison de l’indirection * puis de l’accès au champ . peut se noter avec
l’opérateur ->.
(*p1).annee peut se noter p1->annee .
7- Union.
C’est une variable pouvant être de types différents selon le contexte, ce qui correspond
à la notion de RECORD à discriminant du langage ADA.
La déclaration est analogue à celle d’une structure, mais on remplace le mot struct par
union.
Pour que ce soit vraiment utilisable, il faut disposer d’une information supplémentaire
précisant quelle version de la variable utiliser.
#define ENTIER 0
#define REEL 1
struct Arithm { int categorie ;
union Nombre { int entier ;
float reel ;} u;
} ;
struct Arithm a1, a2 ;
a1.categorie= ENTIER;
a1.u.entier=12;
a2.categorie= REEL;
a2.u.reel=3.14159;
8- Allocation dynamique.
Lorsqu’on déclare une variable, la réservation de place mémoire associée est effectuée
lors de la compilation. On dit qu’il s’agit d’une allocation statique. Lorsqu’on a à
traiter un nombre variable d’informations arrivant lors de l’exécution, on utilise un
tableau en prévoyant le nombre maximum d’éléments. Cela conduit à réserver
beaucoup d’espace mémoire qui sera parfois très peu utilisé. D’autre part, il n’est pas
toujours possible de prévoir le nombre maximum d’éléments à traiter.
a- Allocation de mémoire.
malloc(<nbre d’octets>)
permet d’allouer le nbre d’octets désirés, passé en paramètre. Renvoie une adresse de
caractère ( char *) en C KR ou un pointeur anonyme en C ANSI (void *), si
l’allocation mémoire a réussi, sinon NULL.
Pour connaître la taille à allouer pour un objet structuré complexe, il est commode
d’utiliser l’opérateur sizeof :
sizeof(<ident>)
b- Libération de mémoire.
free(<adresse>)
X- Le Préprocesseur.
1- Inclusion de fichiers.
Soit :
#include "nom-de-fichier"
soit :
#include <nom-de-fichier>
Dans le premier cas, le fichier nom-de-fichier est un fichier utilisateur, qui est
recherché dans le répertoire courant.
Dans le second cas, nom-de-fichier est un fichier système recherché dans un
répertoire prédéfini.
La directive est remplacée par le contenu du fichier nom-de-fichier.
2- Macros.
a- macrodéfinition.
Exemple :
#define MAX 100
b- macrofonction.
C’est une définition de symbole avec paramètres, qui ressemble à une fonction. Il y
aura, dans un premier temps, substitution des paramètres dans le corps de la macro,
puis dans un second temps, substitution du corps à l’appel.
Exemple :
main()
{ int i=6,m;
…….
m=max(i,10);
………
la substitution donnera:
main()
{ int i=6,m;
…….
m=(((i)>(10))?(i) :(10));
…….
4- Compilation conditionnelle.
#ifdef symbole
bloc instructions 1
#else
bloc instructions 2
#endif
Si symbole a été défini par une directive #define préalablement, c’est bloc
instructions 1 qui est pris en compte dans le texte source, sinon c’est bloc instructions
2.
#ifndef à la place de #ifdef, s’interprètera : Si symbole n’a pas été défini par une
directive #define préalablement………….
1- Généralités.
Les fichiers en C sont vus comme des flots d’octets, il n’existe aucune structuration
logique ou physique en enregistrements comme c’est le cas en COBOL par exemple.
Si l’on a besoin d’une telle structuration, cette dernière reste à la charge du
programmeur.
Il existe 2 types de fichiers, les fichiers texte contenant des codes ASCII et des
passages à la ligne, et les fichiers binaires.
Il existe 2 méthodes de manipulation des fichiers :
Une méthode assistée avec buffer
Une méthode non assistée de bas niveau.
Avant tout travail sur un fichier, il faut l’ouvrir dans un certain mode de travail. Quand
les travaux sont terminés, il faut fermer le fichier.
2- Ouverture/fermeture de fichier.
a- Ouverture.
Syntaxe :
FILE * fopen(char * nom,char * mode)
FILE est un type descripteur de fichier
nom est une chaîne de caractères contenant le nom externe du fichier (nom système).
mode indique le mode d’ouverture, sous forme d’une chaîne de caractères également :
" r " lecture seule (erreur, si le fichier n’existe pas)
" w " écriture seule(écrasement, si le fichier existe)
" a" écriture en fin de fichier
#include <stdio.h>
------------
------------
------------
FILE *fd ;
if((fd=fopen("f_donnees", "rt"))==NULL)
printf("\nerreur d’ouverture");
else /* travailler sur le fichier */
{-----------
------------
------------
}
N.B.
Il existe 3 fichiers standards prédéfinis :
stdin
stdout
stderr
b- Fermeture.
int fclose(FILE * f)
3- Lecture/écriture de caractères.
a- Lecture de caractères.
int getc(FILE * f)
b- Ecriture de caractères.
Exemple :
Copie d’un fichier texte de nom « entree » dans un fichier texte de nom « sortie »,
caractère par caractère.
int c ;
FILE *fentree, *fsortie ;
4- Lecture/écriture de lignes.
a- Lecture de lignes.
Lit les caractères sur le fichier, les charge dans le tableau de caractères tampon, ou
bien jusqu’à ce qu’il ne reste qu’un seul caractère libre dans le tampon, et complète par
‘\0’.
b- Ecriture de lignes.
5- Lecture/écriture formatées.
a- Lecture formatée.
format est une chaine de caractères contenant des caractères à afficher tels quels et
des spécifications de format, comme dans le printf. Le fonctionnement est
analogue, sauf que l’écriture se fait dans le fichier f.
b- Ecriture formatée.
6- Lecture/écriture de blocs.
a- Lecture de blocs.
Le fread tente de lire nombre objets de taille taille, les installe, octet par octet
dans le tableau de caractères tampon, et renvoie le nombre d’objets effectivement
transférés.
b- Ecriture de blocs.
Le fwrite tente d’écrire nombre objets de taille taille, octet par octet depuis le
tableau de caractères tampon, vers le fichier f et renvoie le nombre d’objets
effectivement transférés.
7- Instructions de contrôle.
a- Test de fin fichier.
int feof(FILE * f)
b- Erreur d’E/S.
int ferror(FILE * f)
A chaque fichier est associé un « point de déplacement » qui indique sur quel octet on
est positionné.
A l’ouverture en lecture ou écriture, on est positionné sur le premier octet. En append
on est positionné en fin de fichier.
En accès séquentiel, la gestion du « point de déplacement » est automatique
En accès direct, ou lorsqu’on mélange les lectures et les écritures, c’est au
programmeur de se repositionner.
dep est un entier long indiquant un déplacement en octets à partir d’une certaine
origine définie par l’entier mode, dont les valeurs possibles sont :
0 début du fichier
2 fin du fichier
1 position actuelle
Pour les valeurs 0 et 2, les déplacements sont positifs, alors que pour 1 le déplacement
peut être signé.
N.B.
fseek renvoie 0 en cas de réussite, ≠ 0 en cas d’échec
void rewind(FILE * f)
équivaut à fseek(f,0L,0)
e- Position courante.
long ftell(FILE * f)