Couches 1 & 2 : Échanger des données avec un tiers.

Transmettre des bits (couche 1 : physique)

On transmet des données binaires (suites de 0 et de 1) par l'intermédiaire d'un médium, d'un support physique, e.g. :
Comment représenter un bit sur le médium ?
Par exemple découper le temps en périodes et associer un voltage durant cette période à un bit : 1V = 1, -1V = 0.
Problématique : comment transmettre le plus de bits possible ?
Par exemple, -2V = 0, -1V = 1, 1V = 2, 2V = 3, diminuer la durée des périodes (augmenter la fréquence), plus de canaux de communications (= plusieurs fils), etc.
En réalité, systèmes + compliqués, avec des sinoïsidales, des phases, etc. pour transmettre plus d'informations en étant résistant aux interférences physiques.

Transmettre des trames (couche 2 : liaison)

Juste envoyer des bits n'est pas suffisant :
Pour cela on utilise des protocoles :
Par exemple une trame Ethernet est constituée de :
Beaucoup de protocoles intègrent aussi un numéro de version/protocole afin de s'assurer que tout le monde parle le même langage.
! Tout le monde (sur le medium) peut lire le paquet à ce niveau !!!
Lorsque le médium est une onde, tout le monde à proximité peut voir les bits passer. Les protocoles de liaisons vont donc généralement aussi chiffrer les données.

Adresses

Le destinataire indique qui doit lire le message (donc les autres ordi l'ignorent), l'expéditeur, à qui répondre. Attention, rien ne garanti que l'expéditeur est bien celui qui a envoyé le message.
Pour le WiFi, on a 2 autres adresses, une pour l'antenne émettrice et une réceptrice. Pour rappel, en WiFi on a des points d'accès / bornes, reliées entre elles.
L'adresse utilisée est une adresse MAC unique à chaque carte réseau (physique ou virtuelle), qui est une série de 6 octets représentés en hexadécimal, chaque octets séparés par un ":" : 34:ff:01:34:ad:98

Collisions

Les collisions arrivent lorsque plusieurs personnes parlent en même temps. On a alors deux stratégies :
Les collisions peuvent s'observer au niveau physique, e.g. si on code des bits entre -1V et 1V, si deux émetteurs émettent 1V, on reçoit 2V. On détecte alors la collision. Ces erreurs peuvent parfois être corrigées en fonction de la manière dont les bits sont transmis.
Pour Ethernet, le protocole suivant est utilise :
Pour le CA : on détermine via un algorithme qui a le droit de parler quand et sur quel canal. E.g. en WiFi la borne attribue cela aux devices connectés au réseau.
Note: en WiFi il vaut mieux choisir les réseaux 5GHz afin d'éviter les interférences avec le bluetooth en 2.4GHz (en plus c'est + rapide). Possibilité aussi de choisir la plage de fréquence en fonction de ceux utilisés par les voisins.
Vous notez un premier problème de sécurité sur les ondes : il est facile d'écouter ce qui se passe, mais aussi de provoquer un DOS en émettant des ondes plus fortes que celles du réseau.

Codes correcteurs

Au delà des collisions, des interférences physiques peuvent survenir. Que ce soit lié à un rayon cosmique, au micro-onde en marche, à l'éternuement d'un papillon, ou autre.
Il faut avoir pouvoir détecter l'erreur, et si possible la corriger pour s'éviter à avoir à devoir re-transmettre la trame.
Pour cela, en plus des informations (I), on va ajouter des bits supplémentaires (bits de redondances) qui constitueront un code (C) qu'on transmettra. On découpe les messages en blocs appelés "mots", on parlera alors de "mot d'information" et "mot de code".
De manière naïve, les bits de redondances peuvent tout simplement être la répétition des bits d'informations :
De manière générale, si je suis capable de détecter au moins d erreurs, je suis capable de corriger au moins d/2 erreurs.
On note alors les codes Cc,i,d avec c la taille du mot de code, i la taille du mot d'information, et d le nombre minimal d'erreurs détectées.
Notre objectif est alors de corriger le plus d'erreurs possibles, en minimisant le plus possible les bits de redondances. Le calcul des bits de redondances et la vérification/correction doit aussi être le plus rapide possible (sans prendre trop de ressources aussi). L'objectif étant de transmettre des informations le plus rapidement possible.
On évalue donc le rendement du code par i/c i.e. le taux d'informations transmises dans le mot de code (plus c'est grand mieux c'est).
Si on a une redondance de 1, le rendement sera de 50% pour détecter au moins 1 une erreur.
Plus intelligemment, on peut utiliser un bit de parité (xor de tous les bits = une addition dans F2) pour détecter au moins une erreur, pour un rendement qui sera de i/(i+1), i.e. de plus en plus grand au fur et à mesure que i grandi. Par exemple sur un octet, le rendement sera de 7/8 ~= 90%.
Attention, plus i est grand, plus la probabilité d'erreurs (et donc leur nombre) est importante.

Code de Hamming

Les codes de Hamming permettent de détecter au plus 2 erreurs et d'en corriger au plus 1. Le principe de ces codes est très simple, c'est une forme de "qui-est-ce" informatique.
Decr prodécure
0 1 0 1 1 0 1 0
7 6 5 4 3 2 1 0 S
22 1 1 1 1 0 0 0 → 0
21 1 1 0 0 1 1 0 → 0
20 1 0 1 0 1 0 1 → 0
- repr matrice. On vient de calculer le syndrome. Codage: [ ID Q ] * [ I ] = [ C ] Décodage: [ Q ID ] * [ C' ] = [ I' S ] S est le syndrome. Si S = 0, pas d'erreurs (I=I'). Sinon, S indique la correction à appliquer à I' pour obtenir I. De manière générale, on pré-calcul un tableau donnant pour chaque syndrome possible, le correctif à appliquer. Dans notre cas,
Syndrome Position Masque
111 7 1 << 7 I = 10000000 ⨁ I'
110 6 1 << 6 I = 01000000 ⨁ I'
101 5 1 << 5 I = 00100000 ⨁ I'
100 4 1 << 4 I = 00010000 ⨁ I'
011 3 1 << 3 I = 00001000 ⨁ I'
010 2 1 << 2 I = 10000100 ⨁ I'
001 1 1 << 1 I = 00000010 ⨁ I'

Reed-Solomon

- besoin de savoir si le message est valide ou non... -> e.g. bit de parité. -> % p fait que les redondances auront +1 bit par rapport aux messages... donc e.g. message 7 bits (+ parité) - redondance : 8 bits + bits de parités regroupés ensembles dans un octet supplémentaire.

Notes

Reed-Solomon (année ?): -> interlacer (si erreurs côté à côté pour les 2).
On a de nombreux codes correcteur d'erreur, plus avancés/performants que ceux vus précédemment. Beaucoup sont en fait des généralisations des code de Hamming et/ou de Reed-Solomon. - Turbo : l'un des meilleurs (?).

Couches OSI

À la fin OSI + encapsulation. - pas tout à fait vrai, liaison très lié (contraintes du) physique . https://fr.wikipedia.org/wiki/Mod%C3%A8le_OSI#Architecture_en_couches (PDU)

Next week