From 42ff0f374df3e8ec98a6d02fbf564ba21aef7e61 Mon Sep 17 00:00:00 2001 From: Matthieu Jolimaitre Date: Mon, 26 Feb 2024 20:26:38 +0100 Subject: [PATCH 1/5] bus init --- bus/init.md | 98 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 bus/init.md diff --git a/bus/init.md b/bus/init.md new file mode 100644 index 0000000..a68d210 --- /dev/null +++ b/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 From eefd9bdd488780cffaa7e7488e20000aece6110a Mon Sep 17 00:00:00 2001 From: Matthieu Jolimaitre Date: Mon, 26 Feb 2024 20:26:56 +0100 Subject: [PATCH 2/5] archi init --- archi/0_init.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 archi/0_init.md diff --git a/archi/0_init.md b/archi/0_init.md new file mode 100644 index 0000000..6780985 --- /dev/null +++ b/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 From 8c024db0f71b0113a93ec55e5c01fcef681faf3f Mon Sep 17 00:00:00 2001 From: Matthieu Jolimaitre Date: Mon, 26 Feb 2024 20:27:15 +0100 Subject: [PATCH 3/5] surete append --- surete/01_model_ascenseur.py | 69 ++++++++++++++++++++++++++++++++++++ surete/01_model_checking.md | 58 ++++++++++++++++++++++++++++++ 2 files changed, 127 insertions(+) create mode 100644 surete/01_model_ascenseur.py create mode 100644 surete/01_model_checking.md diff --git a/surete/01_model_ascenseur.py b/surete/01_model_ascenseur.py new file mode 100644 index 0000000..8e42691 --- /dev/null +++ b/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") diff --git a/surete/01_model_checking.md b/surete/01_model_checking.md new file mode 100644 index 0000000..14f2322 --- /dev/null +++ b/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 From 89fdf285b5ae0303ba01786bbb069152e5a82a57 Mon Sep 17 00:00:00 2001 From: Matthieu Jolimaitre Date: Mon, 26 Feb 2024 20:27:35 +0100 Subject: [PATCH 4/5] reseau append --- reseau/01_transmission.md | 97 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 reseau/01_transmission.md diff --git a/reseau/01_transmission.md b/reseau/01_transmission.md new file mode 100644 index 0000000..4da6150 --- /dev/null +++ b/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. From 74036fd3046b127b5902059ea9d54825a7d06bab Mon Sep 17 00:00:00 2001 From: Matthieu Jolimaitre Date: Mon, 26 Feb 2024 20:27:54 +0100 Subject: [PATCH 5/5] interpromo add --- interpromo/airbus.md | 10 ++++++++++ interpromo/smile.md | 45 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 55 insertions(+) create mode 100644 interpromo/airbus.md create mode 100644 interpromo/smile.md diff --git a/interpromo/airbus.md b/interpromo/airbus.md new file mode 100644 index 0000000..25c2920 --- /dev/null +++ b/interpromo/airbus.md @@ -0,0 +1,10 @@ + AIRBUS +======== + +Entreprise +---------- + +- avions +- hélico +- défense & espace + diff --git a/interpromo/smile.md b/interpromo/smile.md new file mode 100644 index 0000000..5fc2509 --- /dev/null +++ b/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