• Apprendre à programmer en langage C

Outils logiciels de base

ELE002

ELE002 Outils logiciels de base

• Objectifs pédagogiques

Acquérir les bases de la programmation et savoir utiliser quelques logiciels parmi les plus courants. Cet enseignement est organisé à partir de cours et de travaux pratiques.

• Capacité et compétences acquises

Connaissances des outils informatiques du technicien .

• Organisation

Nombre de crédits enseignements : 8 ECTS Type de la formation : Cours

• Contenu de la formation Première partie

La programmation en langage C

Les principes, les variables, l'affectation, les instructions élémentaires, les boucles.

Les fonctions, les tableaux et les pointeurs.

L'utilisation de logiciels Le système d'exploitation.

Présentation de linux.

Deuxième partie

La programmation en langage C

Les chaines de caractères, les structures et les fichiers.

L'utilisation de logiciels Le traitement de texte.

Le tableur.

Initiation à Matlab

Les exercices sont effectués en séance par les auditeurs sur ordinateurs.

Objectifs

• Apprendre à programmer en langage C

• Appréhender la structure des systèmes informatiques

• Utiliser les environnements de développement

• Connaître les outils informatiques utiles au domaine de l’Électronique tels que :

- Matlab (et ses alternatives gratuites)

- Excel, Word, etc.

Supports

• Polycopié " Outils logiciels de base" ; code ELE002 ; C. Alexandre & C. Pautot Environ 10€

• CDROM (vendu 1€) contenant le cours en version pdf ainsi que d'autres cours et les

logiciels utilisés durant l'année (Codeblocks,

Visual studio, Octave, Scilab, OpenOffice, …)

Déroulement

• Bases du langage C (3 à 4 séances)

• Programmation "d'algorithmes élémentaires" (5 à 6 séances)

• Fonctions, pointeurs et tableaux en C (7 à 8 séances)

• Projet Mastermind (3 à 4 séances)

• 1

Examen (fin février ou début mars)

• Chaînes de caractères, structures, fichiers (7 à 8 séances)

• Introduction à Matlab (Octave, Excel, ...)

• 2

Examen (début juin)

• Examen de rattrapage (mi juin)

Bases du langage C (3 à 4 séances)

• Structure d'un système informatique (ordinateur, µP, DSP, …)

• Programmation en langage "évolué" (langage C)

• Programme

• Environnement de développement (Codeblocks)

Structure d'un système informatique

µP

Mémoire permanente : Disque dur (lenteur)

ROM (Read Only Memory)

RAM

(Random Access Memory)

Clavier, capteurs, …

Ecran, afficheurs, commandes, …

Programmation en langage "évolué"

Les premières machines étaient programmées en "langage machine" :

Suite d'instructions exprimées en binaire et directement exécutables par le système.

Exemple :

Charger une valeur depuis la case mémoire 68 après celle pointée par le registre 3 dans le registre 8 :

100011 00011 01000 000000000001000100 op | rs | rt | adresse

Inconvénient : très difficile pour l'homme habitué aux langages évolués Alternative :

100011 00011 01000 000000000001000100 35 3 8 68

Langage Assembleur

Idée : utiliser des mnémoniques :

100011 00011 01000 000000000001000100 load r3 r8 68

Exemple tiré de Wikipedia :

.global _start

BONJ: .ascii "Bonjour\n" ; Définition en mémoire de la chaîne à afficher.

_start: mov $4 , %eax ; Mettre 4 dans le registre eax (appel système '''Write'')

mov $1 , %ebx ; Mettre 1 dans le registre ebx (descripteur de fichier ''STDOUT'') mov $BONJ , %ecx ; Mettre l'adresse mémoire de notre chaîne dans ecx

mov $8 , %edx ; Mettre la taille de la chaîne dans edx

int $0x80 ; Interruption 0x80, exécutant un appel système sous Linux) mov $1 , %eax ; Mettre 1 dans eax (appel système ''Exit'')

mov $0 , %ebx ; Mettre 0 dans ebx (valeur de retour du programme)

int $0x80 ; Interruption 0x80, exécutant un appel système sous Linux)

Inconvénient : pénible, peu productif et surtout "non portable"

Langage évolué

Exprimer les tâches à exécuter dans un langage simple dont les règles syntaxiques sont claires et faciles à retenir pour l'Homme.

Exemple : y=2*x+b

Inconvénient : Nécessité de traduire les instructions de haut niveau en langage machine (traduction automatique sous optimalité)

Avantages : productivité accrue, portabilité

Le langage C est le langage évolué le plus utilisé. Il en existe d'autres : Fortran, Pascal, Ada,

Programmation rigoureuse et résultats de grande valeur (majorité des applications) Très bonne protection du code

Tendance : Langages interprétés (traduction à la volée) :

Basic, langage de script (sh, PHP, Perl, Python, Tcl, …), Java, Matlab, …

Programmation rapide mais exécution plus lente et nécessité d'un interpréteur Protection difficile

Programme

Code source écrit par le programmeur :

#include <stdio.h>

#include <stdlib.h>

int main() {

printf("Bonjour\n");

return 0;

}

Puis traduit en code exécutable :

bonjour.c traduction Bonjour.exe

Code source Executable

Bonjour.o Code objet compilation

Edition de liens

Environnements de développement

Le langage C

Le langage C a été inventé en 1972 par Kenneth Thompson et Dennis Ritchie aux laboratoires Bell pour écrire UNIX et assurer sa portabilité.

Brian W. Kernighan et Dennis M. Ritchie, "Le langage C"

Normalisé en 1989 : ANSI C ou C89 Puis en 1999 par l'ISO : C99

Le langage C est particulièrement bien adapté à :

- L'écriture des systèmes d'exploitation (Windows, Linux (Unix), Mac OS X, … - La programmation embarquée sur microcontrôleurs

- Les calculs intensifs (maths, traitement des images, traitement du signal, etc …) l'électronique

Le C est un langage simple. Son compilateur l'est également et le code assembleur généré est quasi-optimal. Il est souvent choisi comme premier langage pour une nouvelle architecture.

Le C n'est pas un langage orienté objet.

C++ est une extension du langage C qui l'enrichi de la notion d'objet.

Kenneth Thompson

Dennis Ritchie

Un programme C

#include <stdio.h>

#include <stdlib.h>

int main() {

printf("Bonjour\n");

return 0;

}

Inclusion

des

"stdlib.h" nécessaires à l'utilisation des fonctions de la bibliothèque standard du C

main() est le nom de la fonction principale de tout programme C ; aussi appelée point d'entrée du programme

Corps du programme délimité par des accolades ("{" et "}") et constitué

d'instructions séparées par des points virgules ";"

Instructions

#include <stdio.h>

#include <stdlib.h>

int main() {

printf("Bonjour\n");

return 0;

}

printf("Bonjour\n") est une instruction qui fait appel à la fonction d'écriture standard

"printf()".

"Bonjour\n" est une chaîne de caractères (suite de caractères) fournie à la fonction printf()et destinée à être affichée à l'écran.

"\n" est un caractère spécial signifiant d'aller à la ligne.

return 0 est une instruction commandant de quitter la fonction main() en renvoyant la valeur 0 à l'extérieur.

Programme effectuant un calcul

#include <stdio.h>

#include <stdlib.h>

int main() { int x,y;

x=5;

printf("La valeur de x est : %d\n",x);

y=x*x;

printf("La valeur de x au carré est : %d\n",y);

printf("La valeur de %d au carré est : %d\n",x,y);

return 0;

}

A voir :

Notion de variable

Fonctionnement de la fonction printf()

Déclaration des variables x et y (mémoires) destinées à contenir des valeurs entières Initialisation de la variable x à 5 (affectation)

Affichage de : La valeur de x est : 5↵ Calcul de y (x au carré)

Affichage du résultat Affichage plus complexe Fin de la fonction main() et donc du programme

Variables

Une variable est un nom qui sert à repérer un emplacement mémoire dans lequel on peut ranger une valeur

.

Le nom :

Les noms de variables sont sensibles à la casse.

Les caractères qui les composent doivent être choisis parmi les 26 lettres majuscules et minuscules de l’alphabet, les chiffres de 0 à 9 et l’underscore _.

Le premier caractère du nom ne doit pas être un chiffre.

Pas d’espace, pas de caractères accentués.

Le compilateur s’arrête à 32 caractères.

Noms corrects : A, A1, n_1, racine_carree

Noms incorrects : 1a, nombre 1, racine_carrée, nombre-1

Types de variable

Différents types de valeur peuvent être rangés dans l'emplacement mémoire :

Valeur entière : type int Valeur réelle : type float

Code de caractère : type char Exemples de déclaration :

int n, p;

float valeur, X1, X2;

char reponse;

Exemples d'affectation : n = 10;

X1=3.14;

Exercices 3.1 et 3.2 + voir en détail les différents types

Les types entier

Exemple :

short int n, o, p;

n = 10;

o = +15;

p = -2542;

n = p + o;

type nombre

de bits

intervalle

unsigned short int 16 0 à (2¹⁶-1 = 65535)

short int 16 (-2¹⁵=-32768) à (2¹⁵-1 = 32767) unsigned long int 32 0 à (2³²-1= 4 294 967 295)

long int 32 (-2³¹=-2 147 483 648) à (2³¹-1 = 2 147 483 647) int 32* (-2³¹=-2 147 483 648) à (2³¹-1 = 2 147 483 647)

Les types réels

Exemple :

float n, o, p;

n = 12.43;

o = -0.38e-33;

p = -4.0;

signe exposant (signé) mantisse (non signée)

2^-64 ≈ 10^-19 2¹⁶³⁸⁴ ≈

10⁺⁴⁹³² 1 + 15 +

64 80

long double

2^-52 ≈ 10^-15 2¹⁰²⁴ ≈ 10⁺³⁰⁸

1 + 11 + 52 64

double

2^-23 ≈ 10^-7 2¹²⁸ ≈ 10⁺³⁸

1 + 8 + 23 32

float

précision max valeur max

(valeur min*) format

nombre de bits type

* : la valeur min se détermine à partir de la valeur max (ex : max = 10⁺³⁸ ⇒min = 10^-38)

Les types caractère

Exemple :

char n, o, p;

n = ‘s’; /* un caractère normal */

o = 100; /* un petit entier */

p = ‘\n’; /* le caractère spécial line feed */

p = 0x0A ; /* toujours un line feed */

type nombre de bits intervalle

unsigned char 8 0 à (2⁸-1 = 255)

char 8 (-2⁷=-128) à (2⁷-1 = 127)

La fonction printf()

La fonction printf() permet d’afficher un message paramétrable.

Exemple :

printf("La valeur de %d au carré est : %d\n",x,y);

Le premier argument définit le message à afficher et peut contenir des codes de format (%d, %f, %c, …) destinés à être remplacés par des valeurs de variables.

Les argument suivants sont les variables dont les valeurs doivent être affichées à la place des codes de format.

Le premier argument est aussi appelé "format"

Les variables peuvent être remplacées par des valeurs constantes

Codes de format

• %d : entier en décimal

• %x : entier en hexadécimal

• %f : réel en notation sans exposant

• %e : réel en notation scientifique

• %g : réel en notation la mieux adaptée

• %c : caractère

voir la documentation sur printf()

Les codes de formats doivent être appropriés aux variables !

La fonction scanf()

La fonction scanf() permet de "lire" au clavier une ou plusieurs variables.

Exemple :

scanf("%d %d",&x,&y);

Le premier argument contient les codes de format (%d, %f, %c, …) indiquant comment effectuer les conversions.

Les argument suivants sont les noms des variables précédés du caractère

"&".

Les déclarations

Avant d'être utilisée pour mémoriser une donnée, une variable doit être "déclarée" : int nb_pommes=10;

Nom de la variable type

Initialisation éventuelle

En C, les déclarations doivent être effectuées au début des blocs d'instructions : Plusieurs variables de même types peuvent être déclarées en même temps : int nb_pommes=10,nb_poires;

Le séparateur est une virgule

{

int i,j;

float pi2,pi=3.14159;

i=i+j;

pi2=pi/2;

}

Déclarations

Suite du programme

Bloc d'intructions

Les affectations

Les affectations sont les instructions les plus courantes : nb_pommes=nb_sacs*nb_pommes_par_sac+10;

Signe de l'affectation

Membre de gauche : nom de variable Membre de droite : expression

Les expressions sont constituées de variables et d'opérateurs et éventuellement de parenthèses :

nb_pommes=(nb_sacs*nb_pommes_par_sac)+10;

Les parenthèses servent à préciser l'ordre des calculs. En absence de parenthèse, c'est la priorité relative des opérateurs qui détermine l'ordre.

Les expressions sont évaluées de la gauche vers la droite : nb_pommes=nb_sacs*(nb_pommes_par_sac+10);

Si nb_sacs est nulle, le reste de l'expression n'est pas évalué.

Opérateurs

Les opérateurs

Priorités :

opérateur unaire de négation (ex : -b;) -

reste de la division entière (modulo)

%

division entière /

multiplication

*

addition, soustraction +, -

opération symbole

en cas d’égalité, le calcul s’effectue de gauche à droite

+, - min

en cas d’égalité, le calcul s’effectue de gauche à droite

*, /, % moy

- (négation) max

commentaires symbole

priorité

L’instruction if

L’instruction if permet de réaliser des choix

if(p>127) {

printf("p est superieur a 127\n");

} else {

printf("p est inferieur ou égal a 127\n");

}

optionnel

p>127

?

"p est superieur

a 127"

"p est inferieur

ou égal a 127"

oui

non

fin

// Imbrication if(p>127) {

printf("p est superieur a 127\n");

} else {

if(p==127) {

printf("p est egal a 127\n");

} else {

printf("p est inferieur a 127\n");

} }

Les conditions

non égal

!=

supérieur ou égal

>=

inférieur ou égal

<=

supérieur

>

inférieur

<

égal

==

signification opérateur

non

!

ou

||

et

&&

signification opérateur

vrai si les deux conditions a<b et c<d sont vraies ou si i=5 ((a<b)&&(c<d))||(i==5)

vrai si la condition a<b est fausse

!(a<b)

vrai si l’une au moins des deux conditions a<b et c<d est vraie (a<b)||(c<d)

vrai si les deux conditions a<b et c<d sont vraies (a<b)&&(c<d)

Exemples :

Possibilité de combiner les conditions :

La valeur d'une condition fausse est 0 La valeur d'une condition vraie est 1

Une valeur nulle est fausse Une valeur non-nulle est vraie

Les structures de répétitions (boucles)

Elle sont de 2 types :

Type 1 : Tant que condition faire instructions Type 2 : Faire instructions tant que condition

instruction;

instruction;

…

condition

? non oui

Type 2

condition

?

instruction;

instruction;

… oui

non

Type 1

tant que condition faire instructions

while (condition) { instructions }

condition

?

instruction;

instruction;

… oui

non

for(init;cond;incr) { instructions }

initialisation, initialisation,

…

instruction, instruction,

…

Deux solutions : while et for

Exemple

while

// Somme des N premiers nombres entiers int somme,i,N;

scanf("%d",&N);

somme=0;

i=1;

while(i<N) { somme=somme+i;

i=i+1;

}

printf("La somme des %d premiers \ entiers est %d\n",N,somme);

for

// Somme des N premiers nombres entiers int somme,i,N;

scanf("%d",&N);

somme=0;

i=1;

for(i=1; i<N; i=i+1) { somme=somme+i;

}

printf("La somme des %d premiers \ entiers est %d\n",N,somme);

Les boucles for sont les boucles les plus utilisées en C

faire instructions tant que condition

do { instructions } while (condition)

condition

? non oui

instruction;

instruction;

…

// Somme des notes tant que note # 0 int somme,note;

somme=0;

do {

scanf("%d",&note);

somme=somme+note;

} while(note!=0);

printf("La somme des notes est %d\n",somme);

Surtout utilisé lorsque la condition est liée au corps de la boucle.