M16 Informatique Industriel

ROYAUME DU MAROC
OFPPT
Office de la Formation Professionnelle et de la

Promotion du Travail
DIRECTION RECHERCHE ET INGÉNIERIE DE FORMATION
RÉSUMÉ THÉORIQUE
&
GUIDE DE TRAVAUX PRATIQUES
MODULE N°16: INFORMATIQUE INDUSTRIELLE
SECTEUR : RÉPARATION DES ENGINS À

MOTEUR
SPÉCIALITÉ : DIAGNOSTIC ET ÉLECTRONIQUE

EMBARQUÉE
NIVEAU : TECHNICIEN SPÉCIALISÉ
OFPPT/DRIF
ÉDIT : SEPTEMBRE 2017
OFPPT/DRIF
Document élaboré par :
Nom et prénom EFP DR

ISTA 2 SAFI
Révision linguistique
-
-
-
Validation
-
-
-
Résumé de Théorie Informatique industriel
SOMMAIRE
Les modules Page

Sommaire 2
Présentation du module 3
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
PRÉSENTATION DU MODULE
- Le module Informatique industrielle est le 16éme de la liste des

modules prescrits dans le programme d’étude du Technicien Spécialisé
en Diagnostic et Electronique Embarquée. Cette compétence a pour
objectif de développer chez l’apprenant des compétences nécessaires
pour concevoir des programmes performants sur calculateurs ou
Arduino;
- Le module décrit la démarche pour concevoir un programme en
programmation procédurale et quelques autres compétences en
informatique industriel à savoir :
- L’algorithmique
- La programmation procédurale en langage C
- Les réseaux informatiques
La durée du module est estimée à 60 heures
Les travaux pratiques : 40 heures
Les notions théoriques : 14 heures
L'Épreuve de fin de module
 Théorique : 2 heures
 Pratique : 4 heures
Résumé de Théorie Informatique industrielle
Module : 16
Informatique industrielle
RESUME THEORIQUE
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.
4.1 Matériel et logiciels
Un système d'élaboration des données est composé de matériel et de logiciels.
Le matériel comprend tous les composants électroniques et mécaniques montés sur un
ordinateur ou un système informatique. L'ensemble des câbles, des prises, ainsi que les
supports de données en font partie. Exemple de matériel d'un PC (ill. 1):
 unité du système (ordinateur, processeur) pour l'élaboration des données et
périphériques pour
- entrée des données, p. ex. clavier, souris
- sortie des données, p. ex. écran, imprimante
- stockage externe des données, p. ex. disques durs, lecteurs de disquettes.
Illustration 1: système PC
Les logiciels comprennent tous les programmes et les données.
Les programmes sont composés d'une série de commandes qui, partant des instructions
de travail de l'utilisateur, sont traduites en un langage compréhensible pour la machine.
Les programmes pilotent les processus de travail et élaborent les données. On distingue
les programmes système et les programmes utilisateur {tableau 1).
Tableau 1 : Genres de programmes
Programmes système
· Systèmes d'exploitation, p. ex. DOS,
Windows 7, Windows NT, UNIX, OS/2
· Utilitaires (programmes auxiliaires)
Programmes utilisateur
· Programmes standard, p. ex. élaboration
de textes, tableurs, bases de données
· Programmes CAD
· Programmes d'applications spécifiques,
p. ex. pour la comptabilité, le calcul

technique
· Programmes de diagnostic
· Jeux
· Programmes multimédias, p. ex. lecteurs
de films, MP3
· Langages de programmation, p ex.
BASIC, Pascal, C++
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).
Illustration 2: Genre de données

4.2 Principe ETS
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.
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.
4.3 Représentation interne des données
Le circuit électrique de l'ordinateur a deux états de branchement enclenché ou déclenché
(tableau 1). Ces états de branchement sont utilisés pour la représentation des informations dans
un système à deux signes (système binaire); ainsi, le chiffre 0 correspond à l'état de
branchement déclenché et le chiffre 1 à l'état de branchement enclenché.
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).
Un bit comprend l'information 1 ou 0
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).
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.
1 octet (byte) comprend 8 bits
Un byte permet ainsi d'obtenir 28=256 possibilités de combinaisons différentes.
4.4 Systèmes arithmétiques

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.
Capacité de stockage. Les capacités de stockage des supports de données internes et

externes sont toujours indiquées en byte, code à 8 bits.
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
4.5 Structure d'un ordinateur

Le matériel constituant un ordinateur comprend l'appareil de base avec la carte-mère et
l'équipement qui y est connecté (ill. 1).
Illustration 1: Appareil de base

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.
Illustration 2: Le cœur d'un système informatique

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.
Avantages par rapport aux interfaces parallèles:
· les câbles des interfaces sérielles peuvent être plus longs (jusqu'à 150 m.) que ceux des
interfaces parallèles;
· ils sont électriquement blindés, car ils présentent une grande impédance d'entrée;
· moins de fils sont nécessaires dans le câble. Dans le cas du RS232, seuls 2 fils sont présents
(entrée, sortie).
Les vitesses de transmission des interfaces sont généralement indiquées en MBits/s ou en
MByte/s.
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
AGP Parallèle Supérieure à 533 MByte/s Interface pour carte graphique

PCI Parallèle 133 MByte/s Interface pour cartes internes, p. ex. carte son
Illustration 1: Interfaces à prises situées à l'arrière d'un ordinateur

4.6 Communication des données
Grâce à la communication des données, des informations peuvent être échangées entre des
ordinateurs sous forme de données. La liaison entre chaque ordinateur est réalisée par des
réseaux de données.
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.
4.6.1. Transmission de données
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
Structures en étoile (ill. 1). On différencie:
 les structures en étoile active;
 les structures en étoile passive.
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é.
Illustration 1: Structure d'un réseau en étoile

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.
Illustration 2: Structure en arbre et structure en anneau

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.
Autres conditions pour assurer la transmission des données:
Protocole. Il définit les règles de la transmission des données dans un réseau.
Gateway. Si deux réseaux de type différent sont connectés, le gateway permet de traduire le
protocole de l'un dans le protocole de l'autre.
Hub. C'est une station de répartition située à l'intérieur d'un réseau en étoile. Toutes les
données sont transmises à tous les ordinateurs du réseau. Un hub passif se contente d'assurer
un rôle de répartiteur, tandis qu'un hub actif amplifie encore le signal.
Switch. C'est une station de répartition située à l'intérieur d'un réseau en étoile qui ne transmet
les données qu'aux ordinateurs connectés sur les branches du réseau concernées.
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).
Illustration 1: Réseau client-serveur

4.6.2 Télétransmission de données
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.
Terminal de communication. Il est indispensable pour l'émission et la réception de données. Il
s'agit en général d'ordinateurs personnels, de terminaux.
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.
Modem (Modulateur/Démodulateur). Il s'agit d'un appareil qui permet de transformer (moduler)
les signaux digitaux devant être transmis par un ordinateur en signaux analogiques. Les signaux
sont ensuite envoyés sur le réseau téléphonique analogique. Après la transmission, les signaux
analogiques sont à nouveau transformés (démodulés) par le modem, du côté réception, en
signaux compréhensibles par l'ordinateur. La transmission de données par le réseau
téléphonique s'effectue jusqu'à une vitesse de 56 kBit/s. Ces appareils disposent souvent aussi
d'une fonction de télécopie et d'un répondeur automatique.
ADSL (Asymetric Digital Subscriber Line = liaison numérique asymétrique sur ligne d'abonné). Il
s'agit d'un procédé permettant de transmettre des données numériques à grande vitesse, grâce
à un modem et à un protocole adéquat. La vitesse de transmission n'est pas égale
(asymétrique). En réception (clown-stream), la vitesse peut atteindre 768 kBit/s et en émission
(upstream) 128 kBit/s.
RNIS (Réseau numérique à intégration de services). La transmission des données à lieu sous
forme numérique au travers d'adaptateurs RNIS. Si un ordinateur est équipé de l'interface
adéquate, sous forme de carte RNIS, il peut être utilisé directement comme terminal RNIS. Par
canal, la vitesse de transmission des données atteint 64 kBit/s.
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).
Illustration 2: Offre de services en ligne

Possibilités de communication pour les exploitations automobiles
Il s'agit p. ex. de transmission de données provenant des banques de données des
constructeurs automobiles, du téléchargement d'appareils de commande, de tests et de
logiciels, de listes de délais de maintenance, d'actions pour l'atelier.
4.7 Sauvegarde et protection des données
En raison de la constante évolution de l'informatique et de l'augmentation de la quantité des
données traitées, la nécessité de les sauvegarder et de les protéger contre une utilisation illicite
est cruciale.
Par le biais des réseaux locaux et publics, différents utilisateurs pourraient en effet s'emparer de
ces données de manière directe et les modifier illicitement. Pour cette raison, la sauvegarde des
données et la protection de celles-ci gagnent de plus en plus en importance.
4.7.1 Sauvegarde des données
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.
Mémorisation intermédiaire et mémorisation définitive. Durant le travail à l'ordinateur, des

erreurs d'utilisation, des pannes électriques, des défauts de l'ordinateur, des pannes de système
peuvent provoquer une perte des données qui se trouvent dans la mémoire de travail. Pour
cette raison, il est indispensable de procéder à une mémorisation intermédiaire des données
puis de les sauvegarder de manière définitive sur des mémoires externes comme p ex des
disquettes, des disques durs
Plus on mémorise fréquemment et plus le danger de perte de données est réduit.
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.
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.
4.7.2 Protection des données
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.
Les données personnelles sont des indications sur
 des informations personnelles, p. ex date de naissance, âge, nationalité, religion,
profession, maladies, antécédents judiciaires, convictions politiques, certificats,
comportements de consommation
 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:
 droit d'information, si les données sont saisies et mémorisées;
 droit de renseignement sur les données saisies qui concernent sa personne;
 droit de correction en cas de mémorisation erronée;
 droit d'effacement des données dont la mémorisation n'était pas autorisée ou dont
l'autorisation à la mémorisation est échue, p. ex. après remboursement d'un crédit et
cessation des rapports d'affaires avec la banque concernée.
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.
Guide des travaux pratiques Informatique industrielle
Module :
Informatique industrielle
GUIDE DES TRAVAUX PRATIQUES
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…
A noter que la compréhension et la bonne réalisation de ces TP nécessite la compréhension

des notion fondamentales de programmation. Pour cela, j’ai ajouté deux annexes en fin du
module.
La première annexe traitre les notions de la conception d’un programme ou ce qu’en appel
algorithme.
L’algorithmique donne les techniques fondamentales pour construire un programme logique.
La deuxième annexe aborde les techniques de programmation en langage C nécessaire pour la

programmation de la carte Arduino.
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.
A la fin de ces TP vous serais en mesure de comprendre en profondeur le fonctionnement des

calculateurs et même de concevoir des applications utiles pour l’automobile.
Plan des travaux pratiques
-Travaux pratique N°1 :
Commande d’une diode LED
Utilisation d’un bouton poussoir
Gestion du clavier
Commande d’un afficheur LCD
Gestion de la conversion A/N
L’acquisition de la température et de l’humidité : le capteur DHT11
Mesure de la distance : le capteur HC-SR04
Commande d’un servomoteur
Interfaçage Labview - Arduino (initiation)
TP 1 : COMMANDE D’UNE DIODE LED

 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.
 Volume horaire : 3 heures

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).
Figure 1 : image et symbole d'une LED

Comment calculer la valeur de la résistance à ajouter en série avec la diode LED :
Figure 2 : Tension et courant de seuil d'une LED

Résistance (en Ohms) = (5 – Vf)/If
Figure 3 : Code couleurs des résistances
2 Manipulation 01 :
Le but de cette manipulation est de faire clignoter une diode LED toutes les secondes.
2.1 Schéma de câblage :
Réalisez le montage de la figure suivante :
Figure 4 : branchement d'une diode LED

Vous notez l’utilisation d’une résistance en série avec la diode LED pour minimiser l’appel en
courant.
2.2 Programmation de la carte :
Lancez l’application ARDUINO et ouvrez l’exemple « Blink » (Fichier>Exemples>01.Basics>Blink).
2.2.1 Explication du code ARDUINO :
Figure 5 : Structure d'un programme ARDUINO

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.
2.2.2 Vérification et chargement du programme :
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.
Figure 6 : Vérification et chargement du programme

Une fois le chargement du programme terminé, la LED commencera à clignoter.
3 Manipulation 02 :
Modifiez le programme précédent pour commander deux diodes LED (choisissez les broches de
votre choix)
4 Manipulation 03 :
En utilisant six diodes LED, réalisez un jeu de lumière (exemple : un chenillard)
OFPPT/DRIF/ISTA 2 SAFI 22 8
TP 2 : UTILISATION D’UN BOUTON POUSSOIR

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.
Figure 7 : Différentes vues d'un bouton poussoir

Pour lire une broche de donnée, elle doit être connectée à quelque chose. On ne doit pas lire une
broche qui n’est pas connectée car son état est instable. Une résistance pull-up met la broche à
l’état haut (HIGH) quand elle n’est pas connectée ce qui évite son instabilité.
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.
Réalisez le montage de la figure qui suit et n’oubliez pas d’ajouter la LED à la broche de votre
choix.
Figure 8 : Branchement d'un bouton poussoir

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 :
Figure 9 : Combinaisons du dé numérique
Bonus :
Pour générer un numéro aléatoire, vous devez utiliser les fonctions randomSeed() et random().
TP 3 : GESTION DU CLAVIER
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).
Figure 10 : Clavier numérique 3x4 à ruban

2 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.
Réalisez le montage de la figure qui suit :
Figure 11 : Branchement du clavier à la carte ARDUINO

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 ».
Figure 12 : Ajout d'une bibliothèque

Bonus :
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 :
Au cours de cette manipulation vous allez réaliser une serrure codée.
Principe de fonctionnement :
Un code à plusieurs chiffres (4 chiffres par exemple) doit être saisi par l’utilisateur 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 le programme envoie le message « code erroné » suivi de « Saisir code ».
TP 4 : COMMANDE D’UN AFFICHEUR LCD

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 :
Figure 13 : Afficheur LCD 2x16

2 Brochage de l’afficheur LCD 2x16 :
Le tableau suivant donne une description de la fonction de chaque broche :
Tableau 1 : Brochage de l'afficheur LCD
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)
En observant le brochage de l’afficheur, on constate qu’il faut un minimum de 6 sorties pour le
commander. En effet, si on utilise l’adressage sur 4 bits et que l’on se prive de la lecture dans
l’afficheur, il nous faut commander les six broches EN, RS, D4, D5, D6, et D7.
Ce mode 4 bits est bien pratique quand on utilise un petit microcontrôleur où le nombre
d’entrées/sorties est très limité. En contrepartie, le mode 4 bit complique un petit peu le protocole
de communication (logiciel) puisque qu’il faut passer la donnée 8 bits en deux fois (4 + 4 = 8 ). Ce
passage s’effectue comme suit :
D7 = Bit Donnée 7, D6 = Bit Donnée 6, D5 = Bit Donnée 5, D4 = Bit Donnée 4
puis :
D7 = Bit Donnée 3, D6 = Bit Donnée 2, D5 = Bit Donnée 1, D4 = Bit Donnée 0

En mode 4 bits, les broches D0, D1, D2, D3 doivent rester « en l’air » (non connectées).
A l’inverse, si on utilise toutes les broches de l’afficheur il faut 11 sorties pour le commander. Mais
cela n’apporte rien de plus; en mode 4 bits toutes les fonctionnalités sont disponibles.
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 :
Figure 14 : branchement de l'écran LCD

Lancez l’application ARDUINO et ouvrez l’exemple « HelloWorld » qui se trouve sous :
Fichier > Exemples > LiquidCrystal > HelloWorld. Adaptez le code pour afficher votre nom et
prénom (sur deux lignes). Si vous ne trouverez pas la bibliothèque « LiquidCrytal », il faut l’ajouter
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 :
Reprenez la manipulation du TP précédent (serrure codée) et utilisez l’afficheur LCD à la place du
moniteur série.
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
TP 5 : GESTION DE LA CONVERSION A/N

Le but de ce TP est d’exploiter le convertisseur Analogique/Numérique de la carte Arduino UNO.
L’étudiant sera capable de lire une grandeur analogique et de l’exploiter dans un programme pour
traitement spécifique.

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.
Figure 15 : Entrées analogiques de la carte Arduino UNO

2 Manipulation 01 :
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.
Réalisez le schéma de câblage suivant :
Figure 16 : Branchement d'un potentiomètre

Pour lire une entrée analogique, utilisez la fonction AnalogRead().
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 :
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.
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().
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
Tableau 2 : Etat de la jauge

Valeur de la tension en Volt Etat de la jauge
0
3
4
TP 6 : L’ACQUISITION DE LA TEMPERATURE
ET DE L’HUMIDITE : LE CAPTEUR DHT11
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).
Figure 17 : Brochage du capteur DHT11
1.1 Caractéristique du capteur DHT11 :

· Mesure de l'humidité relative (RH)
· Alimentation comprise entre 3 Vcc et 5.5 Vcc.
· Courant d'alimentation : 100 μA maximum en veille, 2.5 mA maximum en dialogue.
· Mesures des températures comprises entre 0 °C et 50 °C.
· Mesures d'humidité entre 30 % et 90% RH à 0°C. entre 20 % et 90% RH à 25°C. entre 20 % et
80% RH à 50°C.
· Résolution 1 % RH.
· Précision à 25 °C : ± 5% RH.
2 Manipulation 01 :
Téléchargez la bibliothèque « DHT11 » et ajoutez-la au dossier des bibliothèques de l’Arduino.
Réalisez le branchement conformément à la figure 18 et exécutez l’exemple de la bibliothèque.
Testez le bon fonctionnement du programme en affichant les résultats sur le moniteur série.
21
Figure 18 : branchement du capteur DHT11
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.
TP 7 : MESURE DE LA DISTANCE :LE CAPTEUR HC-SR04

Le but de ce TP est de détecter un obstacle et de renvoyer une distance en utilisant le capteur
ultrason HC¬SR04. L’étudiant sera capable de faire des traitements spécifiques selon la distance
acquise.
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
Figure 19 : brochage du HC-SR04

1.2 Principe de fonctionnement :
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.
Figure 20 : Principe de fonctionnement du HC-SR04
1.3 Calcul de la distance :

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 :
Téléchargez une des bibliothèques du capteur HC-SR04 disponibles.
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).
La figure suivante donne le branchement du capteur sur la carte
Figure 21 : Branchement du capteur HC-SR04

3 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 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
TP 8 : COMMANDE D’UN SERVOMOTEUR

Le but de ce TP est de comprendre le fonctionnement d’un servomoteur et de pouvoir le
commander.
L’étudiant sera capable de spécifier la position exacte du servomoteur et d’envoyer la commande
correspondante.
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°).
Figure 23 : Principe de la commande d'un servomoteur
3 Manipulation
Téléchargez la bibliothèque « Servo » qui permet de commander le servomoteur.
Lancez l’exemple de la bibliothèque « Sweep » qui permet de piloter le servomoteur de 0° à 180° et
inversement d’une façon continue.
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 :
Figure 24 : Branchement du servomoteur

Transférez votre programme et testez son bon fonctionnement.
4 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.
Bonus :
N’oubliez pas que la valeur numérique délivrée par le CAN est comprise entre 0 et 1023 et que le
servomoteur accepte un angle compris entre 0 et 180° ; pensez à utiliser la fonction map().
5 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 bras du servomoteur à
droite et inversement.
TP 9 : INTERFAÇAGE LABVIEW - ARDUINO

(INITIATION)
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)
Télécharger et installer la dernière version des drivers NI-VISA :

c’est un pilote qui permet à Labview de communiquer avec les
instruments comme l’Arduino(dans notre cas en utilisant une
connexion USB
Télécharger et installer le module VIPM (VI Package Manager)
permettant d’ajouter de nombreux compléments, dont ceux de
l’Arduino
2 Installation des packages :

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 :
- LIFA : Labview Interface For Arduino
- MakerHub(LINX).
Nous allons télécharger les deux types de VI ensuite nous verrons la différence entre les deux
outils. Dans la zone de recherche de VIPM, tapez Arduino et chercher labVIEW Interface For
Arduino :
Figure 25 : Recherche du VI LIFA

Sélectionner LIFA et cliquez sur l’icône install :
Figure 26 : Ajout du VI LIFA
Refaire la même chose, mais cette fois ci le VI s’appelle MakerHub:
Figure 27 : Ajout VI MakerHub
Une fois tous les VI installés, on peut passer à l’interfaçage.
3 Interfaçage labVIEW-Arduino
L’interfaçage diffère selon le type de VI installé.
3.1 Installation du firmwar LIFA
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
3.2 Installation du firmwar MakerHub(LINX)
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
Figure 28 : Choix du type de la carte dans LINX
En cliquant sur suivant, on se retrouve avec la fenêtre du choix du numéro du port serie :
Figure 29 : Choix du port série pour LINX

L’étape suivante est le choix de la version du firmware et de la méthode du chargement :
Figure 30 : Choix de la méthode de chargement

Finalement le chargement du firmware commence :
Figure 31 : Chargement du firmware
A la fin du chargement la carte est prête pour communiquer avec labVIEW.

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.
Figure 32 : exemple d'interfaces labVIEW

5 Manipulation 01 :
Pour réaliser l’interfaçage avec la carte Arduino, nous allons utiliser le firmware LINX de MakerHub.
1- Brancher la carte et transférer le firmware
2- Une fois le transfert terminé, cliquez sur le bouton « launch exemple ».
L’exemple en question permet de commander une diode LED branchée sur la sortie 13 de la carte
Arduino à l’aide d’un bouton poussoir (bouton vert sur l’interface labVIEW)
3- Connectez une diode LED sur la sortie 13 de la carte Arduino (vous pouvez utiliser la diode LED
branchée sur la carte à la sortie 13 de la carte Arduino), exécutez le programme et vérifier son bon
fonctionnement.
6 Manipulation 02 :
1- Lancer l’exemple « LINX Servo 1 Chanel »
Ce programme permet de commander un servomoteur connecté à la sortie 2 de la carte. Brancher
votre servomoteur et vérifier son bon fonctionnement.
CORRECTION DES TP
TP 1 : COMMANDE D’UNE DIODE LED

Manipulation 02 :
Modifiez le programme précédent pour commander deux diodes LED (choisissez les broches de votre choix)
Manipulation 03 :
En utilisant six diodes LED, réalisez un jeu de lumière (exemple : un chenillard)
TP 2 : UTILISATION D’UN BOUTON POUSSOIR
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.
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 :
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 :
Pour générer un numéro aléatoire, il faut utiliser les fonctions randomSeed() et random() :
La fonction randomSeed() permet d’ initialiser le générateur de nombres pseudo-aléatoire, imposant à la

séquence aléatoire de démarrer à un point arbitraire. S'il est important que les valeurs d'une séquence générée
par l'instruction random() diffèrent, lors d'exécutions successives d'un programme, il faut utiliser la fonction
randomSeed() pour initialiser le générateur de nombres aléatoires avec une entrée suffisamment aléatoire.
Cette entrée aléatoire peut être récupérée de la valeur renvoyée par l'instruction analogRead() sur une broche
analogique non connectée.
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.
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).
Résultat d’exécution :
TP 4 : Commande d’un afficheur LCD
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)
Résultat exécution :
Ajouter une animation au texte affiché : défilement à droite, défilement à gauche
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.
Manipulation 02 :
Reprenez la manipulation du TP précédent (serrure codée) et utilisez l’afficheur LCD à la place du moniteur série.
Manipulation 03 :
Vous allez réaliser un jeu où il faut deviner un nombre choisi au hasard par le programme :
TP 5 : Gestion de la conversion A/N
Manipulation 01 :
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.
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.
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.
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
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 ».
On peut réaliser le même traitement en utilisant la structure switch case :

TP 6 : L’acquisition de la tempeé rature et de
l’humiditeé : 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.
La fonction dht11.read() peut retourner trois valeurs différentes :
- DHTLIB_OK (0): le contrôle du capteur et ses mesures sont correctes

- DHTLIB_ERROR_CHECKSUM (-1): le contrôle du capteur a échoué ; c'est-à-dire que la donnée a été reçu mais
pourrait être erronée.
- DHTLIB_ERROR_TIMEOUT (-2): le délais d’attente a été dépassé et la communication a échouée.
 C’est pourquoi on teste dans le programme si la fonction dht11.read() retourne un zéro ou non.
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.
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)
TP 7 : mesure de la distance : le capteur
HC-SR04
Manipulation 01 :
Téléchargez une des bibliothèques du capteur HC-SR04 disponibles.
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).
- digitalWrite(trigpin, LOW) et delayMicroseconds(2) : envoyer un niveau bas pendant 2 us pour stabiliser la
sortie.
- digitalWrite(trigpin, HIGH) et delayMicroseconds(10) : envoyer un niveau supérieur ou égal à 10 us (10
us dans notre cas)
- pulseIn(echopin, HIGH) : cette instruction attend que la broche « echopin » passe à HAUT, commence alors
le chronométrage, attend que la broche repasse au niveau BAS et stoppe alors le chronométrage.
Elle renvoie la durée de l'impulsion en microsecondes.
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 ».
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.
TP 8 : commande d’un servomoteur
Manipulation
Téléchargez la bibliothèque « Servo » qui permet de commander le servomoteur.
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.
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.
TP 9 : interfaçage Labview – Arduino
(initiation)
Manipulation 01 :
Une fois l’exemple lancé, on obtient les interfaces suivantes :
- Face avant :
1 : choix du numéro du port série
2 : choix du numéro de la sortie sur laquelle sera branchée la diode LED
3 : le bouton poussoir qui permet de commander la diode LED

- 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 :
Guide de travaux pratiques Informatique industrielle
1 : choix de la sortie de commande du servomoteur
2 : sélection de l’angle à envoyer au servomoteur : en variant la commande de 500 à 2500,

l’axe du servo suivra le mouvement (la valeur 1500us correspond à un angle de 90 degrés).
- 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
Annexes Informatique industrielle
Annexe 1 :
Introduction à l'algorithmique
PRÉSENTATION
PRÉSENTATION INFORMELLE
Considérons les étapes qui interviennent dans la résolution problème

quelconque :
1. concevoir une procédure qui une à fois appliquée amènera à une

solution du problème ;
2. résoudre effectivement le problème en appliquant cette méthode.
Le résultat du premier point sera nommé un algorithme. Quant au deuxième

point, c'est-à-dire la mise en pratique de l'algorithme, nous l'appellerons
un processus.
Ces notions sont très répandues dans la vie courante. Un algorithme peut
par exemple y prendre la forme :
 d'une recette de cuisine,

 d'un mode d'emploi,
 d'une notice de montage,
 d'une partition musicale,
 d'un texte de loi,
 d'un itinéraire routier.
Dans le cas particulier de l'informatique, une étape supplémentaire vient se

glisser entre la conception de l'algorithme et sa réalisation à travers un
processus : l'algorithme doit être rendu compréhensible par la machine que
nous allons utiliser pour résoudre effectivement le problème. Le résultat de la
traduction de l'algorithme dans un langage connu de la machine est appelé
un programme.
RAPIDE HISTORIQUE
C'est un mathématicien perse du 8ème siècle, Al-Khawarizmi, qui a donné

son nom à la notion d'algorithme. Son besoin était de traduire un livre de
mathématiques venu d'Inde pour que les résultats et les méthodes exposés
dans ce livre se répandent dans le monde arabe puis en Europe. Les résultats
devaient donc être compréhensibles par tout autre mathématicien et les
méthodes applicables, sans ambiguïté.
En particulier, ce livre utilisait une numérotation de position, ainsi que le

chiffre zéro que ce type de représentation des nombres rend nécessaire. Par
ailleurs, le titre de ce livre devait être repris pour désigner une branche des
mathématiques, l'algèbre.
Si l'origine du mot algorithme est très ancienne, la notion même d'algorithme

l'est plus encore : on la sait présente chez les babyloniens, 1800 ans avant
JC.
Une tablette assyrienne provenant de la bibliothèque d'Assurbanipal et

datée de -640 expose une recette pour obtenir des pigments bleus (notons
que pour avoir un algorithme satisfaisant, il faudrait préciser ici les temps de
cuisson !) :
 tu ajouteras à un mana de bon tersitu un tiers

de mana de verre sirsu broyé, un tiers de mana de
sable, cinq kisal de craie,
 tu broieras encore,
 tu le recueilleras dans un moule, en le fermant
avec un moule réplique,
 tu le placeras dans les ouvreaux du four,
 il rougeoira et uknû merku en sortira.
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
On se donne une instruction Écrire pour afficher du texte, ainsi qu'une

instruction ALaLigne pour poursuivre l'affichage à la ligne suivante.
Patron d'un algorithme
Le patron général est le suivant :

Algorithme NomAlgorithme
Début
... actions
Fin
La première ligne, appelée profil donne essentiellement le nom de

l'algorithme. On trouve ensuite un délimiteur de début puis les différentes
actions composant l'algorithme et enfin un délimiteur de fin.
Ainsi, l'algorithme suivant est valide :

Algorithme Bonjour
Début
Écrire('Hello world !!!')
ALaLigne
Fin
Évoquer l'appel à un tel algorithme dans un algorithme principal.
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.
Pour la clarté de l'algorithme, il peut être intéressant de déclarer les

variables utilisées et leur type au tout début. Quand l'algorithme sera traduit en
programme cette déclaration aura d'autres avantages : réservation de l'espace
mémoire correspondant au type, possibilité de vérifier le programme du point
de vue de la cohérence des types, etc.
Affectation souvent symbolisée par une flèche vers la gauche (←).
Expressions, évaluation, etc.
Nouveau patron d'un algorithme
Nous allons maintenant préciser les variables utilisées par l'algorithme et

leurs types, en distinguant les paramètres externes et les variables internes à
l'algorithme. Ainsi, le patron d'un algorithme devient
Algorithme NomAlgorithme (paramètres...)
Variable ...
Début
... actions
Fin
INSTRUCTIONS CONDITIONNELLES ET ITÉRATIVES
Le Si Alors Sinon va permettre de conditionner l'exécution de certaines

instructions.
Le rôle des boucles est d'itérer un bloc d'instructions, soit un nombre précis
de fois, soit relativement à une condition.
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 Tant que et Répéter

Algorithme JusquAuMur
Début
Tant que Non(DevantMur) faire
Avancer
Fin tant que
Fin
Algorithme JusquAuMurVersionRépéter
Début
Répéter
Avancer
jusqu'à DevantMur
Fin
À noter que, contrairement à la boucle tant que, on passe toujours au moins

une fois dans une boucle répéter. Ainsi, dans l'exemple ci-dessus, on
avancera forcément d'une case... il conviendrait donc de tester si l'on n'est pas
devant un mur avant d'utiliser cet algorithme.
Boucle Pour
Dotés des variables, nous pouvons maintenant écrire un nouveau type de

boucle, la boucle pour :
Algorithme CompteJusqueCent
Variable i : entier
Début
Pour i ← 1 à 100 faire
Écrire(i)
ALaLigne
Fin Pour
Fin
Lorsque l'on sait exactement combien de fois on doit itérer un traitement,

c'est l'utilisation de cette boucle qui doit être privilégiée.
Par exemple,
Algorithme DessineEtoiles (n : entier)
Variable i : entier
Début
Pour i ← 1 à n faire
Écrire('*')
Fin pour
Fin
Comparaisons des boucles pour un problème simple
On reprend l'exemple précédent de la boucle pour

Algorithme CompteJusqueCentVersionPour
Variable i : entier
Début
Pour i ← 1 à 100 faire
Écrire(i)
ALaLigne
Fin Pour
Fin
et on écrit des algorithmes qui produisent la même sortie (les nombres de 1

à 100) mais en utilisant les différentes boucles.
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
Enfin, en utilisant la récursivité, on obtient :

Algorithme CompteJusqueCentRecursif (n : entier)
Début
Si (n ≤ 100)
Alors
Écrire(n)
ALaLigne
CompteJusqueCentRecursif(n+1)
Fin si
Fin
Algorithmes pour les figures géométriques
TYPES ABSTRAITS
FORMALISME
opérations et signature
constructeurs, accesseurs, modifieurs, testeurs, copieurs, afficheurs
pré-conditions et axiomes
opérations complexes
LE TYPE ABSTRAIT « ENTIER »

Type abstrait « Entier »
Utilise « Booléen »
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
Avec ce type abstrait, nous sommes capables de définir l'addition et la

multiplication, indépendamment de l'implémentation de ce type.
Algorithme plus (n,m : entiers)
Début
Tant que non(est_nul(n))
m ← succ(m)
n ← prec(n)
Fin TQ
Retourner m
Algorithme fois (n,m : entiers)

Début
s ← zero()
Tant que non(est_nul(n))
s ← plus(s,m)
n ← prec(n)
Fin TQ
Retourner s
Fin
LE TYPE ABSTRAIT « PILE »

Type abstrait « Pile »
Utilise « Booléen » et « Élément »
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
Un algorithme possible basé sur ce type :

Algorithme inversepile (p : Pile)
Début
q ← copiepile(p)
r ← pilevide()
Tant que non(estvide(q))
ajoute(sommet(q),r)
depile(q)
Fin TQ
Retourner r
Fin
TYPE ABSTRAIT : LE CAS DES TYPES PRODUITS
Forme générale de ces types...
Sur un exemple : le type abstrait « Étudiant ».

Type abstrait « Étudiant »
Utilise « Entier » et « Texte »
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
LE TYPE ABSTRAIT « TABLEAU »
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
Axiomes
taille(créer_tableau(n)) = n
contenu(fixecase(t,n,e),n) = e
Seconde version avec la notation crochets plus proche des langages de

programmation.
Type abstrait « Tableau »
Utilise « Entier » et « Élément »
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 SUR LES TABLEAUX
ALGORITHMES DE BASE
Parcours d'un tableau

Algorithme AfficheTableau (t : tableau)
{ Affiche tous les éléments d'un tableau }
Variable i : entier
Début
Pour i ← 1 à taille(t) faire
Écrire(t[i])
Fin Pour
Fin
Recherche des plus petit et grand éléments d'un tableau

Algorithme Maximum (t : tableau d'entiers)
{ Recherche l'élément le plus grand d'un tableau de taille n non nulle }
Variables i, max : entier

Début
max ← t[1]
Si (t[i] > max)
Alors max ← t[i]
Fin si
Fin Pour
Écrire(max)
Fin
Déroulement du programme sur le tableau
42 5 1 3
I MAX
- 4
2 4
3 5
4 5
5 5
et l'algorithme affiche la valeur 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 :
 la comparaison entre le maximum connu et un élément du tableau

(t[i] > max) ;
 l'affectation d'une valeur à la variable contenant le maximum ( max ←
t[1] et max ← t[i]).
Mesurer la complexité de l'algorithme revient alors à compter le nombre de

fois où ces opérations sont effectuées par l'algorithme.
Ainsi, pour un tableau de taille n, l'algorithme Maximum effectue n-1

comparaisons.
Naturellement, nous le voyons avec l'algorithme Maximum et le nombre

d'affectations qu'il effectue, la complexité peut varier avec les données
fournies en entrée. Nous allons donc distinguer trois notions de complexité :
au mieux, au pire et en moyenne.
 Le cas le plus favorable pour notre algorithme Maximum est le cas

où le maximum du tableau se trouve en première position : la
variable max prend cette valeur au début et n'en change plus
ensuite. La complexité au mieux vaut donc 1.
 Au pire, le tableau est trié en ordre croissant et la variable max doit
changer de valeur avec chaque case. Le complexité au pire vont
donc n.
 La complexité en moyenne est plus difficile à calculer. Il ne s'agit
pas comme on pourrait le penser de la moyenne des complexités
au mieux et au pire. Nous pouvons observer que si nous
choisissons un tableau au hasard, il est beaucoup plus probable
d'avoir un tableau dont le maximum est en première place (cas le
mieux) qu'un tableau complètement trié (cas le pire). Par
conséquent, la complexité en moyenne est plus proche de 1 que
de n et, en effet, il est possible de montrer que cette complexité en
moyenne vaut log(n).
En résumé, nous avons pour la complexité de l'algorithme Maximum en

nombre d'affectations sur un tableau de taille n :
au mieux en moyenne au pire
1 log(n) n
(variation) On cherche la position du minimum dans un tableau et entre deux

cases repérées par leurs numéros d(début) et f (fin):
Algorithme PositionMinimum (t : tableau d'entiers ; d,f : entier)
Variable i,imin : entier
Début
imin ← d
Pour i ← d+1 à f faire :
Si t[i] ≤ t[imin] alors
imin ← i
Fin si
Fin pour
Retourner imin
Fin
Existence d'un élément dans un tableau
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
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
ou encore mieux avec une recherche dite dichotomique :

Algorithme RechercheDichotomique
(e : entier ; t : tableau d'entiers)
Variable g,d,m : entier
trouve : booléen
Début
g ← 1
d ← taille(t)
trouve ← faux
Tant que (g ≤ d) et NON(trouve) Faire
m = (g+d) div 2
Si t[m] = e
Alors trouve ← vrai
Sinon Si e < t[m]
Alors d ← m-1
Sinon g ← m+1
Fin si
Fin si
Fin Tant que
Si trouve
Alors Écrire('Trouvé !')
Sinon Écrire('Pas trouvé...')
Fin si
Écrire(m)
Fin
Pour continuer à bénéficier de ces algorithmes, il faut être capable d'insérer

un nouvel élément directement à sa place (ici n indique le numéro de la
dernière case):
Algorithme Insertion (t : tableau d'entiers ; n,e : entier)
Variable i : entier
Début
i ← n
Tant que (i>0) et (t[i]>e) faire :
t[i+1] ← t[i]
i ← i-1
Fin TQ
t[i+1] ← e
Fin
ALGORITHMES DE TRI DE TABLEAUX
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
Insertion(t,i-1,t[i])
Fin Pour
Fin
Tri extraction
Aussi nommé tri sélection, il utilise l'algorithme PositionMinimum
1. Extraire l'élément le plus petit du tableau à trier.

2. Échanger cette valeur minimale avec la première case du tableau à
trier.
3. Trier le reste du tableau (le tableau initial sans la première case) de
la même manière.
Algorithme TriExtraction (t : tableau d'entiers)
{ Trie par ordre croissant le tableau t }
Variables i,imin : entier
Début
Pour i ← 1 à taille(t)-1 faire
imin ← PositionMinimum(t,i,taille(t))
Échange(t,i,imin)
Fin Pour
Fin
Tri à bulles
Algorithme TriBulles (t : tableau d'entiers)
{ Trie par ordre croissant le tableau t contenant n éléments }
Variables i,j : entier
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
Principe du tri rapide

1. Choisir un élément du tableau, élément que l'on nomme
ensuite pivot.
2. Placer le pivot à sa position finale dans le tableau : les éléments
plus petits que lui sont à sa gauche, les plus grands à sa droite.
3. Trier, toujours à l'aide de cet algorithme, les sous-tableaux à gauche
et à droite du tableau.
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.
Cependant, bien choisir le pivot peut être coûteux en terme de complexité.
Aussi on suppose que le tableau arrive dans un ordre aléatoire et on se

contente de prendre le premier élément comme pivot.
Algorithme Placer (t,d,f):
Variables l,r : entiers
Début
l ← d+1
r ← f
Tant que l ≤ r:
Tant que t[r]>t[d]
r ← r-1
Fin TQ
Tant que l ≤ f et t[l] ≤ t[d]
l ← l+1
Fin TQ
Si l<r:
Échange(t,l,r)
r ← r-1
l ← l+1
Fin si
Fin TQ
Échange(t,d,r)
Renvoyer r
Fin
Algorithme TriRapideBoucle (t,d,f)

Variable k : entier
Début
Si d<f alors
k ← Placer(t,d,f)
TriRapideBoucle(t,d,k-1)
TriRapideBoucle(t,k+1,f)
Fin si
Fin
Algorithme TriRapide (t,n)

Début
TriRapideBoucle(t,1,n)
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.
tri à bulles en n2.
tri rapide en n.log(n).
COMPLEXITÉ
complexité en 2n (exponentielle)
INTUITION D'UNE EXPLOSION COMBINATOIRE

 tours de Hanoï
 grains de blé sur l'échiquier
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.
Pourquoi l'algorithme Windows nécessite des machines de plus en plus

puissantes ?
INDÉCIDABILITÉ DU PROBLÈME DE L'ARRÊT

Commençons par donner un numéro à tous les algorithmes.
Supposons qu'il existe un algorithme dont la spécification serait la suivante :

Algorithme TestArrêt (a,n : entier)
{ Affiche 1 si l'algorithme de numéro a s'arrête sur l'entrée n,
0 sinon }
Nous allons montrer en raisonnant par l'absurde qu'un tel algorithme ne peut
pas exister.
Pour cela, considérons l'algorithme suivant qui n'est qu'une simple utilisation
de l'algorithme TestArrêt.
Algorithme Bizarre (e : entier)

Variable i : entier
Début
Répéter
i = TestArrêt(e,e)
Jusqu'à i = 0
Écrire(1)
Fin
Nous constatons que cette algorithme Bizarre boucle à l'infini si l'algorithme de
numéro e s'arrête ; par contre, Bizarres'arrête si l'algorithme de
numéro e boucle.
Voyons où cela nous mène si nous fournissons à l'algorithme Bizarre son

propre numéro :Bizarre boucle si Bizarres'arrête, et Bizarre s'arrête
si Bizarre boucle...
Nous trouvons là une reformulation du paradoxe du barbier : dans une ville

où les gens soit se rasent eux-mêmes, soit se font raser par le barbier, qui
rase le barbier ? Soit il se rase lui-même et, dans ce cas, il n'est pas rasé par
le barbier, soit il ne se rase pas lui même et nous en déduisons qu'il est rasé
par le barbier. Reformulé, cela nous donne : soit il se rase lui-même et donc il
ne se rase pas lui-même, soit il ne se rase pas lui-même et donc il se rase lui-
même.
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.
L'ensemble des algorithmes est dénombrable, l'ensemble des problèmes ne

l'est pas : tout deux sont de taille infinie mais le second est tout de même
beaucoup plus grand que le premier.
CONCLUSION
Nous avons donné des algorithmes pour différents problèmes, en particulier

des algorithmes de tri de tableaux.
Nous avons vu des problèmes plus difficiles :
 soit nous avons des algorithmes mais qui ne permettent pas de

traitement du problème dans un temps raisonnable (complexité
exponentielle) ;
 soit nous avons montré qu'il n'existe aucun algorithme pour certains
problèmes (indécidabilité)
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.____________________________________________________
13- Lecture formatée._______________________________________________________
IV- Les instructions et structures de contrôle.____________________________________
1- Séquence.________________________________________________________________
2- Répétitions.______________________________________________________________
3- Choix.___________________________________________________________________
4- Instruction vide.___________________________________________________________
V- Les sous-programmes en C.__________________________________________________
1- Généralités.______________________________________________________________
2- Déclaration de fonction.____________________________________________________
3- Appel de fonction._________________________________________________________
4- Portée des déclarations.____________________________________________________
a- Variables locales.______________________________________________________________
b- Attributs des variables locales :___________________________________________________
c- Variables externes._____________________________________________________________
5- Structure d’un programme.__________________________________________________
6- Compilations séparées et projet._____________________________________________
VI- Tableaux : approche traditionnelle._________________________________________
1- Déclaration de tableau._____________________________________________________
2- Initialisation de tableau à la déclaration.______________________________________
3- Référence à un élément de tableau.__________________________________________
VII- Les pointeurs.___________________________________________________________
1- Définition._______________________________________________________________
2- Déclaration de pointeur.____________________________________________________
3- Opérateur adresse.________________________________________________________
4- Opérateur d’indirection.____________________________________________________
5- Arithmétique des pointeurs._________________________________________________
6- Passage de paramètre par adresse dans les fonctions.____________________________
7- Relations entre tableaux et pointeurs._________________________________________
a- Tableaux monodimensionnels.___________________________________________________
b- Tableaux multidimensionnels.____________________________________________________
VIII- Les chaînes de caractères._________________________________________________
1- Généralités.______________________________________________________________
2- Déclarations et initialisations de chaînes.______________________________________
a- Tableau de caractères (dimensionné ou non)._______________________________________
b- Pointeur de caractères._________________________________________________________
3- Tableau de chaînes de caractères.____________________________________________
4- Saisie de chaîne.__________________________________________________________
5- Impression de chaîne.______________________________________________________
6- Fonctions de manipulation de chaîne._________________________________________
a- Copie de chaînes.______________________________________________________________
b- Concaténation de chaînes.______________________________________________________
c- Comparaison de chaînes._______________________________________________________
d- Longueur de chaîne.___________________________________________________________
IX- Structures de données et allocation dynamique._______________________________
1- Structures._______________________________________________________________
2- Accès aux champs de la structure.____________________________________________
3- Imbrication de structures.__________________________________________________
4- Tableaux de structures.____________________________________________________
5- Structures récursives.______________________________________________________
6- Passage de structures en paramètres ou retour de structure ._____________________
7- Union.___________________________________________________________________
8- Allocation dynamique._____________________________________________________
a- Allocation de mémoire._________________________________________________________
b- Libération de mémoire._________________________________________________________
X- Le Préprocesseur.__________________________________________________________
1- Inclusion de fichiers._______________________________________________________
2- Macros._________________________________________________________________
a- macrodéfinition._______________________________________________________________
b- macrofonction.________________________________________________________________
3- Suppression d’une définition précédente.______________________________________
4- Compilation conditionnelle._________________________________________________
XI- Les Fichiers C.___________________________________________________________
1- Généralités.______________________________________________________________
2- Ouverture/fermeture de fichier.______________________________________________
a- Ouverture.___________________________________________________________________
b- Fermeture.___________________________________________________________________
3- Lecture/écriture de caractères._______________________________________________
a- Lecture de caractères.__________________________________________________________
b- Ecriture de caractères.__________________________________________________________
4- Lecture/écriture de lignes.__________________________________________________
a- Lecture de lignes.______________________________________________________________
b- Ecriture de lignes.______________________________________________________________
5- Lecture/écriture formatées._________________________________________________
a- Lecture formatée.______________________________________________________________
b- Ecriture formatée._____________________________________________________________
6- Lecture/écriture de blocs.___________________________________________________
a- Lecture de blocs.______________________________________________________________
b- Ecriture de blocs.______________________________________________________________
7- Instructions de contrôle.____________________________________________________
a- Test de fin fichier.______________________________________________________________
b- Erreur d’E/S.__________________________________________________________________
c- Positionnement direct sur un octet._______________________________________________
d- Repositionnement en début de fichier._____________________________________________
e- Position courante._____________________________________________________________
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 :
. très puissant, syntaxe évoluée

. indépendant de la machine
mais :
. peu typé, peu de contrôles de types

. maintenance difficile
. la lecture peut être difficile si on utilise toute la puissance syntaxique
Utilisé comme langage évolué ( Pb !)

Il faut être prudent (à cause du manque de contrôle) [à l’encontre de la philosophie
ADA]
2 normes : KR, ANSI
II- Notions de base.
1- Compilateur sensible à la casse.
Attention, lettre majuscule différente de lettre minuscule.
2- Commentaires.
/* texte commentaire */
3- Types de base.
a- Caractère :char.
Le type char permet de stocker des valeurs signées ou non (signed ou

unsigned) sur 1 octet. Par défaut, il s’agit de valeurs signées.
char : valeurs comprises entre -128 et +127

signed char : idem
unsigned char : valeurs comprises entre 0 et +255
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
4- Représentation des valeurs
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
‘\\’ back slash
Tout caractère peut être exprimé de manière octale

‘\0’ caractère NUL
‘012’‘\n’
b- Valeurs chaines de caractères.
″ 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.
Notation virgule fixe 3.14459 -10.0

Notation virgule flottante (Mantisse, exposant)
4e16 -8.2345 E-10
5- Déclarations.
a- constantes symboliques.
#define <ident> <expression>
#define PI 3.14592358
#define E 2.718281828
#define entier int
#define debut {
#define fin }
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.
<type> <ident1>, <ident2>, …, <identn>;
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 ;
III- Les opérateurs.
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.
++
préfixé sur une variable => avant accès
ou postfixé sur une variable => après accès
--
i=2;j=2 ;
k=i++; /* k vaut 2, i vaut 3 */

k=++j; /* k vaut 3 j vaut 3 */
i=2;j=2 ;
k=i--; /* k vaut 2, i vaut 1 */

k=--j; /* k vaut 1 j vaut 1 */
3- Opérateurs arithmétiques.
- <exp> /* moins unaire */

<exp1> – <exp2> /* soustraction */
<exp1> + <exp2> /* addition */
<exp1> * <exp2> /* multiplication */
<exp1> / <exp2> /* division */
<exp1> % <exp2> /* modulo */
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.
<exp1> == <exp2> /* égalité */

<exp1> != <exp2> /* différent */
<exp1> > <exp2> /* supérieur */
<exp1> < <exp2> /* inférieur */
<exp1> >= <exp2> /* supérieur ou égal */
<exp1> <= <exp2> /* inférieur ou égal */
Remarque : a < b < c => VRAI

(avec a = 10, b=20, c=15)
5- Opérateurs logiques.
<exp1> et <exp2> sont des expressions entières.
<exp1> && <exp2> /* ET logique */

si <exp1> = 0, <exp2> n’est pas évalué
<exp1> || <exp2> /* OU logique */

si <exp1> = 1, <exp2> n’est pas évalué
!<exp1> /* NON logique */
6- Opérateurs de bits.
<exp1> et <exp2> sont des expressions entières( int ou char).
~ <exp2> /* complément à 1 */
<exp1> & <exp2> /* ET bit à bit */
<exp1> | <exp2> /* OU inclusif bit à bit */
<exp1> ^ <exp2> /* OU exclusif bit à bit */
<exp1> << <exp2> /* décalage à gauche */

La valeur de <exp1> est décalée à gauche de valeur de <exp2> bits.
<exp1> >> <exp2> /* décalage à droite */
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.
(<exp1>) ? <exp2> : <exp3>
si <exp1> ≠ 0 , l’opérateur renvoie <exp2> sinon <exp3>
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) ;
Utilisation de 2 variables de contrôle dans une boucle for :
for(i=0,j=MAX;i<MAX;i++,j--)
{-----}
9- Affectation composée.
<exp1> <op> = <exp2>
<op> pouvant être l’un des opérateurs suivants : +,-,*,/,%,>>,<<,&,|,^
Cette formulation équivaut à : (<exp1>) = <exp1> <op> (<exp2>)
Exemples :
i +=3 ; /* i=i+3 */
x *= y+1 ; /* x=x*(y+1) */
a /= b–c ; /* a=a/(b–c) */
10- Forceur de type.
(<nouveau-type> ) <exp>
<nouveau-type> est un type de base ou un pointeur.

11- Précédences.
Opérateurs Ordre évaluation

() [] -> . gauche->droite
! ~ ++ -- - unaire * unaire & unaire (type) droite -> gauche
sizeof
* / % gauche->droite
+ - gauche->droite
<< >> gauche->droite
< <= > >= gauche->droite
== != gauche->droite
& gauche->droite
^ gauche->droite
| gauche->droite
&& gauche->droite
|| gauche->droite
? : gauche->droite
= += -= *= /= %= >>= <<= &= |= ^= droite-> gauche
, gauche->droite
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.
12- Impression formatée.
printf(″<chaîne de contrôle>″, <suite d’expressions>) ;
<chaîne de contrôle> est une chaîne de caractères contenant des caractères

ordinaires à imprimer tels quels, et des spécifications de format commençant par le
symbole %,contenant au moins un caractère indiquant le format d’impression. Chaque
spécification de format correspond à l’une des expressions de <suite
d’expressions>(selon l’ordre d’apparition).
d entier décimal signé

u entier décimal non signé
o entier octal non signé
x,X entier hexadécimal non signé
f réel en notation virgule fixe [-]dddd.dddddd

e,E réel en notation virgule flottante [-]d.ddddd E[-]ddd
c caractère
s chaîne de caractères
<chaîne de contrôle> peut ne pas contenir de spécification de format, auquel

cas la chaîne sera affichée telle quelle.
Exemples :
printf(″\nBonjour″);
int i=3, j=4 ;

printf(″\nLa valeur de i est %d et celle de j est %d″, i,
j);
Il est possible de préciser entre le symbole % et le caractère de spécifiation de format,

une ou plusieurs informations numériques, définissant le nombre de caractères à
imprimer.
%nd indique que la valeur décimale est imprimée sur une zone de n caractères,
cadrée à droite
%m.n f, indique que la valeur réelle est imprimée sur m caractères, dont n chiffres
après la virgule. Si m est insuffisant, la partie entière reste prioritaire.
%m:nE, indique que la valeur réelle est imprimée sur m caractères, dont n chiffres
après la virgule (virgule comprise) pour la mantisse.
Exemples :
printf(″/%d/ \n″, 337); /* imprime /337/ */

printf(″/%10d/ \n″, 337); /* imprime / 337/ */
printf(″/%-10d/ \n″, 337); /* imprime /337 / */
printf(″/%4.2f/ \n″, 1234.56); /* imprime /1234.56/ */
printf(″/%10.3f/ \n″, 1234.56); /* imprime / 1234.560/
*/
printf(″/%10:3E/ \n″, 1234.56); /* imprime / 1.23E+03/
*/
printf(″%d %c\n″, 336,336); /* imprime 336 P */
printf(″%d %c\n″, ‘A’,’A’); /* imprime 65 A */
printf(″%Ld %d\n″, 65616,65616); /* imprime 65616 80 */
13- Lecture formatée.
Le scanf fonctionne sur le même principe que le printf, la suite d’expressions

étant remplacée par une suite d’adresses de variables. Pour avoir l’adresse d’une
variable, il faut faire précéder l’identificateur du symbole &. Pour les chaînes de
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);
Données tapées au clavier :

25
--------
--------
295.75 chaussure type danse
les affectations produites seront :

pourcentage 25
prix 295.75
libelle chaussure
Une spécification de format contenant le symbole * après % indique que la donnée

correspondante doit être ignorée lors de la lecture.
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
IV- Les instructions et structures de contrôle.
1- Séquence.
C’est un bloc d’instructions entre accolades.
{ a1 ; a2 ; }
; terminaison d’instruction
{
<déclarations locales>
<suite instructions> joue le rôle d’une instruction
}
2- Répétitions.
. while (expression) < inst >

int = 0 faux
≠ 0 vrai
Tant que : test en début de boucle
. do <instructions> while(<expression>)
Test en fin de boucle => exécuté au moins une fois.
. for(<exp1>;<exp2>;<exp3>)<inst> ;
Effectué en fin d’itération
Test de continuation
Initialisation avant boucle
. Instructions de contrôle de boucles
 break => sortie de boucle immédiatement englobante
for(i=0;i<n;i++)
if(tab[i]==a)break; /*récupère i correspondant à tab[i]= a
*/
 continue => arrêt de l’itération en cours.
for ( i = 0 ; i<n ; i++ )

{
if ( tab[i] % 2 != 0 ) continue ;
/* somme des pairs contenus dans le tableau tab[] */
s = s + tab[i] ;
}
3- Choix.
a- Choix simple.
if(<exp>) <inst> ;
if(<exp>) <inst1> else <inst2>
if(a<b)
if(c<d)u=0;
else i=j;
else se rapporte au dernier if
if(a>b)
{ if(c<d)u=v;}
else i = j ;
if(x) équivaut à if(x!=0)
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.
Un point-virgule constitue l’instruction vide ;
Exemples :
for(i=0 ;i<N ;t[i++]=0) ;

/*on boucle sur l’instruction vide, car tout est fait dans
le for */
while((c=getchar())=’ ‘||c==’\t’) ;/* boucle pour ignorer

les blancs et tabulations sur la chaîne d’entrée */
Remarques :
Quelques erreurs courantes :
c=0;
if(c=0) <inst1>;
else <inst2>; /* on passe toujours par inst2 */
rep=‘n’;
while(rep==‘0’||‘0’) /* toujours vrai */
{…}
for(i=0 ;i<N ;i++) ;

{ t[i]=i ;
-------- ;
-------- ;
} /* le bloc n’est pas exécuté sous contrôle de for */
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 :
Pas de ; après l’en-tête

Le corps de la fonction comportera un ou plusieurs return(<expression>) de
manière à retourner le résultat.
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 :
int maxEntiers(int a, int b)

{if(a>b)
return a ;
else
return b ;
}
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
Un seul mode de transmission des paramètres en C, par valeur. Rappelons le

fonctionnement de la transmission par valeur :
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 :
Une fonction peut s’appeler récursivement.

4- Portée des déclarations.
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.
Les identificateurs d’un même bloc doivent être tous différents.

Les identificateurs d’un bloc peuvent être les mêmes que ceux d’un bloc englobant,
mais ces derniers deviennent inaccessibles.
b- Attributs des variables locales :

auto (par défaut) : variable locale automatique, la place mémoire associée est prise
dans la pile d’exécution et libérée lors du retour à l’appelant.
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.
Ce sont des variables déclarées en dehors de toute fonction, en conséquence, elles

deviennent globales pour toutes les fonctions du fichier source de déclaration et même
pour d’autres fichiers source compilés séparément.
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()
}
{-------;
--------
--------
}
La variable i déclarée extern dans fichier2.c est celle de fichier1.c. Si on veut

qu’une variable externe soit inaccessible depuis d’autres fichiers sources, il faut la
déclarer static.
5- Structure d’un programme.
Il est possible d’organiser le programme de diverses manières, soit :
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().
Dans la seconde configuration, déclarant uniquement des prototypes de fonctions

avant le main(), toute fonction peut appeler n’importe quelle autre.
6- Compilations séparées et projet.
Dans le cadre de la réalisation d’un projet informatique de taille conséquente, il

convient de le découper en modules plus petits, compilés séparément, et regroupés lors
de l’édition de liens en un seul module binaire exécutable.
module1.h module2.h
int f1(int n) ; int f3(int n) ;
float f2(int n); float f4(int n);
principal.c module1.c module2.c

#include #include #include
“module1.h” “module1.h” “module2.h”
#include int f1(int n) int f3(int n)
“module2.h” {------ {------
void main() -------- --------
{-------- } }
--------- float f2(int n) float f4(int n)
--------- {------ {------
} -------- --------
} }
Compilatio Compilatio Compilatio

n n n
C C C
principal.obj module1.obj module2.obj
Edition de liens : Link
principal.exe
VI- Tableaux : approche traditionnelle.
1- Déclaration de tableau.
Syntaxe de déclaration :
<type des éléments> < ident-tableau> [ <nombre d’éléments>

] ;
Le nombre d’éléments <nombre d’éléments> doit être une expression statique

évaluable à la compilation. Les indices vont de 0 à (<nombre d’éléments>– 1).
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.
2- Initialisation de tableau à la déclaration.
Ce n’est possible que pour les déclarations externes. Exemple :
#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 :
char chaine[8]= "bonjour" ;
3- Référence à un élément de tableau.
ident-tableau> [ <expression-entière> ]
Attention, la valeur de <expression-entière> doit être comprise entre 0 et

(<nombre d’éléments>– 1) mais le compilateur ne génère aucune vérification
d’indice, et une erreur peut entraîner un accès à un endroit quelconque de la mémoire.
VII- Les pointeurs.
1- Définition.
Un pointeur est une variable contenant l’adresse mémoire d’une autre variable.
2- Déclaration de pointeur.
En C, on doit déclarer le type de l’objet pointé. Exemples :
int * i ; char * p ; float * px, * py ;
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.
L’opérateur & placé devant un identificateur permet de récupérer l’adresse mémoire de

la variable.
int i ; int * p ;
p=&i;
4- Opérateur d’indirection.
L’opérateur * placé devant un identificateur permet d’accéder au contenu de la cellule

mémoire pointée. Toutes les opérations liées au type de l’objet pointé sont permises.
Mémoire
i 2
*p = 2; /* i prend la valeur 2 */
k = *P + 1 ; /* k prend la valeur 3 */
Attention : *p++ équivaut à * (p++)
5- Arithmétique des pointeurs.

On peut ajouter ou retrancher un entier à un pointeur. La valeur effectivement ajoutée

dépend du type de l’objet pointé. Une unité correspond à la taille mémoire de l’objet
pointé.
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
int tab[4] ; int * p ;

p= tab;
p=p+3;/* p pointe maintenant vers le dernier element du
tableau*/
6- Passage de paramètre par adresse dans les fonctions.
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 */
}
Exemple d’une fonction travaillant comme une procedure en ADA, effectuant

l’échange des valeurs de deux variables entières passées en paramètres :
void echange(int * a, int * b)

{
int aux ;
aux = *a ;
*a = *b ;
*b=aux ;
}
main()
{int i= 10 ,j= 20;
echange(&i,&j) ;
printf("\n%d,%d ",i,j) ;/*affiche 20,10 */
}
7- Relations entre tableaux et pointeurs.
a- Tableaux monodimensionnels.
Le nom du tableau est équivalent à un pointeur constant contenant l’adresse du

premier élément.
int tab[10] ;
tab équivaut à &tab[0]
L’expression d’indexation est traduite par le compilateur par une translation d’adresse
suivie d’une indirection:
tab[i] est traduit par *(tab + i)
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 :
tab[i] équivaut à i[tab]
puisque i[tab] est traduit par *(i + tab), identique à *(tab + i)
Si un tableau est paramètre formel, la transmission est implicitement par adresse, et le

paramètre effectif correspondant est simplement le nom du tableau.
int sommeElements(int tab[], int N)

{
int i,somme=0 ;
for(i=0 ;i<N ;i++)
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.
Ce sont des tableaux de tableaux, on trouvera plusieurs paires de [] contenant des

indices. C’est l’indice le plus à droite qui varie le plus vite du point de vue de
l’implantation mémoire.
int tab[3][5]={ {0,1,2,3,4},

{10,11,12,13,14},
{20,21,22,23,24} };
tab 0
1
2
3
4
tab[1] 10
11
12
13
14
tab[2] 20
21
22
23
24
paramètre formel L’expression d’indexation est transformée par le compilateur en

l’expression d’indirection suivante :
tab[i][j]=*(tab + i * taille_ligne + j)
Un paramètre formel tableau à plusieurs dimensions devra avoir le nombre d’éléments

de chacune de ses dimensions renseigné, de façon à ce que le compilateur puisse
transformer l’expression indicée en indirection.
VIII- Les chaînes de caractères.
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’.
1- Déclarations et initialisations de chaînes.
a- Tableau de caractères (dimensionné ou non).
char texte1[10]={‘e’,’x’,’e’,’m’,’p’,’l’,’e’,’\0’} ;
On réserve 10 caractères et on initialise comme un tableau, en n’omettant pas le

caractère ‘\0’.
char texte2[10]= "exemple";
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.
char texte3[]= "exemple";
Dans ce cas, 8 octets ont été réservés, c’est-à-dire exactement la taille utile.
b- Pointeur de caractères.
char * texte4= "exemple";
Précisons maintenant le travail effectué par la notation "":
allocation de N+1 octets si la chaîne a une taille de N caractères.

Copie des N caractères dans la zone mémoire réservée.
Ajout de ‘\0’ à la fin
L’adresse de la zone mémoire allouée est renvoyée
texte4 est un pointeur de caractères pointant vers cette zone mémoire allouée par
"".
texte4
exemple\0
Attention, il y a une différence avec la déclaration de texte3[], on pourra faire, par

la suite, texte4= "salut" mais on ne pourra pas faire texte3= "salut" ,
car un tableau est analogue à un pointeur constant (la dernière affectation reviendrait à
modifier la valeur de l’adresse associée à texte3.
On portera également attention aux différences d’impression dans les exemples
suivants :
printf("%c",* texte4) ;/*affiche : e */

printf("%s", texte4) ;/*affiche : exemple */
2- Tableau de chaînes de caractères.
On peut déclarer soit un tableau de caractères à 2 dimensions, soit un tableau de

pointeurs de caractères à 1 dimension .
char fruit[3][8]= {"pomme","abricot","orange"};

char *fruit[3]= {"pomme","abricot","orange"};
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.
scanf({"%s",<adresse début de chaine>)
Effectue la saisie d’une chaîne de caractères tapés au clavier, jusqu’à la rencontre du

premier espace ou ‘\n’.
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.
gets(<adresse début de chaine>)
Effectue la saisie d’une chaîne de caractères tapés au clavier, jusqu’à la rencontre du

premier ‘\n’. L’’\0’ est rajouté automatiquement.
gets renvoie l’adresse de début de chaîne ou NULL si on est en fin de fichier.
4- Impression de chaîne.
printf({"%s",<adresse début de chaine>)
puts(<adresse début de chaine>)
5- Fonctions de manipulation de chaîne.

a- Copie de chaînes.
strcpy( <adresse chaine1>, <adresse chaine2>)
recopie le contenu de la mémoire depuis <adresse chaine2> jusqu’à la rencontre

d’un ‘\0’, à partir de <adresse chaine1>. Attention, le compilateur n’effectue
aucune vérification quant à la réservation d’un espace mémoire suffisant pour stocker
chaîne1.
b- Concaténation de chaînes.
strcat(<adresse chaine1>, <adresse chaine2>)
concatène le contenu de la mémoire depuis <adresse chaine2> jusqu’à la

rencontre d’un ‘\0’, au contenu de la mémoire à partir de <adresse chaine1>.
Attention, le compilateur n’effectue aucune vérification quant à la réservation d’un
espace mémoire suffisant pour stocker le résultat de la concaténation de chaîne1 et
chaîne2.
c- Comparaison de chaînes.
strcmp(<adresse chaine1>, <adresse chaine2>)
compare le contenu de la mémoire depuis <adresse chaine1> jusqu’à la

rencontre d’un ‘\0’, au contenu de la mémoire à partir de <adresse chaine2>
jusqu’à la rencontre d’un ‘\0’. La valeur retournée est 0 si les chaînes sont égales, une
valeur négative si chaîne1 précède chaîne2 au sens lexicographique, ou une valeur
positive si chaîne1 suit chaîne2 au sens lexicographique.
d- Longueur de chaîne.
strlen(<adresse chaine1>)
La valeur retournée est la longueur de la chaine sans compter le caractère ‘\0’.

IX- Structures de données et allocation dynamique.
1- Structures.
La notion de structure est analogue à celle de RECORD dans d’autres langages

comme ADA ou PASCAL. On peut ainsi regrouper des variables de types différents
sous un même nom.
Déclaration de structure.
struct <ident-structure>
{ <type1> <ident1> ;
<type2> <ident2> ;
-----------------
-----------------
<typen> <identn> ;
}
<ident1> , <ident2>,…,<identn> sont les champs de la structure.
Pour déclarer des variables du type de la structure :
struct <ident-structure> <ident1>,<ident2>,…,<identn>;

struct Date { int jour ;
int mois ;
int annee ;} ;
struct Date d1,d2 ;
struct Personne { char nom[25] ;

char prenom[25] ;
int age ;} p1, p2 ;
On peut aussi déclarer des variables du type de la structure, juste après la déclaration
de structure.
2- Accès aux champs de la structure.
<ident-structure>.<ident-champ>
printf("La personne %s est agée de %d ",p1.nom,p1.age)
3- Imbrication de structures.
Un champ d’une structure peut être une structure

:
struct Personne { char nom[25] ;
char prenom[25] ;
struct Date date_naissance ;} p1, p2 ;
p1.date_naissance.annee permet d’accéder à l’année de naissance de la

personne p1.
4- Tableaux de structures.
struct Personne p[100] ;
p[i].nom permet d’accéder au nom de la personne p[i]
5- Structures récursives.
La récursivité directe, c’est-à-dire déclarer un champ de structure du type de la

structure qu’on est en train de déclarer, est interdite. Par contre un champ peut être un
pointeur vers la structure qu’on est en train de déclarer.
On utilise cette possibilité pour implémenter des listes chaînées, qui permettent,
conjointement à l’utilisation de l’allocation dynamique, de n’allouer que l’espace
mémoire nécessaire au stockage de données qui apparaissent en cours d’exécution.
struct Cellule { int info ;

struct Cellule * suivant ;} ;
struct Cellule * tete ;
tete
10 49 -5
NULL
6- Passage de structures en paramètres ou retour de structure .
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 :
int comparDate(struct Date *p1,

struct Date *p2)
{
if((*p1).annee < ((*p2).annee)
return -1;
else if((*p1).annee == ((*p2).annee)
return 0;
else return 1;
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 .
En C ANSI, il est possible de passer en paramètres des structures ou de retourner des

structures.
int comparDate(struct Date d1,

struct Date d2)
{
if( d1.annee < d2.annee)
return -1;
else if (d1.annee == d2.annee)
return 0;
else return 1;
}
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.
union Nombre { int entier ;

float reel ;} ;
union Nombre n1,n2 ;
L’accès à la bonne version de la variable se fait de manière analogue à l’accès au

champ d’une structure :
n1.entier ou bien n1.reel
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.
Pour palier ces inconvénients, on a recours à l’allocation dynamique, qui permet

d’allouer de la mémoire à l’exécution, selon ses besoins. Les zones mémoires allouées
sont prise dans une partie de la mémoire dédiée, le tas. Les zones mémoires allouées
dans le tas sont accessibles de partout jusqu’à récupération de l’espace mémoire ou
jusqu’à la fin de l’exécution du programme.
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>)
où <ident> est soit un identificateur de type soit un identificateur de variable.
(struct Personne *)malloc(sizeof( struct Personne))
b- Libération de mémoire.
On peut libérer un espace mémoire qui a été auparavant alloué dynamiquement à

l’aide de la fonction free,connaissant l’adresse de début <adresse> :
free(<adresse>)
X- Le Préprocesseur.
Il existe une phase de précompilation effectuée par le préprocesseur avant la

compilation, qui consiste à traiter dans le texte source, toutes les directives
commençant par #.
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.
#define symbole valeur

Toutes les occurrences de symbole dans le texte source sont remplacées par valeur.
Ceci permet de définir des constantes (taille d’un tableau par exemple).
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 :
#define max(A,B) (((A)>(B))?(A):(B))
main()
{ int i=6,m;
…….
m=max(i,10);
………
la substitution donnera:
main()
{ int i=6,m;
…….
m=(((i)>(10))?(i) :(10));
…….
Attention au contexte d’utilisation :
pas de types de paramètres

parenthéser les paramètres dans le corps (sinon risque d’évaluations erronées).
Exemple :
#define carre(x) x*x

main()
{int x=5 ;
printf(″%d″,carre(x)) ;/* affiche : 25*/
printf(″%d″,carre(x+2)) ;/* affiche : 17*/
}
en effet, carre(x+2) sera remplacé par :
5+2*5+2
Donc, il faut définir la macrofonction carre de la manière suivante :

#define carre(x) (x)*(x)
3- Suppression d’une définition précédente.

#undef symbole
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………….
XI- Les Fichiers C.
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.
Le fichier header stdio.h contient :

Les fonctions d’Entrée/Sortie
La constante EOF
La constante NULL
Le type FILE
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
un + après le r ou w autorise la lecture.

Un t à la fin du mode indique un fichier texte, un b un fichier binaire.
Si l’ouverture échoue, fopen renvoie NULL, sinon un pointeur vers un descripteur de

fichier. Toutes les autres instructions de manipulation de fichiers utilisent ce pointeur.
Exemple d’ouverture d’un fichier texte de nom « f_donnees », en lecture :

#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)
Ferme le fichier de nom interne f, et renvoie 0 si OK.
3- Lecture/écriture de caractères.
a- Lecture de caractères.
int getc(FILE * f)
Retourne le caractère lu ou EOF (c’est-à-dire la valeur -1).
b- Ecriture de caractères.
void putc(int c,FILE * f)
c est le caractère à écrire.
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 ;
fentree=fopen(" entree ", "rt") ;

fsortie=fopen("sortie" , "wt");
while ((c=getc(fentree))!=EOF)
putc(c,fsortie);
4- Lecture/écriture de lignes.
a- Lecture de lignes.
char * fgets(char * tampon, int taille,FILE * f)
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’.
Renvoie NULL en fin de fichier ou l’adresse du tableau tampon sinon.
b- Ecriture de lignes.
int fputs(char * tampon,FILE * f)
5- Lecture/écriture formatées.
a- Lecture formatée.
int fprintf(FILE * f, char * format,<liste de parametres>)
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.
int fscanf(FILE * f, char * format,<liste de parametres>)
fonctionnement est analogue à celui de scanf.
6- Lecture/écriture de blocs.
a- Lecture de blocs.
int fread(char * tampon, int taille,int nombre,FILE * f)

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.
int fwrite(char * tampon, int taille,int nombre,FILE * f)
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)
Renvoie 1 si fin de fichier, 0 sinon.
b- Erreur d’E/S.
int ferror(FILE * f)
Renvoie 0 si pas d’erreur, ≠0 sinon.

L’erreur concerne la dernière opération d’entrée/sortie effectuée.
c- Positionnement direct sur un octet.
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.
int fseek(FILE * f, long dep,int mode)
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
d- Repositionnement en début de fichier.
void rewind(FILE * f)
équivaut à fseek(f,0L,0)
e- Position courante.
long ftell(FILE * f)
renvoie la valeur actuelle du « point de déplacement ».

M16 Informatique Industriel

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

M16 Informatique Industriel

Hochgeladen von

Copyright:

Verfügbare Formate

ROYAUME DU MAROC

Office de la Formation Professionnelle et de la

MODULE N°16: INFORMATIQUE INDUSTRIELLE

SECTEUR : RÉPARATION DES ENGINS À

SPÉCIALITÉ : DIAGNOSTIC ET ÉLECTRONIQUE

NIVEAU : TECHNICIEN SPÉCIALISÉ

Nom et prénom EFP DR

Les modules Page

- Le module Informatique industrielle est le 16éme de la liste des

p. ex. pour la comptabilité, le calcul

Illustration 2: Genre de données

4.4 Systèmes arithmétiques

Capacité de stockage. Les capacités de stockage des supports de données internes et

4.5 Structure d'un ordinateur

Illustration 1: Appareil de base

Illustration 2: Le cœur d'un système informatique

AGP Parallèle Supérieure à 533 MByte/s Interface pour carte graphique

Illustration 1: Interfaces à prises situées à l'arrière d'un ordinateur

Illustration 1: Structure d'un réseau en étoile

Illustration 2: Structure en arbre et structure en anneau

Illustration 1: Réseau client-serveur

Illustration 2: Offre de services en ligne

Mémorisation intermédiaire et mémorisation définitive. Durant le travail à l'ordinateur, des

A noter que la compréhension et la bonne réalisation de ces TP nécessite la compréhension

L’algorithmique donne les techniques fondamentales pour construire un programme logique.

La deuxième annexe aborde les techniques de programmation en langage C nécessaire pour la

A la fin de ces TP vous serais en mesure de comprendre en profondeur le fonctionnement des

Plan des travaux pratiques

-Travaux pratique N°1 :

Commande d’une diode LED

-Travaux pratique N°2 :

Utilisation d’un bouton poussoir

-Travaux pratique N°3 :

-Travaux pratique N°4 :

Commande d’un afficheur LCD

-Travaux pratique N°5 :

Gestion de la conversion A/N

-Travaux pratique N°6 :

L’acquisition de la température et de l’humidité : le capteur DHT11

-Travaux pratique N°7 :

Mesure de la distance : le capteur HC-SR04

-Travaux pratique N°8 :

Commande d’un servomoteur

-Travaux pratique N°9 :

Interfaçage Labview - Arduino (initiation)

TP 1 : COMMANDE D’UNE DIODE LED

 Volume horaire : 3 heures

Figure 1 : image et symbole d'une LED

Figure 2 : Tension et courant de seuil d'une LED

Figure 3 : Code couleurs des résistances

Réalisez le montage de la figure suivante :

Figure 4 : branchement d'une diode LED

Figure 5 : Structure d'un programme ARDUINO

Figure 6 : Vérification et chargement du programme

TP 2 : UTILISATION D’UN BOUTON POUSSOIR

 Volume horaire : 6 heures

Figure 7 : Différentes vues d'un bouton poussoir

Figure 8 : Branchement d'un bouton poussoir

2.2 Programmation de la carte :

Figure 9 : Combinaisons du dé numérique

 Volume horaire : 6 heures

Figure 10 : Clavier numérique 3x4 à ruban

Figure 11 : Branchement du clavier à la carte ARDUINO