Les interruptions en systèmes temps réel

Bonjour à tous,
Je tiens à préciser que je suis debutant. Merci d'être patient avec moi. :aie:
Je cherche dans un projet lambda à effectuer des interruptions (matérielles et logicielles) avec priorités.
Ce n'est pas un projet scolaire ou professionnel, c'est à titre personnel, je m'intéresse au C appliqué aux systémes temps reel, afin de pouvoir plus tard bidouiller chez moi!
Je travaille sur Wind River Workbench (une licence qu'un pote m'a file).

Le scenario:
j'ai 2 signaux A1 et A2 (disons unsigned char)
J'ai un programme qui tourne,
-lorsque le signal A1 est à 1 on lance l'interruption1
-lorsque le signal A2 est à 1 on lance l'interruption2
-si les signaux A1 et A2 sont à 1 en meme temps alors l'interruption 2 se lancer d'abord car elle est plus prioritaire

J'ai effectué des recherches sur les interruptions mais malheureusement je n'ai eu que des explications sur ce qu'est une interruption sans jamais avoir la bibliothéque à appliqué ou bien la structuration de programme à adopter ou meme un exemple de code...

J'ai juste compris que

Code:

intLock();

autorisé les interruptions

Merci d'avance pour vos réponse et soyez indulgent :D

Bonjour,

Je ne suis pas certain de bien comprendre ce que tu cherches... mais voici un peu d'information :

Regarde du côté des fonctions signal(), c'est un bon début.

Ensuite, essaye de faire un programme simple, en environnement non temps-réel : un programme de type boucle infinie qui affiche le numéro du signal que l'utilisateur lui envoie. Ensuite, joue un peu avec ça, en lui envoyant différent signaux (si tu es en environnement *n*x, tu peux utiliser kill pour envoyer un signal à un processus). Tu peux chercher à comprendre pourquoi tu peux attraper certains signaux, mais pas d'autres.

Ensuite, tu pourras faire des accès concurrents, puis du temps-réel.

J'imagine que vous parlait ici d'interruption logiciel ?
Parce que on est bien d'accord qu'une interruption matériel est beaucoup moins permissive.
De plus les interruption IRQ dépendent de la machine cible , et ça peut etre n'importe quoi , et leur configuration (quand elle peuvent l’être) reste limité.

Bonsoir;
Effectivement, il est sujet IRQ plus précisément les IRQ matériel. Cependant, la fonction intLock(); en question est une sorte de fonction de verrous elle a donc un comportement similaire aux mutex.
intLock(); va fournir une clé de verrouillage qui dépend de l'architecture de la machine.(Exemple sur une architecture x86 ça va être par exemple un bit indicateur du registre EFLAGS, sur une architecture PowerPC ça sera une valeur du registre MSR, sur d’autres architectures ça pourrait être un masque par etc. À vérifier...) Généralement, elle permet de traité les sections critiques mais ne garantit pas qu’un verrouillage sur un IRQ en question puisse durée si une tâche prioritaire est sollicité avec une priorité haute car, il y a réenclenchement systématique de celui-ci (donc un déverrouillage du verrou acquis). En revanche, si elle est utilisée dans un contexte d’exécution, le verrouillage de l’IRQ fait partie du contexte d'exécution et dans ce cas précis on traite une section critique, mais là encore on n’est pas à l’abri d’un déverrouillage; car si certain IRQ sont verrouiller, le simple fait de faire appel a des fonctions système a pour effet un déverrouillage. Bref, lire la doc pour plus de précisions.

Citation:

Envoyé par neophyte_ingé

J'ai effectué des recherches sur les interruptions mais malheureusement je n'ai eu que des explications sur ce qu'est une interruption sans jamais avoir la bibliothéque à appliqué ou bien la structuration de programme à adopter ou meme un exemple de code...

J'ai juste compris que

Code:

intLock();

autorisé les interruptions

Merci d'avance pour vos réponse et soyez indulgent :D

Qu’est-ce qu'exactement une interruption, de façon simple je dis souvent aux débutant que c’est un moyen par lequel un matériel (périphérique) attire l’attention de son pilote( driver) pour lui signifie qu’il a besoin de quelque chose ou de faire quelque chose exemple, dire à un périphérique que des données sont prêtes pour une lecture ou un traitement quelconque ou signifier que le traitement précédent est fini et qu’il est en attente d’autres traitements.
Dans un système temps réel ce mécanisme devient un élément majeur, car il permet instantanément de traiter la requête qui est soumise en utilisant temporairement les ressources du processeur pour y répondre. Ainsi donc une interruption (IRQ) est un signal qui va demander à l'unité centrale (CPU) d'interrompre un cycle de calcul en cours pour pouvoir réagir à un certain événement survenu.
On parle de gestionnaire d’interruption parce que c'est lui qui prend en charge les interruptions du périphérique. Il doit accuser réception de l’interruption et servir le périphérique d’une manière ou autres.

Cependant, la difficulté réside dans la mise en place du gestionnaire d’interruption cela dépend de comment on gère la chose. Exemple: Pour le cas Linux, il est important qu’un gestionnaire d’interruption se termine aussi vite que possible puisqu’il susceptible à un moment donné de recevoir une autre interruption matérielle c’est également valable si cette interruption est partagée avec un autre matériel. En clair, il faut savoir géré la chose. (Sur VxWork une tâche prioritaire peut vite arriver et déclencher un déverrouillage et le traitement de la section critique est annulé ou devient problématique a vérifier)

C’est bien d’utiliser des signaux, je pense que le plus simple serait de mettre en place un gestionnaire d’interruption qui est attachée à un périphérique exemple: le clavier. Et enregistrée dans un buffer les interruptions acquises ou, pour allée un peu plus loin, l’interception d’un signal qui activerais le montage d'un point d’ancrage (hooks) sur un appel système visé pour enregistrer les frappes de clavier bref je m’arrête (car on sort du cadre légal en matière de règlements du forum, en continuant sur cet lancé je décris les principes d’un rootkit et je fait du hors-sujet si c'est pas déjà le cas )

Sur la basse de votre exemple, on peut très bien faire comme ceci ( attention c’est du pseudo-code de plus il est a vérifié).:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 void f_handler_a( void ){ f_acquire_irq_x(); f_traitement_irq_avec_prioriter(); } void f_handler_b( void ){ f_acquire_irq_y(); f_traitement_irq_avec_prioriter(); } void f_handler_ab( void ){ f_handler_b() // priorité modifier de irq_a exemple passe sur un CPU en préemptible f_handler_a() // normale } int main( void ){ f_setup_sigaction_handler( SIGNAL_A, f_handler_a() ); f_setup_sigaction_handler( SIGNAL_B, f_handler_b() ); f_setup_sigaction_handler( SIGNAL_AB, f_handler_ab() ); for(;;) sleep(1); }
Ou continuer sur la lancé des signaux avec les conseils de @gangsoleil cependant dans l’exemple qui suit j'essaye de saturé volontairement le CPU
Pour le teste faire attention au comportement du système ....
(Attention le code source en question peut comporté des erreurs , elle illustre l’utilisation des signaux pour envisager l’utilisation d’une routine énonce (speudcode) précédemment vu d'un autre côté le simple fait de proposé l'exemple qui suit peut paraître déjà Hors sujet, désolé si c'est le cas)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 /* ============================================================================ Name : Untitled 2.c Author : SAMBIA39 Version : 0.1 Copyright : Copyright (c) 09/11/2016 SAMBIA39 Description : Ansi-style ============================================================================ */ #define _GNU_SOURCE #include <sched.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int cmpt; void f_forkSaturation( int cpu ){ cpu_set_t cpu_set; struct sched_param p; //Choix d’exécution sur le processeur CPU_ZERO( &cpu_set ); CPU_SET( cpu, &cpu_set ); if( 0 != sched_setaffinity(0, sizeof(cpu_set), &cpu_set) ){ fprintf( stderr, "Erreur sched_setaffinity\n"); exit( EXIT_FAILURE ); } /* * passage en temps réel en clair ordonenceur temps réel FIFO * ce contexte d’exécution ne peut être préempter que par une * tâche supérieure FIFO */ p.sched_priority = 99; if( 0 != sched_setscheduler(0, SCHED_FIFO, &p) ){ fprintf( stderr, "Erreur sched_setscheduler\n" ); exit( EXIT_FAILURE ); } fprintf( stdout, "10 seconde attente avant start fork saturation\n" ); sleep(10); for(;;) fprintf( stdout, "!!!Fork Saturation CPU %d\n", cpu ); } void f_handler_A( int x ){ fprintf( stdout, "Signal A détecté\n"); } void f_handler_B( int x ){ fprintf( stdout, "Signal B détecté\n" ); cmpt = 0; } void f_handler_C( int x ){ int cpu = 0; int xcpu = 0; xcpu = sysconf( _SC_NPROCESSORS_ONLN ); for( cpu = 0; cpu < xcpu; cpu++ ){ if( 0 == fork() ) f_forkSaturation(cpu); } /* * Balayette zombie CPU fork */ for( cpu = 0; cpu < xcpu; cpu++ ) waitpid( -1, NULL, 0 ); } /* * Attention le programme peut avoir * un comportement indéterminé * Utiliser CTRL+\ à la place, * Attention cela génère un fichier core */ int main( void ){ char *p = NULL; unsigned int i = 0; sigset_t t_sigset[3]; struct sigaction t_sig_handler[3]; for( i = 0; i < 3; i++ ){ if( sigemptyset(&t_sigset[i]) ) exit( EXIT_FAILURE ); } for( i = 0; i < 3; i++ ) t_sig_handler[i].sa_flags = 0; t_sig_handler[0].sa_handler = f_handler_A; t_sig_handler[1].sa_handler = f_handler_B; t_sig_handler[2].sa_handler = f_handler_C; sigaction( SIGINT, &t_sig_handler[0], NULL ); // CTRL+C sigaction( SIGSEGV, &t_sig_handler[1], NULL ); // segfault sigaction( SIGALRM, &t_sig_handler[2], NULL ); // Alarme alarm( 20 ); // Fork saturation fprintf( stdout, "Attente de signal\n" ); for(;;){ if( 15 == ++cmpt ) p[0] = 'A'; //Erreur seg volentaire sleep(1); } exit( EXIT_SUCCESS ); }
à bientôt

Citation:

Envoyé par neophyte_ingé

Je cherche dans un projet lambda à effectuer des interruptions (matérielles et logicielles) avec priorités.

? Les interruptions matérielles et logicielles s'effectuent au niveau du CPU comme l'a expliqué mon prédecesseur
Avec Turbo C ça pouvait se faire avec une macro spéciale qui permettait de faire une sorte de pointeur long, de passer des paramètres pour un registre en particulier du CPU et d'appeler une interruption
Par exemple l'INT 10H c'est pour la vidéo avec dans AH le mode vidéo ( il faudrait vérifier ) donc au pif si on veut du 320x200 VGA on fait MOV AH,0 ; MOV AL,mode_video; INT 10
Pour ce qui est des interruptions logicielles sous Ms-Dos il fallait obligatoirement appeler l'INT 21H
Mais maintenant un OS comme Windows interdit l'appel des interruptions à moins de pouvoir le faire dans une boite d'émulation ms-dos

Citation:

Envoyé par neophyte_ingé

Ce n'est pas un projet scolaire ou professionnel, c'est à titre personnel, je m'intéresse au C appliqué aux systémes temps reel, afin de pouvoir plus tard bidouiller chez moi!

sous Linux je ne sais pas donc je m'en remets à Gangsoleil et la fonction signal() mais sous Windows il faut appeler des fonctions spécifiques de l'OS