interpromo add

archi/0_init.md

@@ -0,0 +1,14 @@
+# Introduction
+
+Des ensembles de systèmes organisés par une architecture.
+C'est un enemble de règle de communication et d'organisation offrant des garanties sur les systèmes qui les appliquent.
+
+Objectifs :
+- réduire la complexité du logiciel en structurant les composants.
+- Déterminer la capacité d'un logiciel à atteindre des objectifs.
+- Optimiser les processus de développements (programmation, test, documentation, support, maintenance).
+
+- Compréhension
+- Construction
+- Réutilisation
+- Gestion

bus/init.md

@@ -0,0 +1,98 @@
+# Multiplexage
+
+## Pourquoi ?
+
+Machines à plusieurs objectifs.
+
+- sécurisation
+- réduction de consomation
+- confort de conduite
+
+Grand nombre de périphériques à connecter.
+
+### Conventionnalité : une connection par liaison nécessaire :
+
+```
++---+   +---+
+| A |---| B |
+|   |-+ |   |
++---+ | +---+
+      |   |
+      | +---+
+      +-| C |
+        +---+
+```
+
+- Nombre de connections exponentelle.
+- Difficile à mettre à jour.
+
+### Multiplexage : une connection commune en 'réseau'.
+
+```
++---+   +---+
+| A |-+-| B |
++---+ | +---+
+      |
+      | +---+
+      +-| C |
+        +---+
+```
+
+- Nombre de connections linéaire.
+- Disponibilité de l'information.
+
+## Avantages
+
+- moins de capteurs et de nombres de liaisons
+- le poids et les couts diminuent
+- extensibilité avec un cout minimal
+- reconnu par une norme iso de fiabilité
+
+## Principes
+
+- un capteur par donnée nécessaire
+- échange de donnée sur un cannal global.
+
+### Détail
+
+- Un réseau unifié
+	- Structuration des trames
+	- Synchronisation des horloges
+	- Arbitrage, priorisation de l'accès au Bus
+
+## Architecture en couches
+
+### étage d'entrée
+
+Interface avec les capteurs
+
+### étage de calcul
+
+Le microprocesseur
+
+- contient possiblement des mémoires
+
+### étage de sortie
+
+Interface avec les actionneurs
+
+## Architecture réseau
+
+- maitre esclave
+- multi-maitre
+- mixte
+
+## Protocole
+
+- l'acheminement des trames
+- synchronisation d'horloges
+- deux trames peuvent être émise en même temps
+	- l'arbitrage détermine celle qui est transmise
+	- la seconde sera ré-émise ensuite pour ne pas perdre d'information
+
+### Méthode CSMA
+
+- chaque message a un ID, un ID faible donne une plus haute priorité
+- un temps est réservé pour la lecture des messages à envoyer
+	- un hashset des IDs supperposés est écrit sur le BUS,
+	- l'ID le plus faible enverra son message au temps suivant

interpromo/airbus.md

@@ -0,0 +1,10 @@
+ AIRBUS
+========
+
+Entreprise
+----------
+
+- avions
+- hélico
+- défense & espace
+

interpromo/smile.md

@@ -0,0 +1,45 @@
+
+ SMILE
+=======
+
+Entreprise
+----------
+
+- ESN, Toulouse
+- Systèmes embarqués
+	- appareils intelligents
+	- réseau
+- 32 ans
+- 15 employés (tls)
+- formation / conseil Open Source
+
+Expertise
+---------
+
+- Présentation (QT)
+
+- Applicatif
+	- C
+	- Rust
+	- C++
+
+- Customisation linux
+	- Driver
+	- Strip (yocto)
+
+Produits
+--------
+
+- Embarqués
+	- IHMS
+
+- AIRBUS : Études des systèmes linux
+
+
+- 3 stages
+
+Réfs
+----
+
+> formations.opensourceschool.fr
+> alexandre.lahaye@smile.fr

reseau/01_transmission.md

@@ -0,0 +1,97 @@
+
+## Contexte
+
+Exemple d'architecture
+
+```
+| microprocesseur | | rom | | ram | | eeprom | | chien de garde |
++-----------------+ +-----+ +-----+ +--------+ +----------------+
+        |              |       |        |              |
+        +--------------+-------+--------+--------------+
+                               | bus
+    +---------+----------------+------------------+
+    |         |                |                  |
++--------+ +-----+ +--------------------+ +-----------------+
+| timers | | can | | interface ethernet | | interface serie | 
+
+                   ^^^^^^^^^^^^^^^^^^^^^\__ implémentation réseau
+```
+
+Couches intéressées
+
+- TCP
+- IP
+- Transport
+
+Transmission
+
+- Série
+	- un seul fil, découpage de l'information basé sur la temporalité
+	- liée à une horloge
+	- 'lent'
+- parallèles
+	- plusieurs fils série
+	- 'rapide'
+	- 'courte distance'
+
+## Synchronicité
+
+### Asynchrone
+
+une légère différence de fréquences due à des perturbation est compensée
+par le fait que les données sont envoyées par petites séquences délimités
+par des mots 'start' et 'stop' pour candenser les horloges
+
+#### Contrôle
+
+Pour contrôler les flux, on peut utiliser des messages de contrôles :
+- hardware : il existe des lignes séries dédiées au contrôle
+- software : mots réservés dans un dialogue
+
+### Synchrone
+
+Une transmission est rendue synchrone si elle :
+- commence par une étape de synchronisation
+- transmet les données utiles de manière synchrone
+- termine par une étape de contrôle
+
+## Pertes
+
+- Affessement du signal, perte en intensité proportionnelle à la distance.
+- Bruits, parasitage du signal liée à l'entropie du milieu.
+
+## Codage
+
+### bipolaire
+
+la donnée est encodée en binaire envoyé au cours du temps
+de façon régulière à travers une valeur physique.
+
+> exemple : NRZ (non-return zero)
+> une horloge alterne de manière régulière.
+> un zéro est encodé par une tension négative pendant une période de l'horloge.
+> un un est encodé par une tension positive.
+
+> exemple : NRZI (non-return zero invertion)
+> une horloge alterne de manière régulière.
+> la valeure communiquée est initialisée à zéro.
+> à chaque période de l'horloge
+> 	- si la tension est positive, la valeur reçue est la valeur communiquée précédente.
+> 	- si la tension est négative, la valeur reçue est inversée par rapport à la valeur communiquée précédente.
+
+défaut de NRZ & NRZI : la valeur physique peut être plate pendant un long moment et la synchronisation risque de se perdre.
+
+### différentiel
+
+le changement d'une valeur physique constitue le signal transmis.
+(en mesurant le temps entre ces changement par exemple)
+
+> exemple : codage Manchester
+> Un un est encodé en envoyant une valeure positive lors du front montant de l'horloge
+> Un zéro est encodé en envoyant une valeure positive sur le front déscendant de l'horloge.
+
+## bande de base
+
+La fréquence utilisable dépend du média.
+Certains signaux encodés dans des fréquences doivent être
+transformés pour être modulé vers une fréquence utilisable.

surete/01_model_ascenseur.py

@@ -0,0 +1,69 @@
+from enum import Enum
+from dataclasses import dataclass
+
+class Etage(Enum):
+	A = 0
+	B = 1
+	C = 2
+
+@dataclass
+class Etat:
+	ascenseur: Etage = Etage.A
+	bouton_A: bool = False
+	bouton_B: bool = False
+	bouton_C: bool = False
+
+	def clone(self): return Etat(ascenseur=self.ascenseur, bouton_A=self.bouton_A, bouton_B=self.bouton_B, bouton_C=self.bouton_C)
+
+def transition(etat: Etat, bouton_A: bool, bouton_B: bool, bouton_C: bool):
+	if bouton_A: etat.bouton_A = True
+	if bouton_B: etat.bouton_B = True
+	if bouton_C: etat.bouton_C = True
+
+	if etat.bouton_A:
+		ascenseur = Etage.A
+		etat.bouton_A = False
+
+	elif etat.bouton_B:
+		ascenseur = Etage.B
+		etat.bouton_B = False
+
+	elif etat.bouton_C:
+		ascenseur = Etage.C
+		etat.bouton_C = False
+
+	return etat
+
+def tout_bool():
+	yield False
+	yield True
+
+def tout_etage():
+	yield Etage.A
+	yield Etage.B
+	yield Etage.C
+
+def tout_etat():
+	for etage in tout_etage():
+		for bouton_A in tout_bool():
+			for bouton_B in tout_bool():
+				for bouton_C in tout_bool():
+					yield Etat(ascenseur=etage, bouton_A=bouton_A, bouton_B=bouton_B, bouton_C=bouton_C)
+
+def tout_entree():
+		for bouton_A in tout_bool():
+			for bouton_B in tout_bool():
+				for bouton_C in tout_bool():
+					yield (bouton_A, bouton_B, bouton_C)
+
+set_ = set()
+for etat in tout_etat():
+	transition_map = {}
+	for entree in tout_entree():
+		res = transition(etat.clone(), *entree)
+		if str(res) not in transition_map: transition_map[str(res)] = []
+		set_.add(str(etat) + " + " + str(entree) + "\n=> " + str(transition(etat, *entree)))
+
+
+for line in set_:
+	print(line + "\n")

surete/01_model_checking.md

@@ -0,0 +1,58 @@
+- modèle : représentation mathématique
+- vérification : algorithme fournissant une preuve adaptée
+
+## modèle
+
+- système de transitions
+	- machine à état, avec des états non désirés
+
+- synchronicité
+	- synchrone
+		- opérations sur tous les circuits sont organisées par une seule horloge de manière granulaire
+		- physiquement, le temps de propagation des signaux est bien inférieur à la période de l'horloge
+
+	- asynchrone
+		- des signaux peuvent se propager entre circuits avant la fin d'un changement d'état d'un circuit
+		- comporte des signaux indépendants et des verroux de synchronisation
+		- exemple : échanges réseau, composants à plusieurs horloges 
+
+- transition
+	- synchrone : une transition change tous les circuits
+	- asynchrone : une transition ne concerne et change qu'un circuit
+
+### automate fini
+
+- ensemble d'état
+- ensemble de transitions
+- un 'langage' qui sert d'entrées système
+- une phrase qui est une entrée précise
+
+- les état finaux serviront de cas d'erreurs, nous cherchons donc à vérifier que l'état final ne peut pas être atteint
+
+- on peut différencier des langages pour analyser un sous ensemble de cas à vérifier lorsqu'on intègre de nouvelles entrées
+- faire le produit d'automates A et B, c'est former l'automate qui prends comme transition les tuples des entrées de A et B
+
+#### Exemple
+
+propriété : tout A est suivi d'un B dans le langage (b+ab)*
+
+
+### structure de kripke
+- défini par une liste de propositions
+- ensemble de variables propositionnelles (équation booléennes)
+- ensemble d'états
+- ensemble de transitions
+- pour chaque état, l'ensemble des propositions qui sont vérifiées par cet état
+
+#### traces
+- suite d'évènements / états
+
+- est un ensemble mathématique de la forme:
+	- toutes les suites avec :
+		- e_0 est un état de départ
+		- (e_n, e_n+1) est une transition existante
+
+- arborescence
+	- arbre des états possibles en arrivant à chaque état en partant de l'état initial
+		- racine : état de départ
+		- enfants d'un neud : états accessibles depuis cet état