Terminale générale · Sciences de l'ingénieur

Programmer une interface et ses événements

Comprends la boucle événementielle, les gestionnaires et la validation des saisies grâce à une interface de ventilation et à six activités corrigées.

Lecture et activités : environ 50 minutes

Objectifs

  • Identifier les composants d’une interface événementielle
  • Valider une saisie et tracer ses effets
  • Concevoir des gestionnaires réactifs
Sommaire du chapitre
  1. Relier widgets, événements et gestionnaires
  2. Séparer saisie, commande et mesure
  3. Résoudre une séquence de saisies
  4. Garder une interface réactive
  5. Tester le programme par scénarios

Un clic sur « appliquer » prouve-t-il que le ventilateur a changé de vitesse ?

Une interface graphique relie des actions humaines à un programme. Nous concevons le panneau d’une maquette de ventilation : saisie d’une consigne de 0 à 100 %, bouton Appliquer, bouton Arrêter et affichage de mesure. Les échanges et délais sont fictifs, définis pour raisonner. Le programme étudié ne commande aucun appareil réel.

Relier widgets, événements et gestionnaires

Un widget est un élément de l’interface : bouton, champ de saisie ou étiquette. Un événement signale un fait : clic, validation au clavier, réception d’une donnée ou échéance d’une temporisation. Le gestionnaire, aussi appelé fonction de rappel, est la fonction associée à cet événement. L’association entre événement et fonction doit être établie une fois à l’initialisation ; dessiner un bouton ne lui attribue aucune action automatiquement.

La boucle événementielle reçoit les événements et appelle leurs gestionnaires. Elle ne déroule donc pas seulement une longue suite d’entrées demandées à l’utilisateur. L’ordre des clics n’est pas connu à l’avance. Le programme conserve un état entre deux événements : dernière consigne valide, demande en attente et dernière mesure. Une variable locale créée dans un gestionnaire ne remplace pas cette mémoire partagée explicitement définie.

À toi d'essayer

A1. Identifie événement et gestionnaire pour le bouton Appliquer.

Coup de pouce : Distingue ce qui arrive de la fonction qui réagit.

Voir la réponse

Le clic est l’événement ; appliquer() est le gestionnaire. Le champ de saisie est un widget dont appliquer() lit le contenu. Il faut relier le clic à cette fonction.

Séparer saisie, commande et mesure

Trois informations différentes dans le panneau — schéma pédagogique original, à lire de gauche à droite.

Le texte « 70 » est converti en nombre avant toute comparaison. Une saisie vide, non numérique ou hors intervalle produit un message précis et conserve la dernière consigne valide. La consigne exprime ce que l’on demande ; la mesure décrit ce que l’on observe. Afficher immédiatement « vitesse réelle 70 % » après le clic serait trompeur. On peut afficher « consigne 70 %, demande en attente », puis la mesure lorsqu’elle arrive.

Pour chaque message reçu, vérifier sa structure et son identifiant. Une réponse ancienne ne doit pas remplacer l’état d’une demande plus récente. Une échéance de 500 ms sans réponse change l’indication en « réponse absente », sans conclure que le ventilateur est arrêté. L’interface rend ainsi visibles les incertitudes au lieu de fabriquer un succès.

À toi d'essayer

A2. La consigne vaut 70 %, la mesure 62 %. Que faut-il afficher ?

Coup de pouce : Les deux nombres répondent à deux questions différentes.

Voir la réponse

Afficher consigne 70 % et mesure 62 %, avec leur libellé. L’écart vaut 8 points de pourcentage ; il ne prouve pas seul une panne, car un régime transitoire est possible.

Résoudre une séquence de saisies

Exemple résolu

Cas 1. La consigne initiale vaut 35 %. À 0 ms, l’utilisateur applique « 120 ». À 100 ms, il applique « 70 ». La réponse à cette seconde demande arrive à 180 ms et une mesure de 62 % à 200 ms.

  1. Étape 1 : 120 dépasse 100 : rejeter la saisie, signaler la borne et conserver 35 % ; aucune demande n’est émise.
  2. Étape 2 : À 100 ms, convertir 70, vérifier l’intervalle puis mémoriser 70 % et afficher en attente.
  3. Étape 3 : La réponse arrive après 180 − 100 = 80 ms, avant l’échéance de 500 ms : afficher demande acceptée.
  4. Étape 4 : À 200 ms, afficher la mesure 62 % séparément de la consigne.

Résultat : Une seule demande valide est émise. Elle est acceptée après 80 ms. La mesure demeure distincte : 62 % ne devient pas 70 % parce que la demande a été acceptée.

Piège à éviter : Ne pas remplacer une saisie invalide par une valeur limite sans prévenir : cela transformerait la demande de l’utilisateur.

À toi d'essayer

A3. Que fait appliquer() si le champ contient « vite » ?

Coup de pouce : La conversion peut échouer avant le test des bornes.

Voir la réponse

Intercepter l’échec de conversion, afficher « saisir un nombre entre 0 et 100 », conserver la consigne précédente et ne rien transmettre. Tester seulement valeur > 100 ne suffit pas.

Garder une interface réactive

Un gestionnaire doit accomplir une action courte puis rendre la main. Une attente de deux secondes dans appliquer() empêche la boucle de traiter les clics suivants si tout s’exécute dans le même fil. Pour suivre une mesure toutes les 100 ms, demander une temporisation de rappel, puis mettre à jour l’affichage au prochain événement. Une temporisation planifiée n’est pas une garantie de ponctualité absolue : son traitement dépend aussi de la disponibilité de la boucle.

Algorithme de appliquer() : lire le champ ; tenter la conversion ; rejeter si invalide ; créer un identifiant croissant ; mémoriser la consigne et cet identifiant ; lancer l’envoi sans attente bloquante ; afficher en attente ; planifier le contrôle d’échéance. À réception d’une réponse : si son identifiant est celui encore attendu, actualiser le statut ; sinon ignorer cette réponse pour le statut courant. Tous les changements de widgets restent dans le fil de l’interface.

Exemple résolu

Cas 2. Une opération bloquante commence à 0 s et dure 2 s. Un clic Arrêter arrive à 0,3 s. Comparer avec un traitement où chaque gestionnaire dure au plus 5 ms et où l’envoi est non bloquant.

  1. Étape 1 : Dans le premier cas, le clic reste en file jusqu’à la fin de l’opération : délai minimal 2 − 0,3 = 1,7 s.
  2. Étape 2 : Dans le second modèle, si un seul gestionnaire est en cours et aucun autre événement devant le clic, l’attente due à ce gestionnaire est au plus 5 ms.
  3. Étape 3 : Après traitement du clic, une demande de consigne 0 % est envoyée ; sa réception reste à confirmer.

Résultat : Le second choix réduit fortement le retard imputable à l’interface dans ces hypothèses. Il ne garantit pas le délai complet du réseau ou de l’actionneur.

Piège à éviter : Un bouton visible ne constitue pas à lui seul une fonction d’arrêt matériel garanti.

À toi d'essayer

A4. Une tâche prend 260 ms alors que le rappel est demandé toutes les 100 ms. Peut-on promettre dix affichages par seconde ?

Coup de pouce : Le même fil ne peut pas exécuter simultanément les deux tâches.

Voir la réponse

Non. Le rappel sera retardé ; selon la bibliothèque, les événements pourront être regroupés ou s’accumuler. Réduire ou déporter la tâche et contrôler les dates réelles d’actualisation.

Tester le programme par scénarios

Préparer des événements et des résultats attendus : champ vide, borne 0, borne 100, valeur 101, réponse absente et réponse ancienne. Le test doit vérifier les valeurs mémorisées et le texte affiché, pas seulement l’absence d’erreur informatique. Une donnée vieille de plus d’une seconde sera ici signalée comme ancienne ; ce seuil est un choix pédagogique à adapter à la dynamique du système.

Attention :

Erreur 1 — Relier le même clic plusieurs fois peut envoyer plusieurs demandes. Effectuer les associations une fois et compter les envois dans le test.

Erreur 2 — Attendre la réponse dans une boucle bloque les interactions. Traiter une réception comme un nouvel événement.

Erreur 3 — Employer un seul libellé pour consigne et mesure masque la provenance. Afficher les deux avec leurs unités et leur date.

À toi d'essayer

A5. La demande 12 est remplacée par la demande 13. La réponse 12 arrive ensuite. Quel statut actualiser ?

Coup de pouce : Compare l’identifiant reçu à celui encore attendu.

Voir la réponse

Ne pas marquer la demande 13 comme acceptée. La réponse 12 concerne une ancienne demande ; l’ignorer pour le statut courant et conserver 13 en attente.

À toi d'essayer

A6. Propose un test de limite qui vérifie aussi l’affichage.

Coup de pouce : Choisis une valeur juste au-delà de l’intervalle.

Voir la réponse

Avec consigne mémorisée 35 %, appliquer 101 : vérifier zéro envoi, consigne inchangée et message indiquant la borne 100. Le résultat serait incomplet si l’on vérifiait seulement la variable.

À retenir

  • Un événement déclenche un gestionnaire associé à un widget ou à une réception.
  • La boucle reste réactive lorsque les gestionnaires rendent rapidement la main.
  • Consigne, acceptation de demande et mesure sont des informations différentes.

S'entraîner sur cette notion

Aucun exercice spécifique n'a encore été validé pour ce chapitre. Le répertoire SI reste accessible.

Explorer les exercices SI

Fiche de révision

Énumérer les widgets et associer chaque événement à une fonction.

Convertir les saisies puis contrôler explicitement leurs bornes.

Conserver l’état nécessaire entre les événements.

Identifier les demandes pour reconnaître les réponses anciennes.

Planifier les échéances sans attente bloquante.

Vérifier les libellés et les valeurs après un scénario positif et négatif.

Questions fréquentes

Pourquoi le programme continue-t-il après la fin de l’initialisation ?

La boucle événementielle reste active. Elle attend des événements puis déclenche les fonctions associées. Une fonction de rappel n’a pas besoin d’être appelée en boucle par notre code pour réagir aux clics.

Une temporisation rend-elle le traitement parallèle ?

Non. Elle demande un appel ultérieur ; dans une boucle à un seul fil, cet appel attend que le gestionnaire courant se termine. Elle évite une attente active mais ne rend pas une longue fonction instantanée.

Et maintenant ?

Choisis la suite de ton parcours : approfondir la notion suivante, revoir le chapitre ou t’entraîner avec les exercices réellement disponibles.

Besoin d’une révision ? Revoir la leçon précédente : Matérialiser un prototype et sa commande dans une chaîne numérique

Toutes les leçons de Terminale générale — Sciences de l’ingénieur

Scientia