diff --git a/infotro/Eln/Sigma-Delta.md b/infotro/Eln/Sigma-Delta.md
index 9a9a723..60fcee4 100644
--- a/infotro/Eln/Sigma-Delta.md
+++ b/infotro/Eln/Sigma-Delta.md
@@ -72,8 +72,7 @@ d'atteindre des performances supérieures à celles des autres types de
 convertisseurs analogique-numérique en termes de résolution et de
 précision.
 
-$$
-SNR = 6,02n + 1,76[dB] 
-$$
+cccccckrhltvbdnvjilbnrchidectlggreetcdrehlet
+
 
 ![img.png](snr_by_osr.png)
diff --git a/infotro/PTR/README.md b/infotro/PTR/README.md
new file mode 100644
index 0000000..42e52cc
--- /dev/null
+++ b/infotro/PTR/README.md
@@ -0,0 +1,7 @@
+<header><h1>
+PTR - Programmation Temps Réel
+</h1></header>
+
+- [XF](/infotro/PTR/XF.md)
+- [UML](/infotro/PTR/UML)
+- [RealTime](/infotro/PTR/RealTime)
\ No newline at end of file
diff --git a/infotro/PTR/RealTime.md b/infotro/PTR/RealTime.md
new file mode 100644
index 0000000..913ab97
--- /dev/null
+++ b/infotro/PTR/RealTime.md
@@ -0,0 +1,204 @@
+<header><h1>
+Real Time
+</h1></header>
+
+## Temps réel vs non - temps réel
+Pour les systèmes non temps réel, seule l'exactitude du résultat importe, le traitement est principalement contrôlé par
+des données massives, et ils ne dépendent pas d'un matériel spécifique.
+En revanche, pour les systèmes temps réel, non seulement l'exactitude du résultat est importante, mais aussi le moment
+où le résultat apparaît. Le traitement est contrôlé par des événements, les données sont simples,
+les quantités sont modérées, le processeur est intensément utilisé, et ces systèmes dépendent d'un matériel spécifique.
+
+**Système Déterministe:**
+1. L'état futur du système peut être prédit de manière précise à partir de son état actuel et des entrées.
+2. Chaque transition d'état est définie de manière univoque par les conditions actuelles, assurant une prévisibilité totale.
+3. Les réponses du système à des signaux d'entrée sont constantes, sans dépendance de la qualité ou du nombre de ces signaux.
+4. Idéal pour les applications où la précision du timing et la prédictibilité du comportement sont cruciales, comme dans les systèmes temps réel.
+5. Le concept de déterminisme assure une fiabilité et une certitude dans le fonctionnement du système.
+
+**Système Non-Déterministe:**
+1. L'état futur du système ne peut pas être prédit de manière précise à partir de son état actuel et des entrées, introduisant une certaine incertitude.
+2. Plusieurs transitions d'état peuvent résulter des mêmes conditions initiales, rendant le comportement du système moins prévisible.
+3. Les réponses du système à des signaux d'entrée peuvent varier en fonction de différents facteurs, tels que la charge du système ou les conditions d'exécution.
+4. Souvent utilisé dans des applications où une flexibilité est nécessaire, mais peut poser des défis dans les systèmes où la prédictibilité est cruciale.
+5. La gestion de l'incertitude et l'adaptabilité aux conditions changeantes sont des caractéristiques clés des systèmes non-déterministes.
+
+
+### Management du temps (Timing)
+Le timing peut avoir principalement deux formes différentes :
+- *Timing absolu:* Une tâche sera exécutée à un moment dans le temps bien déterminé.
+- *Timing relatif:* Une tâche sera exécutée à la suite de l'apparition d'un événement.
+
+Le timing peut par-contre aussi être classé comme suit :
+- *Fixed Time:* Une tâche sera exécutée à un moment bien précis.
+- *Fixed Time +/-:* L'exécution d'une tâche est démarrée dans un tout petit intervalle de temps avant ou après un moment bien précis.
+- *Latest Time:* L'exécution d'une tâche est démarrée dans un intervalle de temps avant le moment le plus tard possible.
+- *Earliest Time:* L'exécution d'une tâche est démarrée dans un intervalle de temps après le moment le plus tôt possible.
+
+### Management du traitement
+
+***Multitasking:***
+Traitement en thread: pseudo-parallèle
+
+***Multiprocessing:***
+Traintement en parallèle sur plusieurs coeur / processeurs. 
+
+### Management des ressources
+
+***Mutex:***
+Une ressource peut être utilisée par un seul processus à la fois
+
+***Semaphore:***
+Une ressource peut être utilisée par un nombre limité de processus et sous des conditions bien précise
+
+### Approches pour la programmation temps réel
+
+***Synchrone:***
+Tout est planifié à l'avance pendant la phase de programmation.
+
+***Asynchrone:***
+Rien est planifié à l'avance. Toutes les décisions sont faites pendant d'exécution.
+
+#### Synchrone
+Le timing des tâches cycliques est planifié précisément.
+Ces dernières sont synchronisées (démarrées) par un signal d'une horloge.
+La scéquence des tâches est déterminé à l'avance
+Le temps cumulée de l'execution des tâches ne doit pas dépasser le temps d'un cycle.
+![Programmation synchrone](system_synchron.png)
+
+<u>*Avantages*</u><br>
+- Timing précis
+- Comportement déterministe
+
+<u>*Avantages*</u><br>
+- Inadaptée aux Processus Sporadiques :
+- Inflexibilité
+
+#### Asynchrone
+
+Le timing des tâches est contrôlé soit par un RTOS soit par un XF.
+Les tâches sont contrôlées par des événements et des appels de méthodes.
+Des tâches parallèles sont sérialisées.
+Le séquencement des tâches n'est pas déterminé.
+![Programmation asynchrone](system_asynchron.png)
+
+<u>Avantages</u><br>
+- Flexibilité face aux changements de spécification du système.
+- Implémentation possible au moyen de diagrammes d'états transitions.
+
+<u>Inconvénients</u><br>
+- Le RTOS ou le XF introduit des délais dans le traitement.
+- Le timing n'est pas très précis, rendant les systèmes moins déterministes en temps.
+- Systèmes toujours préemptifs, avec la possibilité d'interruptions dans le traitement 
+
+
+## Processus & Thread
+
+**Processus :**
+Un processus est un programme en cours d'exécution, avec sa propre mémoire et ses ressources allouées.
+Dans le contexte des systèmes temps réel, un processus est souvent appelé une "task" (tâche).
+Il peut être lié à un Real-Time Operating System (RTOS) ou un Executive Framework (XF).
+Chaque processus a son propre espace mémoire, ce qui signifie qu'il ne partage pas directement ses données avec d'autres processus.
+La communication entre les processus se fait généralement à travers des messages.
+
+**Thread :**
+- Un thread est une unité d'exécution plus légère au sein d'un processus.
+- Contrairement à un processus, un thread partage le même espace mémoire que son processus parent.
+- Les threads peuvent être exécutés de manière concurrente, ce qui permet un parallélisme au sein du processus.
+- Les threads peuvent communiquer plus facilement entre eux, car ils ont un accès direct à la mémoire partagée.
+
+**Différence :**
+- La principale différence réside dans la gestion de la mémoire. Les processus ont leur propre espace mémoire distinct, tandis que les threads partagent la même mémoire avec leur processus parent.
+- Les threads permettent une exécution concurrente au sein du même processus, tandis que les processus sont généralement des entités indépendantes.
+- En résumé, un processus est un programme complet en cours d'exécution, tandis qu'un thread est une unité d'exécution plus petite qui partage la mémoire avec d'autres threads dans le même processus.
+
+```plantuml
+@startuml
+binary "Red Task" as r
+binary "Green Task" as g
+binary "Blue Task" as b
+concise "Task" as t
+robust "Red Task" as rt
+
+@0
+r is low
+g is low
+b is low
+t is {-}
+rt is Sleep
+
+@1
+r is high
+g is high
+b is high
+t is "" #blue
+rt is ready
+
+@2
+r is low
+g is low
+b is low
+t is "" #green
+
+@4
+t is "" #red
+rt is running
+
+@6
+b is high
+t is "" #blue
+rt is interrupt
+
+@7
+b is low
+t is "" #red
+rt is running
+
+@9
+b is high
+g is high
+t is "" #blue
+rt is interrupt
+
+@10
+b is low
+g is low
+t is "" #green
+
+@12
+t is "" #red
+rt is running
+
+@13
+t is {-}
+rt is Sleep
+
+@enduml
+```
+
+## Scheduling
+
+
+## OSAL, OXF, RTOS
+
+**Différence entre OSAL, OXF et RTOS :**
+
+1. **OSAL (Operating System Abstraction Layer) :**
+    - L'OSAL est une couche d'abstraction qui fournit une interface uniforme pour accéder aux services du système d'exploitation sous-jacent.
+    - Il permet de rendre le code portable entre différents systèmes d'exploitation en masquant les détails spécifiques de chaque système.
+    - L'OSAL est utile dans des environnements où le système d'exploitation peut varier, permettant ainsi d'adapter le logiciel à différentes plates-formes sans changer le code applicatif.
+
+2. **OXF (Object Execution Framework) :**
+    - L'OXF est un framework qui fournit une infrastructure pour le développement d'applications temps réel orientées objet.
+    - Il facilite la modélisation d'objets réactifs, possédant souvent une machine à états, et offre une gestion efficace des événements.
+    - L'OXF peut être utilisé avec ou sans RTOS. Il fournit des fonctionnalités telles que la gestion des événements, la gestion des tâches, et la synchronisation entre les objets réactifs.
+
+3. **RTOS (Real-Time Operating System) :**
+    - Un RTOS est un système d'exploitation conçu pour répondre aux exigences temporelles strictes des systèmes temps réel.
+    - Il offre des fonctionnalités telles que l'ordonnancement des tâches, la gestion du temps, la synchronisation, et la gestion des interruptions pour assurer des réponses prévisibles aux événements.
+    - Un RTOS peut être utilisé en conjonction avec l'OXF pour développer des systèmes temps réel orientés objet.
+
+**Conclusion :**
+- L'OSAL fournit une abstraction des services du système d'exploitation.
+- L'OXF est un framework pour le développement d'applications temps réel orientées objet.
+- Un RTOS est un système d'exploitation temps réel complet, offrant des services spécifiques pour répondre aux contraintes temporelles strictes.
diff --git a/infotro/PTR/UML.md b/infotro/PTR/UML.md
new file mode 100644
index 0000000..e511583
--- /dev/null
+++ b/infotro/PTR/UML.md
@@ -0,0 +1,118 @@
+<header><h1>
+UML
+</h1></header>
+
+## Class
+
+### Association bidirectionnel
+```plantuml
+@startuml
+A - B : "                                                  "
+@enduml
+```
+
+### Association unidirectionnel
+```plantuml
+@startuml
+class A
+A -> B : "                                                  "
+@enduml
+```
+
+### Aggregation bidirectionnel
+```plantuml
+@startuml
+class A {
+-ptrB: B*
+}
+class B {
++ptrA: A*
+}
+A "+ptrA" o- "-ptrB" B : "                                                  "
+@enduml
+```
+
+```plantuml
+@startuml
+class A {
+-ptrB: B*
+}
+A o- "1" B : "                                                  "
+@enduml
+```
+
+### Composition (pas bidirectionnel)
+```plantuml
+@startuml
+class A {
+#aB: B
+}
+A *-> B : "                                                  "
+@enduml
+```
+
+### Dépendance
+```plantuml
+@startuml
+
+A .> B : <<usage>>\n<<include>>\n<<import>>\n"                                                  "
+@enduml
+```
+
+### Généralisation
+```plantuml
+@startuml
+class "A extends B" as A
+class B {
+-myFunc(a: integer): void
+}
+A <|- B : "                                                  "
+@enduml
+```
+
+### Implémentation
+```plantuml
+@startuml
+interface B
+A .|> B : "                                                  "
+@enduml
+```
+
+## Timing
+```plantuml
+@startuml
+
+robust "Virus Timing" as vt
+vt is Infection
+
+@2023/02/01
+vt is Incubation
+
+@2023/02/05
+vt is Illnes
+
+@2023/02/17
+vt is Infection
+
+
+@enduml
+```
+
+## Sequence
+```plantuml
+@startuml
+participant A as a
+participant B as b
+
+a -> b: synchrone / call
+a ->>(10) b++: asynchrone
+b -->> a--: replay
+a -\\ b : signal
+
+b -> b
+b ->> b 
+
+@enduml
+```
+
+## State machine
diff --git a/infotro/PTR/system_asynchron.png b/infotro/PTR/system_asynchron.png
new file mode 100644
index 0000000..dc79409
Binary files /dev/null and b/infotro/PTR/system_asynchron.png differ
diff --git a/infotro/PTR/system_synchron.png b/infotro/PTR/system_synchron.png
new file mode 100644
index 0000000..f63bc00
Binary files /dev/null and b/infotro/PTR/system_synchron.png differ
diff --git a/infotro/README.md b/infotro/README.md
index 121b598..e98fd92 100644
--- a/infotro/README.md
+++ b/infotro/README.md
@@ -2,6 +2,8 @@
 
 ## [PTR - Programmation Temps Réel](/infotro/PTR/)
 - [XF](/infotro/PTR/XF.md)
+- [UML](/infotro/PTR/UML)
+- [RealTime](/infotro/PTR/RealTime)
 
 
 ## [SDi - Système Distribué](/infotro/SDi/)
diff --git a/infotro/SEm/README.md b/infotro/SEm/README.md
index 72c5ea1..2525782 100644
--- a/infotro/SEm/README.md
+++ b/infotro/SEm/README.md
@@ -1,4 +1,17 @@
-# Taille des paquets de bits
+<header><h1>
+Systèmes Embarqués
+</h1></header>
 
-[PLA](/infotro/arm/PLA.md)
-[ASM](/infotro/arm/ASM.md)
\ No newline at end of file
+# Assembleur
+- [PLA - Programmation en Language Assemleur](/infotro/arm/PLA.md)
+- [ASS - ASSembleur ARM](/infotro/arm/ASM.md)
+
+# C
+- SPR - Sous PRogrammges
+- PSC - Pointers and Memory in C
+- LES - Les Entrées-Sorties
+- INT - Les INTerruptions
+- DMA - Direct Memory Access
+- CAM - Memoire cache
+
+# CI / TDD
diff --git a/infotro/SEm/SPR.md b/infotro/SEm/SPR.md
new file mode 100644
index 0000000..14d4777
--- /dev/null
+++ b/infotro/SEm/SPR.md
@@ -0,0 +1,6 @@
+<header><h1>
+Sous programmes
+</h1></header>
+
+# Intoduction 
+ 
\ No newline at end of file
diff --git a/infotro/_navbar.md b/infotro/_navbar.md
index 79efa63..352264a 100644
--- a/infotro/_navbar.md
+++ b/infotro/_navbar.md
@@ -1,5 +1,7 @@
 * [PTR - Programmation Temps Réel](/infotro/PTR/)
   * [XF](/infotro/PTR/XF)
+  * [UML](/infotro/PTR/UML)
+  * [RealTime](/infotro/PTR/RealTime)
 * [SDi - Systèmes Distribués](/infotro/SDi)
   * [Transmission process](/infotro/SDi/transmission_process.md)
 * [Eln - Électronique](/infotro/Eln/)
diff --git a/style/_coverpage.md b/style/_coverpage.md
index 576ac9e..3ee1bda 100644
--- a/style/_coverpage.md
+++ b/style/_coverpage.md
@@ -1,7 +1,12 @@
 <img src="style/yggdrasil.svg" width="25%"></img>
 
-# Yggdrasil 
-## Collections of notes around IT, OT and other geeks stuff
+<header><h1>
+Yggdrasil
+</h1></header>
+
+<header><h3>
+Collections of notes around IT, OT and other geeks stuff
+</h3></header> 
 <br>
 <br>
 <br>