Qu’est-ce qu’un diagramme de timing ?
Un Diagramme de timing est un diagramme comportemental spécialisé diagramme UML conçu pour visualiser la durée exacte des états et les conditions précises selon lesquelles ces états changent le long d’une timeline linéaire. En tant qu’élément essentiel de la spécification du langage de modélisation unifié (UML), ce type de type de diagramme UML se concentre fortement sur les contraintes de temps rigides, les cycles d’horloge et les signaux d’onde. Il suit les formes d’onde ou les lignes en escalier pour illustrer exactement pendant combien de temps un objet reste dans un état spécifique avant qu’un déclencheur externe ne modifie son état.
Les cartes de timing sont largement utilisées par les ingénieurs en systèmes embarqués, les développeurs de protocoles réseau et les architectes matériels pour modéliser les conditions de course, suivre les changements du cycle de vie des threads ou cartographier les transitions des registres matériels. Avec VPasCode, vous n’avez pas à calculer manuellement les largeurs en pixels ou à cartographier les coordonnées de la timeline. Notre moteur de rendu gère automatiquement toute la grille temporelle en fonction de vos scripts en texte brut.
Guide de syntaxe fondamentale : éléments et constructions
Pour concevoir un diagramme de timing UML précis et conforme aux normes dans PlantUML, vous devez maîtriser les types de participants, les définitions d’états, les intervalles de temps et les contraintes de synchronisation.
1. Déclarer les participants (Robuste vs. Concis)
Vous pouvez modéliser des timelines en utilisant deux styles visuels distincts, selon le niveau de détail requis par votre système. Vous devez les déclarer en utilisant des mots-clés explicites :
- Timelines robustes :Affiche les états sous forme de lignes empilées distinctes. Idéal pour les processus logiciels de haut niveau.
robuste "Thread d'application" comme Thread - Timelines concises :Affiche les états le long d’une seule ligne plane, en utilisant des blocs hachurés pour indiquer les changements. Parfait pour les cartes de signaux matériels compactes.
concis "Registre CPU" comme Reg
2. Définir les transitions d’état et les étapes de temps
Contrairement aux autres diagrammes, vous changez d’état en déclarant un point de contrôle temporel en utilisant le symbole @ symbole, en faisant référence à votre participant, et en utilisant le mot-clé est mot-clé. Les noms d’état contenant des espaces ou des caractères spéciaux doivent être entourés de guillemets :
@0
Thread est Inactif
@10
Thread est "Traitement des données"3. Générer des signaux d’horloge
Pour simuler des horloges matériels binaires, utilisez le mot-clé clock mot-clé. Vous devez spécifier une période de cycle, un rapport cyclique facultatif et un nom interne :
clock "Horloge système" comme CLK avec période 24. Ajout de contraintes de précision et de plannings temporels
Pour documenter des délais d’exécution stricts (par exemple, garantir qu’une transition système a lieu dans une fenêtre spécifiée), utilisez la syntaxe <-> pour relier deux coordonnées temporelles avec une étiquette descriptive :
@10 <-> @40 : {Moins de 30ms}Meilleures pratiques pour des dispositions temporelles propres
- Maintenez les unités de temps uniformes : PlantUML traite les entiers de la chronologie comme des étapes séquentielles génériques. Choisissez une unité de temps uniforme pour votre projet (par exemple, des ticks, des microsecondes ou des secondes) et conservez-la de façon cohérente.
- Utilisez des étiquettes pour les transitions complexes : Vous pouvez ajouter des messages texte directement aux changements d’état en ajoutant deux points immédiatement après l’affectation d’état (par exemple,
@10nReg est en lecture : "Déclencher l'interruption"). - Déclarez les éléments de manière stratégique : PlantUML empile les lignes de vie verticalement dans l’ordre exact de leur déclaration dans votre script. Placez toujours vos horloges principales tout en haut pour un alignement plus facile.
Exemples réels de diagrammes temporels PlantUML
Exemple 1 : États du cache et des registres d’un microcontrôleur (concis et formes d’onde d’horloge)
Ce plan exécutable démontre une chronologie classique en ingénierie matérielle embarquée, avec une horloge système standard fonctionnant parallèlement à un registre de stockage de données concis qui suit les états matériels.
@startuml
clock "Horloge système (CLK)" comme clk avec période 2
concise "Registre du bus de données" comme Reg
@0
Reg est vide
@2
Reg est en lecture : "Récupérer"
@6
Reg est en écriture
@10
Reg est verrouillé
@14
Reg est vide
@enduml
Analyse syntaxique : Le clock directive crée automatiquement une onde carrée rythmique haute/basse. Le Reg la ligne gère plusieurs affectations d’état de manière séquentielle sur la grille de timeline absolue. Les chaînes de texte suivies d’un deux-points (comme : "Récupérer") s’affichent sous forme de repères propres directement au-dessus de la ligne de frontière de transition.
Exemple 2 : Actualisation asynchrone du jeton du consommateur web (Contraintes robustes multi-fils)
Ce plan architectural logiciel avancé et entièrement fonctionnel utilise le format de mise en page robuste pour suivre le flux de travail d’une application web multithreadée, en définissant des délais précis de temporisation entre un client web et un worker d’autorisation.
@startuml
robuste "Client navigateur web" comme Web
robuste "Worker de jeton d'autorisation" comme Auth
@0
Web est inactif
Auth est endormi
@5
Web attend le jeton
Auth est en cours de validation
@15
Auth est en cours de génération
@15 <-> @25 : {Fenêtre de génération}
@25
Auth est endormi
Web est en cours de rendu de page
@40
Web est inactif
@enduml
Analyse syntaxique : En utilisant la déclaration robuste déclaration, les états sont clairement listés sur l’axe Y pour chaque ligne de vie individuelle. La contrainte d’évaluation temporelle (@15 <-> @25 : {Fenêtre de génération}) dessine une flèche de cotation standard à double sens au-dessus de la grille de timeline, indiquant une limite opérationnelle stricte.