BASES DE PROGRAMMATION EN LANGAGE C SOUS LINUX

BASES DE PROGRAMMATION EN LANGAGE C SOUS LINUX

INFORMATIQUE INDUSTRIELLE

1

TRAVAUX DIRIGÉS EN INFORMATIQUE INDUSTRIELLE

ENVIRONNEMENT DE DÉVELOPPEMENT

2

▸ Raspberry Pi Model 3B

▸ Carte microSD - Raspbian patché Xenomai

▸ Ecran sur port HDMI

▸ Un clavier et une souris USB


OBJECTIFS DE LA SÉANCE

3

▸ Fonctionnement et commandes de bases sous Linux

▸ Rappels sur la programmation en langage C

▸ Présentation des outils de développement : Makefile et CMake

▸ Premier programme

▸ Programmation avancée

▸ Utilisation de Xenomai

▸ Programmation d’une tâche périodique temps-réel

PRISE EN MAIN DU SYSTÈME D’EXPLOITATION LINUXINFORMATIQUE INDUSTRIELLE

4

MATÉRIEL


SYSTÈME D’EXPLOITATION LINUX

5

NOYAU LINUX

INTERFACE APPELS SYSTEME

BIBLIOTHÈQUE GNU C (GLIBC)

APPLICATIONS UTILISATEURS

CODE NOYAU DÉPENDANT DU MATÉRIEL

GNU/Linux

Espace utilisateur

Espace noyau (administrateur)

UNE DISTRIBUTION LINUX =

NOYAU LINUX + OUTILS D'INSTALLATION+OUTILS D’ADMINISTRATION +

UN ENSEMBLE DE LOGICIELS D’APPLICATION

EXEMPLES DE DISTRIBUTIONS : - SLACKWARE - UBUNTU - RED HAT - ETC.


SYSTÈME D’ARBORESCENCE SOUS LINUX

6

‣ /bin/ : Contient toutes les commandes de base nécessaires au démarrage et à l’utilisation d’un système minimaliste (par exemple : cat, ls, cp, sh). ‣ /sbin/ : Contient les commandes systèmes réservées aux administrateurs. ‣ /boot/ : Contient les fichiers nécessaires au démarrage du système d’exploitation. ‣ /dev/ : Contient des fichiers correspondants à un périphériques (disques , disquettes …). ‣ /etc/ : Contient la plupart des fichiers de configuration du système. ‣ /home/ : Utilisé pour stocker les répertoires utilisateurs (exemple : /home/user1). ‣ /opt/ : Utilisé comme emplacement d’installation d’un logiciel utilisé. ‣ /tmp/ : Utilisé pour stocker les fichiers temporaires tout comme /var/tmp et /run/tmp et généralement vidé à chaque démarrage.


COMMANDES LINUX

7

▸ Les commandes linux sont appelées depuis un terminal

▸ La syntaxe d’une commande linux est la suivante :

commande options arguments

‣ La commande étant la commande elle-même, suivie d’une ou plusieurs options facultatives qui servent à modifier le comportement de la commande tandis que les arguments ,facultatifs aussi, représentent les objets sur lesquels la commande agit.


COMMANDES FONDAMENTALES LINUX

8

▸ commande pwd permet d’afficher l’emplacement où on se situe actuellement dans l’arborescence

▸ La navigation d’un répertoire à un autre se faire à l’aide de la commande cd avec le nom du répertoire. Par exemple : cd / Permet de se retrouver à la racine du disque, cd .. remonte dans le répertoire parent à partir de là où vous êtes, cd /var/www/ aller dans le répertoire /var/www.

▸ La commande ls permet d’afficher le contenu d’un répertoire. Par exemple : ls -l affiche les informations de manière détaillée; ls -a affiche les fichiers cachés, etc.

▸ La commande cp permet de créer une copie d’un fichier. Par exemple : cp foo/bar.txt baz/ Copier le fichier bar.txt dans le répertoire baz, cp -r foo/ baz/ Copier des répertoires entiers (note : si baz existe, la cible sera baz/foo/)

▸ La commande mv permet de déplacer un fichier ou de le renommer. Par exemple : mv foo/bar.txt baz/ Déplacer le fichier bar.txt dans le répertoire baz, mv foo_bar.txt foo_baz.txt Renommer le fichier foo_bar.txt en foo_baz.txt.

▸ La commande rm permet d’effacer un fichier ou un répertoire. Par exemple : rm *.txt Supprimer tous les fichiers ayant pour extension txt, rm foo.txt bar.txt Supprimer les fichiers foo.txt et bar.txt, rm -rf baz/ Supprimer le répertoire baz et tout son contenu.

▸ La commande mkdir permet de créer un répertoire à l’emplacement précisé en argument. Par exemple : mkdir -v Retourner des informations lors de la création d'un répertoire, mkdir foo Créer le répertoire foo, mkdir -p foo/bar/baz Créer l’arborescence foo/bar/baz.


COMMANDES FONDAMENTALES LINUX

9

▸ commande grep permet de chercher une chaîne de caractère ou un motif dans un fichier. Par exemple : grep 'text' foo.txt Recherche l'occurence 'text' dans le fichier foo.txt, grep -nri 'foobar' /project Recherche toutes les occurrences de 'foobar' dans le repertoire /project.

▸ La commande find permet de chercher des fichiers et éventuellement d’exécuter des commandes dessus. Par exemple : find myfile* -print Rechercher un fichier commençant par « myfile », find -name *myfile*.txt -print Rechercher un fichier contenant "myfile" et ayant pour extension ".txt"

▸ La commande tar permet de compresser et décompresser des fichiers ou des dossiers. Par exemple : tar -cvf archive.tar fichier1 Création d’une archive nommée archive.tar contenant le fichier fichier1, tar -xzvf archive.tar.gz Extraction de l’archive tar.gz.

▸ Gestion des processus :

‣ top Classement en live des processus en cours triés par utilisation Proc, Mem ou Temps CPU. ‣ free Afficher la mémoire libre. ‣ ps aux Afficher tous les processus exécutés. ‣ ps faux Afficher tous les processus exécutés affiché sous forme. ‣ kill pid Arrêter un processus. ‣ kill 9 pid Tuer violemment le processus (déconseillé).

▸ La commande cat permet d’afficher le contenu d’un fichier

▸ La commande man permet d’afficher le manuel d’aide de n’importe quelle autre commande disponible.

▸ La commande more permet de visualiser le contenu d’un fichier page à page.

LANGAGE DE PROGRAMMATION CINFORMATIQUE INDUSTRIELLE

10


INTRODUCTION AU LANGAGE C

11

▸ Le langage C fait partie de la famille des langages de programmation fonctionnels de haut niveau (au même titre que le Fortran, Pascal, Ada, etc.). Il a été développé en 1972 par Kernighan et Richie au laboratoire Bell d’AT&T. Initialement développé pour réécrire entièrement le système UNIX avec un langage évolué de manière le rendre le plus portable possible. La première version a été mise à disposition en 1978, la référence syntaxique étant alors l’ouvrage informel publié par Kernighan et Richie, The C Programming language.

▸ Depuis 1980, la syntaxe a beaucoup évolué et a donné de nombreuses variantes. En 1983, l’ANSI (American National Standards Institute) propose de normaliser le langage C, ce qui aboutira en 1989 à la définition de la norme ANSI C, reprise en 1990 par l’ISO (International Standards Organization).

▸ Le succès du langage C tient essentiellement dans le fait qu’il s’agit d’un langage de haut niveau (modularité, portabilité, etc.) mais qui reste proche du langage machine.


LES BASES DE LA PROGRAMMATION EN C

12

▸ Compilation : Le langage C est un langage compilé, ce qui signifie que le programme C est décrit par un fichier texte, appelé fichier source. Le fichier source n’est pas directement exécutable par le microprocesseur, il faut le traduire en langage machine. Cette opération est effectué par un programme, appelé compilateur. La compilation se décompose en 4 phases :

1. Le traitement par le préprocesseur permet d’analyser le fichier source qui effectue des transformations purement textuelles (remplacement de chaînes de caractères, inclusion d’autres fichiers sources, etc.).

2. La compilation traduit le fichier généré par le préprocesseur en code assembleur, c’est à dire en une suite d’instructions du microprocesseur qui utilisent des mnémoniques rendant la lecture possible.

3. L’assemblage est une étape qui consiste à transformer le code assembleur en un fichier binaire, c’est-à-dire en instructions directement compréhensibles par le processeur. Généralement les étapes de compilation et d’assemblage se font conjointement, il est cependant possible de les séparer. Le fichier alors généré est appelé : fichier objet.

4. L’édition de lien permet de produire le fichier exécutable. Un programme est souvent séparé en plusieurs fichiers source, pour des raisons de clarté mais aussi parce qu’il fait appel à des librairies de fonctions standard déjà écrites. Une fois chaque code source assemblé, il faut donc lier entre eux les différents fichiers objets.



13

▸ Les différents type de fichiers utilisés lors de la compilation sont distingués par leur suffixe. Les fichiers sources sont suffixés par .c, les fichiers pré-traités par le préprocesseur par .i, les fichiers assembleur par .s, et les fichiers objets par .o. Les fichiers objets correspondant aux librairies pré-compilés ont pour suffixe .a.

▸ Le compilateur a privilégier sous GNU/linux est gcc. Ce programme active par défaut toutes les étapes de la compilation, il s’exécute de la manière suivante :

gcc [options] fichier.c [-llibrairies]➡Par défaut, le fichier exécutable s’appelle a.out. Le nom de l’exécutable peut

être changé en utilisant l’option -o

➡Pour le librairies, le système recherche, par défaut, le fichier liblibrairies.a dans le répertoire /usr/lib/



14

▸ Les composants élémentaires du C

๏ les identificateurs permettent de donner un nom à une entité du programme (nom d’une variable, fonction, type défini, étiquette, etc.). Il s’agit d’une suite de caractère (Attention majuscules et minuscules sont différenciées et à la longueur)

๏ les mots-clefs : l’ANSI C compte 32 mots-clefs (ne pas prendre ces mots comme identificateur)

auto const double float int short struct unsignedbreak continue else for long signed switch void

case default enum goto register sizeof typedef volatilechar do extern if return static union while

๏ les constantes

๏ les chaîne de caractères

๏ les opérateurs : addition, soustraction, multiplication, division, modulo, affectation, et les opérateurs d’accumulation, opérateurs binaires, opérateurs de comparaison, opérateurs booléens.

๏ les signes de ponctuation et les commentaires : Un commentaire début par /* et se termine par */

‣ Une expression est une suite d’instruction/composants élémentaires syntaxiquement correcte.

‣ Une instruction est une expression suivie d’un point virgule. Plusieurs instructions peuvent être rassemblées par des accolades { et } pour former une instruction composée ou bloc qui syntaxiquement équivalent à une instruction .

‣ Une instruction composée d’un spécificateur de type et d’une liste d’identificateurs séparés par une virgule est une déclaration.



15

▸ Un programme en C se présente généralement de la façon suivante :

‣ Les fonctions secondaires peuvent être placées indifféremment avant ou après la fonction principale. Une fonction secondaire peut se décrire de la façon suivante :

[ directives au préprocesseur][ déclarations de variables externes][ fonctions secondaires]main(){ déclarations de variables internes instructions}

type ma_fonction ( arguments ){ déclarations de variables internes instructions}

FONCTION PRINCIPALE


PRÉPARATION DE L’ENVIRONNEMENT DE TRAVAIL

16

1. Démarrer le Raspberry Pi sous Linux

2. Ouvrir un terminal de contrôle pour utiliser les commandes Linux ;

3. Vérifier que le répertoire workspace existe ;

‣ Si ce n’est pas le cas : créer le répertoire workspace

4. Aller dans le répertoire workspace

5. Créer un répertoire avec le nom de votre groupe et aller dans ce répertoire

‣ Par la suite pour chaque nouveau projet, vous devrez créer un répertoire type TP1, TP2, etc.

6. Créer le répertoire TP1 et aller dans ce répertoire

7. Créer deux répertoires src et build qui vous serviront par la suite pour mettre le code source de votre programme ainsi que les fichiers de compilation (vous répéterez cette opération pour chaque projet)


PRÉPARATION DE L’ENVIRONNEMENT DE TRAVAIL

17

‣ Pour écrire un programme en C il existe plusieurs méthodes :

‣ Utilisation d’un IDE (Integrated Development Environment) qui intégrera un éditeur de texte, des outils de compilation, des outils pour débogguer, parfois des outils de création d’interface graphique, etc.. Parmi les IDE les plus connu QtCreator, Eclipse, Visual Studio, etc.

‣ Utilisation d’un éditeur de texte (Emacs, Gedit, Vi, Kate, Kwrite, etc.) et les outils de compilation proposés avec la distribution Linux (gcc, Makefile, CMake, etc.)


PREMIER PROGRAMME EN C

18

▸ Exercice : Faire un programme qui permet d’afficher dans une console « Hello World ! »

▸ Exercice : Faire un programme qui permet de calculer la puissance d’un nombre réel, en utilisant une fonction

- Soit un réel non nul et un entier relatif positif ou nul. La puissance d’exposant de , se définit par :

๏ si alors

๏ si alors

a n n a

n > 0 an = ∏nk=0 a

n = 0 an = 1



19#include <stdio.h> #include <stdlib.h>

double puissance (double x, int n) { if ( n==0) { return 1; } else { if( n < 0) { return -1; } else { return x*puissance(x, n-1); } } }

int main(int argc, char *argv[]) { double x; int n; printf("Saisir un nombre réel : "); scanf("%lf", &x); printf("Saisir un nombre entier pour la puissance : "); scanf("%d", &n); printf("\n\n Résultat puissance : %0.3f\n", puissance(x, n));

return 0; }

{{

Fonction secondaire

Fonction principale

▸ Ouvrir un éditeur de texte (gedit ou emacs)

▸ Ecrire le programme et enregistrer main.c dans le répertoire src



20

▸ Compilation du programme :

1. Ouvrir un terminal de commande

2. Aller dans le répertoire workspace/[nom_binome]/TP1/build

3. Utiliser la commande gcc pour compiler votre programme

1. Création du fichier objet gcc -c ../src/main.c

2. Edition de lien gcc -o my_exe main.o

4. Exécuter le programme avec la commande : ./my_exe

Attention pour un programme contenant un code source réparti sur plusieurs fichiers, qui doit être liée à d’autres librairies, la compilation manuelle devient pénible et quasi impossible.

OUTILS DE COMPILATIONINFORMATIQUE INDUSTRIELLE

21


OUTILS DE COMPILATION : MAKE

22

‣ make est un logiciel qui construit automatiquement des fichiers exécutables ou des bibliothèques à partir de code source. Il utilise des fichiers appelés Makefile qui donnent toutes les instructions permettant de construire les fichiers cibles.

‣ Attention Makefile n’est pas encore normalisé, il existe plusieurs utilitaires Makefile (make, gmake, qmake, etc. ). Il est nécessaire de vérifier la syntaxe pour le portage d’un utilitaire à l’autre.


OUTILS DE COMPILATION : MAKE ET CMAKE

▸ make est basé sur des règles. Chaque règle représente des opérations à exécuter lorsqu’un ensemble de fichier (les pré-requis de la règle) ont été mis à jour depuis le dernier make. Une règle décrit par exemple comment compiler un fichier ou supprimer les fichiers temporaires. La syntaxe d'une règle est la suivante :

cible : pre-requis instructions

⏟tabulation

23


EXEMPLE DE MAKEFILECC=gcc -Wall -O2SRC=main.c module1.c module2.cOBJ=main.o module1.o module2.oEXE=my_exe

all: $(OBJ) $(CC) $(OBJ) -o $(EXE)

main.o: main.c $(CC) main.c \ -o main.omodule1.o: module1.c $(CC) module1.c \ -o module1.omodule2.o: module2.c $(CC) module2.c \ -o module2.o

clean: rm -f *~

distclean: clean rm -f *.o $(EXE)

gcc module1.c -c -o module1.o -Wall -O2 -Wpedanticgcc module2.c -c -o module2.o -Wall -O2 -Wpedanticgcc main.c -c -o main.o -Wall -O2 -Wpedanticgcc module1.o module2.o main.o -o my_exe

COMPILATION MANUELLECOMPILATION AUTOMATIQUE

Création du fichier Makefile pour automatiser la compilation

CC=gcc -Wall -O2SRC=$(wildcard *.c)OBJ=$(SRC:.c=.o)EXE=my_exeall: $(OBJ) $(CC) $(OBJ) -o $(EXE) @echo "Fini."

%.o: %.c @echo "Compiling $@..." $(CC) $(CFLAGS) $(LIBS) $^ -o $@

clean: rm -f *~

distclean: clean rm -f *.o $(EXE)

SIMPLIFICATION DU MAKEFILE

24


UTILISATION D’UN MAKEFILE

▸ A partir du projet précédent, créer un fichier Makefile qui permettra de faire la compilation automatique de votre projet

▸ Compiler votre code …

25


OUTILS DE COMPILATION : CMAKE

▸ Développé pour les besoins de compilation multiplate-forme de la bibliothèque Insight Toolkit (ITK). Une première version a vu le jour en 2000. Aujourd’hui, le logiciel est maintenu par Kitware. C’est un outil gratuit et open-source permettant de gérer la compilation d’un projet multiplateformes.

▸ CMake produit, grâce au fichier CMakeLists.txt, un script de compilation permettant de créer un exécutable. CMakeLists.txt est un fichier contenant les instructions de compilation et est indépendant de la plate-forme, il va uniquement décrire comment le projet doit être compilé (langage, fichiers sources, dépendances, …)

CMakelists.txt CMake

Fichiers sources

Script de compilation Exécutable

26


OUTILS DE COMPILATION : CMAKE▸ Exemple simple de compilation d’un projet :

▸ Compilation : Depuis le répertoire build, appeler cmake

cmake ..‣ Après une succession d’appels et de commande, plusieurs fichiers et

répertoires ont été crée dans le répertoire build :

‣ CMakeCache.txt, CMakeFiles, Makefile, cmake_install.cmake

‣ On constate qu’il y a le fichier Makefile qui va nous permettre de compiler le code source …

make‣ Il y a l’exécutable qui apparaît !

Workspace/ TP1/ src/

build/

CMakeList.txt

main.c

# version récente de cmake cmake_minimum_required(VERSION 3.0)

# on appelle notre projet TP1project(TP1)

# Créer des variables avec les fichiers à compilerset(SRCS main.c ) set(HEADERS )

# On indique que l'on veut un exécutable « my_exe" compilé à partir des fichiers décrits par les variables SRCS et HEADERSadd_executable(hello ${SRCS} ${HEADERS})

CMAKELISTS.TXT

27


OUTILS DE COMPILATION : CMAKE▸ Exemple de compilation d’un projet avec une bibliothèque :

▸ Compilation : Depuis le répertoire BUILD, appeler CMAKE de la manière suivante

cmake ..‣ Après une succession d’appels et de commande, plusieurs fichiers et

répertoires dans le répertoire build ont été créé :

‣ CMakeCache.txt, CMakeFiles, Makefile, cmake_install.cmake

‣ On constate qu’il y a le fichier Makefile qui va nous permettre de compiler le code source …

make‣ L’exécutable qui apparaît !


build/

CMakeList.txt

main.c# version récente de cmake cmake_minimum_required(VERSION 3.0)

# on appelle notre projet TP1project(TP1)

# Créer des variables avec les fichiers à compilerset(SRCS main.c ) set(HEADERS )

# On indique que l'on veut un exécutable « my_exe" compilé à partir des fichiers décrits par les variables SRCS et HEADERSadd_executable(hello ${SRCS} ${HEADERS})target_link_libraries(hello [librairy])

CMAKELISTS.TXT

28

PROGRAMMATION DE THREAD SOUS LINUXINFORMATIQUE INDUSTRIELLE

29


PROGRAMMATION DE THREAD SOUS LINUX

▸ Utilisation de la bibliothèque pthread (libpthread.a) avec le fichier d’entête <pthread.h>

▸ Compilation d’un programme nécessitant la bibliothèque pthread :

gcc -lpthread main.c -o my_exe‣ Attention en pas oublier le fichier d’entête dans le code source #include <pthread.h>

30



▸ création d’un thread

int pthread_create( pthread_t * thread, pthread_attr_t * attr,

void *(*start_routine) (void *), void *arg);

▸ Retourne une valeur de type int. Si cette valeur vaut 0 alors la création a réussi sinon il faut gérer l’erreur

▸ 1er argument est un pointeur sur l’identifiant du thread

▸ 2ème argument désigne les attributs du thread. Vous pouvez choisir l’état du thread (joignable ou détaché), sa politique d’ordonnancement (usuelle, temps-réel,…).

▸ 3ème argument est un pointeur vers une fonction à exécuter par le thread. Cette dernière devra être de la forme void *fonction(void* arg) et contiendra le code à exécuter par le thread.

▸ 4ème argument est l’argument qui peut être passé au thread.

31



▸ suppression d’un thread

void pthread_exit(void *ret);

▸ prend en argument la valeur qui doit être retournée par le thread, et doit être placée en dernière position dans la fonction concernée.

32


PROGRAMMATION DE THREAD SOUS LINUX#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <pthread.h>

void *thread_1(void *arg){ printf("Nous sommes dans le thread.\n");

/* Pour enlever le warning */ (void) arg; pthread_exit(NULL);}

int main(void){ pthread_t thread1;

printf("Avant la création du thread.\n");

if(pthread_create(&thread1, NULL, thread_1, NULL) == -1) {perror("pthread_create");return EXIT_FAILURE;

}

printf("Après la création du thread.\n");

return EXIT_SUCCESS;}

CMAKELISTS.TXT Compilation Exécution

33


PROGRAMMATION DE THREAD SOUS LINUXcmake_minimum_required(VERSION 3.0)

#Déclaration du projet

project(MyProject)

#Génération de la liste des fichiers sourcesfile( GLOB_RECURSE source_files src/*)

#Déclaration de l'exécutableadd_executable( my_exe ${source_files})


build/

CMakeLists.txt

main.cAvant la création du thread.Après la création du thread.Nous sommes dans le thread.

RÉSULTAT EXÉCUTION

34



▸ Attendre la fin d’un thread

int pthread_join(pthread_t th, void **thread_return);

▸ 1er argument l’identifiant du thread.

▸ 2ème argument est un pointeur qui permet de récupérer la valeur retournée par la fonction dans laquelle s’exécute le thread (c’est à dire l’argument de pthread_exit)

35


PROGRAMMATION DE THREAD SOUS LINUX#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <pthread.h>

void *thread_1(void *arg){ printf("Nous sommes dans le thread.\n");

/* Pour enlever le warning */ (void) arg; pthread_exit(NULL);}

int main(void){ pthread_t thread1;

printf("Avant la création du thread.\n");

if (pthread_create(&thread1, NULL, thread_1, NULL)) {perror("pthread_create");return EXIT_FAILURE;

}

if (pthread_join(thread1, NULL)) {perror("pthread_join");return EXIT_FAILURE;

}

printf("Après la création du thread.\n");

return EXIT_SUCCESS;}

CMAKELISTS.TXT Compilation Exécution

36


PROGRAMMATION DE THREAD SOUS LINUXcmake_minimum_required(VERSION 3.0)

#Déclaration du projet

project(MyProject)

#Génération de la liste des fichiers sourcesfile( GLOB_RECURSE source_files src/*)

#Déclaration de l'exécutableadd_executable( my_exe ${source_files})


build/

CMakeLists.txt

main.cAvant la création du thread.Nous sommes dans le thread.Après la création du thread.

RÉSULTAT EXÉCUTION

37


PROGRAMMATION DE THREAD SOUS LINUX (SYNCHRONISATION)

▸ Problématique : Au sein d’un processus, tout les thread partagent les variables, c’est la mémoire partagée. Que se passe t’il si deux thread souhaitent modifier une variable en même temps ? si un des deux thread lit la variable pendant que l’autre est entrain de la modifier ?

▸ Utilisation d’un mécanisme de synchronisation : mutex ou exclusion mutuelle

▸ En C un mutex est de type pthread_mutex_t. Ce mécanisme va nous servir de verrou pour protéger des données. Il peut prendre deux état : disponible ou verrouillé. Attention ces variables sont généralement déclarées en variables globales (donc à utiliser avec précaution).

▸ Verrouiller un mutex :int pthread_mutex_lock(pthread_mutex_t *mut);

▸ Déverrouiller un mutex :int pthread_mutex_unlock(pthread_mutex_t *mut);

▸ Détruire un mutex :int pthread_mutex_destroy(pthread_mutex_t *mut);

38



▸ Pour la synchronisation il existe également un mécanisme de condition

▸ Lorsqu’un thread reste bloqué jusqu’à ce que survienne un évènement dans un autre thread alors on peut utiliser les conditions. Quand un thread est en attente d’une condition, il reste bloqué tant que cette condition n’est pas remplie par un autre thread (attention à l’utilisation dans des zones critiques)

▸ La déclaration d’une variable de type pthread_cond_t

▸ Attente d’une condition (utilise un mutex) : int pthread_cond_wait(pthread_cond_t *nomCondition, pthread_mutex_t *nomMutex);

▸ Réveiller un thread en attente d’une condition: int pthread_cond_signal(pthread_cond_t *nomCondition);

39



▸ Exercice : Créez un programme qui utilise deux thread : un thread qui incréments une variable compteur par un nombre tiré au hasard entre 0 et 10, et l’autre qui affiche un message lorsque la variable compteur dépasse 20 et la remet à zéro. Ecrire le code source, écrire de CMakeLists.txt, compiler et exécuter le code.

40


PROGRAMMATION DE THREAD SOUS LINUX (SYNCHRONISATION)#include <stdio.h> #include <stdlib.h> #include <pthread.h>

pthread_cond_t condition = PTHREAD_COND_INITIALIZER; /* Création de la condition */ pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; /* Création du mutex */

void* threadAlarme (void* arg); void* threadCompteur (void* arg);

int main (void) { pthread_t monThreadCompteur; pthread_t monThreadAlarme;

pthread_create (&monThreadCompteur, NULL, threadCompteur, (void*)NULL); pthread_create (&monThreadAlarme, NULL, threadAlarme, (void*)NULL); /* Création des threads */

pthread_join (monThreadCompteur, NULL); pthread_join (monThreadAlarme, NULL); /* Attente de la fin des threads */

return 0; }

void* threadCompteur (void* arg) { int compteur = 0, nombre = 0; srand(time(NULL));

while(1) /* Boucle infinie */ { nombre = rand()%10; /* On tire un nombre entre 0 et 10 */ compteur += nombre; /* On ajoute ce nombre à la variable compteur */

printf("\n%d", compteur); if(compteur >= 20) /* Si compteur est plus grand ou égal à 20 */ { pthread_mutex_lock (&mutex); /* On verrouille le mutex */ pthread_cond_signal (&condition); /* On délivre le signal : condition remplie */ pthread_mutex_unlock (&mutex); /* On déverrouille le mutex */

compteur = 0; /* On remet la variable compteur à 0 */ }

sleep (1); /* On laisse 1 seconde de repos */ } pthread_exit(NULL); /* Fin du thread */ }

void* threadAlarme (void* arg) { while(1) /* Boucle infinie */ { pthread_mutex_lock(&mutex); /* On verrouille le mutex */ pthread_cond_wait (&condition, &mutex); /* On attend que la condition soit remplie */ printf("\nLE COMPTEUR A DÉPASSÉ 20."); pthread_mutex_unlock(&mutex); /* On déverrouille le mutex */ } pthread_exit(NULL); /* Fin du thread */ }

41


PROGRAMMATION DE THREAD SOUS LINUX (SYNCHRONISATION)void* threadCompteur (void* arg) { int compteur = 0, nombre = 0; srand(time(NULL));

while(1) /* Boucle infinie */ { nombre = rand()%10; /* On tire un nombre entre 0 et 10 */ compteur += nombre; /* On ajoute ce nombre à la variable compteur */

printf("\n%d", compteur); if(compteur >= 20) /* Si compteur est plus grand ou égal à 20 */ { pthread_mutex_lock (&mutex); /* On verrouille le mutex */ pthread_cond_signal (&condition); /* On délivre le signal : condition remplie */ pthread_mutex_unlock (&mutex); /* On déverrouille le mutex */

compteur = 0; /* On remet la variable compteur à 0 */ }

sleep (1); /* On laisse 1 seconde de repos */ } pthread_exit(NULL); /* Fin du thread */ }

void* threadAlarme (void* arg) { while(1) /* Boucle infinie */ { pthread_mutex_lock(&mutex); /* On verrouille le mutex */ pthread_cond_wait (&condition, &mutex); /* On attend que la condition soit remplie */ printf("\nLE COMPTEUR A DÉPASSÉ 20."); pthread_mutex_unlock(&mutex); /* On déverrouille le mutex */ } pthread_exit(NULL); /* Fin du thread */ }

42

DÉCOUVERTE DE XENOMAIINFORMATIQUE INDUSTRIELLE

43


XENOMAI

▸ Noyau temps-réel dur qui cohabite ou collabore avec le noyau Linux. Linux devient alors une « tâche » de faible priorité par rapport à Xenomai

▸ Transparent grâce aux Skins de programmation

▸ Open-source et gratuit

▸ Permet de travailler dans l’espace utilisateur (temps réel mou) et dans l’espace kernel

LINUX

XENOMAI

ADEOS

MATÉRIEL

Evènements

44


XENOMAI -GRANDES ÉTAPES DE L’INSTALLATION▸ Installation de Xenomai sur RPi (voir le site de Christophe Blaess https://www.blaess.fr/christophe/2017/03/20/xenomai-sur-raspberry-pi-3-bilan-mitige/)

▸ Récupérer le code source d'un noyau linux « originel » http://www.kernel.org. (noyau Linux version 4.1.21)

▸ Récupérer le code source de Xenomai http://download.gna.org/xenomai/stable. (version Xenomai 3.0.3)

▸ Attention :

▸ tout les noyaux ne sont pas compatibles avec les patches xenomai disponibles.

▸ s’assurer que l’on maîtrise l'installation de Linux en compilant et installant le nouveau noyau linux.

▸ Copier les archives dans /usr/src et décompresser les archives du noyau Linux et Xenomai

▸ Créer une nouveau répertoire Linux-xenomai, copier le code source du noyau Linux, patcher le code source du noyau linux avec le patch xenomai adéquate

▸ Configurer le noyau Linux en respectant les contraintes liées à Xenomai

▸ Compiler le noyau Linux, les modules et installer le nouveau noyau compiler (bien prendre soin de configurer l’amorçage du système d'exploitation selon votre distribution il faut configurer Grub ou lilo)

▸ Rebooter la machine sur le nouveau noyau

▸ Compiler les sources de xenomai et installer les bibliothèques Xenomai (et les exécutables disponibles).

45

https://www.blaess.fr/christophe/2017/03/20/xenomai-sur-raspberry-pi-3-bilan-mitige/

http://www.kernel.org

http://download.gna.org/xenomai/stable


XENOMAI - VÉRIFICATION DE FONCTIONNEMENT

‣ Test de latence sudo /usr/xenomai/bin/latency -T 60

== Sampling period: 1000 us== Test mode: periodic user-mode task== All results in microsecondswarming up...RTT| 00:00:01 (periodic user-mode task, 1000 us period, priority 99)RTH|----lat min|----lat avg|----lat max|-overrun|---msw|---lat best|--lat worstRTD| -3.594| -2.786| 1.822| 0| 0| -3.594| 1.822RTD| -3.647| -2.923| 0.051| 0| 0| -3.647| 1.822RTD| -3.595| -2.920| 1.613| 0| 0| -3.647| 1.822RTD| -3.648| -2.946| -0.106| 0| 0| -3.648| 1.822[...]RTD| -3.616| -2.936| -0.230| 0| 0| -5.017| 1.863RTD| -3.616| -2.871| 1.488| 0| 0| -5.017| 1.863RTD| -3.669| -2.848| 0.186| 0| 0| -5.017| 1.863---|-----------|-----------|-----------|--------|------|-------------------------RTS| -5.017| -2.893| 1.863| 0| 0| 00:01:00/00:01:00

cat /proc/xenomai/latency

sudo -iecho 0 > /proc/xenomai/latency cat /proc/xenomai/latency 0exit

Relancer le test

46


XENOMAI - VÉRIFICATION DES DÉPENDANCES

47

‣ Vérifier que le chemin /usr/xenomai/lib est bien dans la variable d’environnement LD_LIBRARY_PATH. Pour cela fait :

echo $LD_LIBRARY_PATH

‣ Si ce n’est pas le cas utiliser la commande suivante :

export $LD_LIBRARY_PATH=/usr/xenomai/lib:$LD_LIBRARY_PATH

‣ Vérifier également que le chemin /usr/xenomai est dans la variable d’environnement PATH. Sinon il faut l’exporter de la même manière que précédemment. (Attention au chemin)

‣ Ajouter également la ligne /usr/xenomai/lib dans le fichier /etc/ld.so.conf

‣ Pour que ces variables d’environnement soient prises en compte lors de la compilation utiliser la commande suivante :

ldconfig


XENOMAI - PREMIER PROGRAMME TEMPS-RÉEL#include <stdio.h>#include <signal.h>#include <unistd.h>#include <sys/mman.h>#include <alchemy/task.h>

RT_TASK main_task;

void main_task_proc(void *arg){ RT_TASK *curtask; RT_TASK_INFO curtaskinfo;

curtask = rt_task_self(); rt_task_inquire(curtask, &curtaskinfo);

//Affichage des informations sur la tâche courante printf("Démarrage de la tâche %s\n", curtaskinfo.name);}

int main(int argc, char **argv){ char str[20];

//Verrouillage de la mémoire pour éviter le swapping mlockall(MCL_CURRENT | MCL_FUTURE); //Création de la tâche temps-réel sprintf(str, "main_task"); rt_task_create(&main_task, str, 0, 50, 0);

rt_task_start(&main_task, &main_task_proc, 0);

//Attente Ctrl-C pause();

return 0;}

CMAKELISTS.TXTcmake_minimum_required(VERSION 3.0 FATAL_ERROR)project(MyProject)set(XENO_DIR /usr/xenomai)set(XENO_INCLUDE_DIR ${XENO_DIR}/include)set(XENO_BIN_DIR ${XENO_DIR}/bin)set(SKIN native)execute_process(COMMAND ${XENO_BIN_DIR}/xeno-config skin=${SKIN} cflags OUTPUT_VARIABLE XENO_CFLAGS OUTPUT_STRIP_TRAILING_WHITESPACE)execute_process(COMMAND ${XENO_BIN_DIR}/xeno-config skin=${SKIN} ldflags OUTPUT_VARIABLE XENO_LDFLAGS OUTPUT_STRIP_TRAILING_WHITESPACE)include_directories(${XENO_INCLUDE_DIR}file(GLOB_RECURSE source_files src/*)set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} ${XENO_CFLAGS} )add_executable(my_exe ${source_files})target_link_libraries(my_exe ${XENO_LDFLAGS})

−− −−

−− −−

′�′� ′�′�

48

Exécution à faire en administrateur


SKIN ALCHEMY (NATIVE) XENOMAI

49

Alarm servicesAlarme de type Watchdog à usage général. Buffer servicesMécanisme de communication inter-process (IPC) allégé. Condition variable servicesMécanisme de variables de condition de type POSIX. Event flag group services Mécanisme de notification inter-tâches basé sur des drapeaux numériques. Heap management servicesEspace mémoire dédié à l’allocation temps-réel.

Mutex servicesService d’exclusion mutuelle de type POSIX.

Message pipe servicesCanaux bi-directionnels de communication entre les domaines Xenomai et Linux.

Message queue servicesMécanisme d’IPC temps-réel four envoyer des messages de taille arbitraire. Semaphore servicesMécanisme de synchronisation IPC de type sémaphores. Task management servicesServices de gestion du multi-tâches préemptives. Timer management servicesServices permettant la gestion des timbres matériel.

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__alarm.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__buffer.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__cond.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__event.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__heap.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__mutex.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__pipe.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__queue.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__sem.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__timer.html

INFORMATIQUE INDUSTRIELLE 50

SKIN ALCHEMY (NATIVE) XENOMAIint rt_task_delete (RT_TASK *task) Détruire une tâche temps-réelint rt_task_start (RT_TASK *task, void(*entry)(void *arg), void *arg) Démarrer une tâche temps-réelint rt_task_join (RT_TASK *task) Attendre la fin d’une tâcheint rt_task_wait_period (unsigned long *overruns_r) Attendre la prochaine période. int rt_task_suspend (RT_TASK *task) Suspendre une tâche temps-réel. int rt_task_resume (RT_TASK *task) Relancer une tâche temps-réel. RT_TASK *rt_task_self (void) Récupérer le descripteur de la tâche. int rt_task_inquire (RT_TASK *task, RT_TASK_INFO *info) Récupérer les informations concernant une tâche spécifique. int rt_task_create (RT_TASK *task, const char *name, int stksize, int prio, int mode) Créer une tâche temps-réel. int rt_task_set_periodic (RT_TASK *task, RTIME idate, RTIME period) Rendre périodique une tâche temps-réel.

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#gab6e0d411830710e8cc82d77b9df19510

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#ga3ee3863a29497e2181d49d5b3ecfd855

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#ga8c77d57638578a126812e29429f61fe7

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#ga1645d3a072ef3cefeed3bcbb27dcf108

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#ga926a4b10e3631f76c5f38910e6eea24c

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#ga1fab1aa24ef6f199546fd9669ae711be

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#ga8a17935f049171be2ac8945abc68da6a

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#ga53bad6acf5496f8008e594954507dce8

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/structRT__TASK__INFO.html

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#ga03387550693c21d0223f739570ccd992

https://xenomai.org/documentation/xenomai-3/html/xeno3prm/group__alchemy__task.html#gababee94264156693cd4f5b9b70d3c5a1


PROGRAMMATION D’UNE TÂCHE PÉRIODIQUE TEMPS-RÉEL

51

▸ Exercice : Créer un programme avec une tâche temps-réel périodique (de période 10 ms), évaluer le jitter de cette boucle. Mettre également le système en surcharge CPU en ouvrant différents logiciels.


PROGRAMMATION D’UNE TÂCHE PÉRIODIQUE TEMPS-RÉEL#include <stdio.h>#include <signal.h>#include <unistd.h>#include <sys/mman.h>#include <alchemy/task.h>#include <alchemy/timer.h>

RT_TASK main_task;long long period_ns = 10*1000*1000LL; // 10 msint end = 0;

void main_task_proc(void *arg){ RTIME now, previous, start_ns; previous = rt_timer_read(); start_ns = rt_timer_read()+1000000; // démarrage après 1 ms rt_task_set_periodic(NULL, start_ns, period_ns); while(!end) { rt_task_wait_period(NULL); now = rt_timer_read(); printf("Time elpased : %ld.%04ld ms \n ", (long)(previous-now)/1000000, (long-previous)%1000000 ); previous = now; }}

int main(int argc, char **argv){ //Verrouillage de la mémoire pour éviter le swapping mlockall(MCL_CURRENT | MCL_FUTURE); //Création de la tâche temps-réel rt_task_create(&main_task, "main_task", 0, 99, 0); % 99 highest priority , 1 is lower priority

rt_task_start(&main_task, &main_task_proc, 0);

//Attente Ctrl-C pause(); end = 1; return 0;}

52

Proposition

COMMUNIQUER AVEC LE MATÉRIELINFORMATIQUE INDUSTRIELLE

53


BUS ETHERCAT ▸ EtherCAT (Ethernet for Control Automation Technology) est un bus de terrain

développé par Beckhoff Automation en 2003.

▸ Le protocole EtherCAT est :

▸ normalisé CEI 61158 et disponible publiquement

▸ type Maître/Esclave

▸ le contrôleur Ethernet peut être standard pour le maître mais propriétaire pour l’esclave

▸ maintenu par un consortium EtherCAT Technology Group depuis 2006

▸ compatible temps-réel dur et mou (respecte le déterminisme temporel et d’exécution) avec des temps de cycle court ( )

▸ EtherCAT réutilise les profils d’application CANopen et Sercos (Drives, E/S etc.)

< 100 μs

54


CARACTÉRISTIQUES▸ Les performances actuelles du bus EtherCAT : temps de cycle de avec un jitter

▸ Ethernet Industriel RT qui utilise les trames standard IEEE 802.3 (100 MBs, Full Duplex)

▸ Assure la synchronisation grâce au mécanisme « Distributed clock » DC

▸ Facile à mettre en oeuvre grâce à l’adresse automatique des noeuds

▸ Utilisation des câbles et connecteurs standard d’Ethernet - câble 100Base-TX

▸ Topologie linéaire qui ne nécessite pas de switch

▸ Topologie flexible grâce à deux ports EtherCAT sur chaque station et une transmission Full Duplex (structures linéaires en anneau fermé, structures en dérivations (Tree, Star))

100 μs < 1 μs

MAIS EtherCAT n’est pas une communication TCP/IP standard, la communication TCP/IP doit se faire via EoE (Ethernet over EtherCAT qui sont des modules additionnels)

55

▸ Echange de données à la volée (On-fly data exchange)

▸ Le maître envoie un télégramme qui traverse toutes les stations esclaves

▸ Chaque esclave prend « à la volée » les données Output Data et mets à sa place les données Input Data

▸ Ensuite le télégramme est envoyé à la station suivante

▸ La dernière station esclave dans l’anneau complète la trame et l’envoie vers le maître via toutes les stations

▸ L’échange des données OutputData et InputData est réalisé en quelques par un circuit spécialisé (ASIC EtherCAT)ns


ETHERCAT : FONCTIONNEMENT

ETHERCAT MASTER ETHERCAT SLAVE ETHERCAT SLAVE ETHERCAT SLAVESLAVE 1

CONTROLLER

TRAME ETHERNET SLAVE 3 DATA

FRAME

SLAVE 2 CONTROLLER

SLAVE 3 CONTROLLER

56


PILE ETHERCAT : IGH ETHERCAT MASTER

▸ Une pile de protocole est une mise en oeuvre particulière d’un ensemble de protocoles de communication réseau. L’intitulé « pile » implique que chaque couche de protocole s’appuie sur celles qui sont en dessous en y apportant des fonctions supplémentaires

▸ Pile EtherCAT développée par IgH EtherCAT Master :

▸ Pile utilisée dans EtherLab http://www.etherlab.org

▸ Temps-réel dur, programmation en C et open-source

▸ Possibilité de générer du code Simulink/RTW

▸ Compatible avec Linux - Xenomai et RT-Preempt

57

Modèle OSI (Open System Interconnection)

http://www.etherlab.org


PILE ETHERCAT : IGH ETHERCAT MASTER‣ Configuration du système pour utiliser EtherCAT sous Linux :

1. Installation du la version courante de EtherCAT

‣ Code source directement depuis le site http://www.etherlab.org/en/ethercat/

‣ Code source depuis la Forge « repository Mercurial » : hg clone http://hg.code.sf.net/p/etherlabmaster/code ethercat-hg

2. S’assurer de la compatibilité entre la version de la pile EtherCAT et du noyau linux utilisé

3. Configurer la carte ethernet qui servira au support physique (renseigner l’adresse MAC de la carte dans le fichier /etc/sysconfig/ethercat (Attention il peut y avoir plusieurs master !). Il faut également renseigner le module noyau utilisé par la carte Ethernet.

‣ Mise en service des fonctionnalités du Master EtherCAT au sein du noyau linux avec les outils de commandes en ligne :

‣ /etc/init.d/ethercat <fonction> avec <fonction> qui start, stop, restart, status

58

http://www.etherlab.org/en/ethercat/


IMPLÉMENTATION SIMPLIFIÉE DU MAÎTRE

59


IMPLÉMENTATION DANS UN ENVIRONNEMENT TEMPS-RÉEL

60

ETHERCAT MASTER

LINUX KERNELXENOMAI

ADEOS

MATÉRIEL

BUS ETHERCAT

TÂCHE NRT TÂCHE RT

API

RTDM

ETH0ETH1


COMMUNICATION ETHERCAT AVEC IGH ETHERCAT MASTER

61

1. Une fois que le module ethercatmaster est chargé dans le noyau

2. Récupérer la topologie du réseau et les informations sur les modules esclave :

/opt/ethercat/bin/ethercat <fonction> avec <fonction> qui slaves, cstruct, master, help, etc.

3. Dans l’application, il y aura deux phases :

1. phase de configuration du bus de communication (non temps-réel) : récupération de la structure de donnée du master, construire le domain pour la communication via la trame ethernet, configurer les modules esclaves qui sont sur le bus et activer le master pour ouvrir la communication on peut alors exécuter la tâche périodique temps réel de contrôle

2. phase de contrôle du système (temps-réel). Cette phase est réalisée dans la tâche périodique temps-réel. On réceptionne la trame EtherCAT (les informations sont stockées dans une structure de données), l’utilisateur récupère les informations, calcul la nouvelle commande à envoyer, on mets à disposition les nouvelles données et la trame EtherCAT est renvoyée sur le bus.

⇒

Documents

BASES DE PROGRAMMATION EN LANGAGE C SOUS LINUX