Master 2 REOC - Reseaux et Objets Connectes

PART A : PRESENTATION GENERALE

Presentation du Master REOC

Le Master 2 REOC (Reseaux et Objets Connectes) est une formation dispensee a l'ENSEEIHT (Ecole Nationale Superieure d'Electrotechnique, d'Electronique, d'Informatique, d'Hydraulique et des Telecommunications) de Toulouse, dans le cadre d'un double diplome avec l'INSA Toulouse. Cette formation s'inscrit dans le semestre S9 de l'annee 2024-2025.

Ce programme intensif couvre un large spectre de technologies liees aux reseaux embarques et aux objets connectes. Il offre une vision approfondie des architectures reseau modernes, allant de la virtualisation des reseaux (SDN, NFV) aux reseaux temps reel pour l'aeronautique (AFDX, IMA), en passant par les reseaux bas debit pour l'IoT (LoRaWAN) et les processus stochastiques appliques a l'evaluation de performances.

Le cursus est organise en une dizaine de modules complementaires qui permettent de maitriser les aspects theoriques et pratiques des systemes en reseau embarques. L'approche pedagogique allie cours magistraux, travaux pratiques et projets de mise en situation reelle.

Objectifs de la formation

  • Concevoir et deployer des architectures reseau virtualisees (SDN/NFV)
  • Comprendre et implementer des protocoles de communication temps reel pour les systemes embarques critiques
  • Evaluer les performances des reseaux a travers la simulation et la modelisation stochastique
  • Maitriser les technologies de communication bas debit pour l'Internet des Objets
  • Apprehender les architectures modulaires integrees pour l'avionique

PART B : EXPERIENCE ET CONTEXTE

Environnement et contexte

Le Master REOC m'a plonge dans un environnement academique exigeant, mele a l'ENSEEIHT de Toulouse, en parallele de mes cours a l'INSA. Cette double formation a necessite une grande capacite d'organisation et d'adaptation. Les travaux pratiques etaient realises sur des plateformes variees : environnements virtualises avec Docker et Containernet, programmation P4 pour le data plane, simulateurs LoRaWAN en Python, et outils de simulation reseau avec NetworkX.

Le contexte etait celui d'une immersion complete dans les problematiques actuelles des reseaux : comment virtualiser les fonctions reseau, comment garantir le determinisme dans les communications embarquees, comment optimiser les performances des reseaux IoT a grande echelle, et comment modeliser mathematiquement le comportement des systemes en file d'attente.

Mon role et mes responsabilites

  • Conception d'architectures reseau : mise en place de topologies SDN avec Containernet, deploiement de conteneurs Docker pour simuler des equipements reseau
  • Programmation du data plane : implementation de parseurs et de tables de correspondance en langage P4 pour le traitement AFDX
  • Developpement d'outils de monitoring : creation d'interfaces de surveillance et d'adaptation du trafic via les API de controleurs SDN (Ryu)
  • Simulation et evaluation de performances : modelisation de reseaux avec NetworkX, simulation de deploiements LoRaWAN, et calcul de metriques de performance par processus stochastiques
  • Redaction de rapports techniques : documentation detaillee des projets realises, notamment le projet SDCI et le rapport sur les processus stochastiques

Collaboration

La majorite des projets a ete realisee en binome avec Yohan Boujon, un partenaire de confiance avec lequel la collaboration etait fluide et efficace. Notre complementarite nous a permis de mener a bien les travaux pratiques dans les delais impartis, malgre la charge de travail consequente liee au double diplome.


PART C : ASPECTS TECHNIQUES

Cette section detaille les differents modules du Master REOC, couvrant les aspects theoriques et pratiques de chaque thematique abordee.


1. Virtualisation des Reseaux Embarques et P4

Ce module abordait la virtualisation des reseaux dans un contexte embarque, avec un focus sur le protocole AFDX (Avionics Full-Duplex Switched Ethernet) utilise dans l'aeronautique. L'objectif etait de comprendre comment programmer le plan de donnees d'un commutateur reseau en utilisant le langage P4 (Programming Protocol-Independent Packet Processors).

Le TP portait sur l'implementation d'un commutateur AFDX en P4, ou les trames sont routees en fonction de leur Virtual Link (VL). Voici la structure de la trame AFDX definie en P4 :

header_type afdx_frame_t {
  fields {
  	const: 32;
  	vl: 16;
  	source: 48;
  	type: 16;
  }
}

header afdx_frame_t afdx_frame;

parser start {
       return parse_afdx_frame;
}

parser parse_afdx_frame {
	extract(afdx_frame);
	return select(afdx_frame.const) {
		0x03000000: ingress;
	}
}

table table_afdx{
	reads{
		afdx_frame.vl : exact;
	}
	actions{
		compute_afdx;
		_drop;
	}
}

action compute_afdx(port){
	modify_field(standard_metadata.egress_spec, port);
}

La topologie etait simulee avec Mininet et le commutateur comportemental de P4, permettant de tester le routage des trames AFDX selon les Virtual Links configures.

Concepts cles : Plan de donnees programmable, AFDX, Virtual Links, P4, Mininet, SDN pour l'embarque, Time-Sensitive Networking (TSN).


2. Information Centric Networking (ICN/NDN)

Le module sur l'Information Centric Networking (ICN), et plus specifiquement le paradigme Named Data Networking (NDN), proposait une vision radicalement differente des reseaux par rapport au modele IP classique. Au lieu de connecter des machines entre elles, le NDN centre les communications sur les donnees elles-memes : on ne demande plus "connecte-moi a telle machine" mais plutot "donne-moi tel contenu".

Les principes fondamentaux etudies :

  • Interest / Data : le consommateur envoie un paquet "Interest" portant le nom du contenu souhaite, et le reseau achemine un paquet "Data" en reponse
  • Content Store (CS) : chaque noeud du reseau peut mettre en cache les donnees traversantes, permettant de servir les requetes futures localement
  • Pending Interest Table (PIT) : table qui enregistre les Interest non encore satisfaits et les interfaces par lesquelles ils sont arrives
  • Forwarding Information Base (FIB) : equivalent de la table de routage, mais basee sur les noms de contenus

Ce paradigme presente des avantages significatifs pour les reseaux embarques et IoT : reduction de la latence grace au cache distribue, mobilite native des producteurs et consommateurs, et securite integree au niveau des donnees (chaque paquet Data est signe par le producteur).

Concepts cles : NDN, ICN, Content Store, PIT, FIB, routage par nom, cache distribue, securite centree donnees.


3. Software Defined Networking (SDN) - INSA

Le module SDN a l'INSA approfondissait les concepts de separation du plan de controle et du plan de donnees dans les reseaux. Le cours couvrait les architectures SDN, le protocole OpenFlow, et l'utilisation de controleurs SDN tels que Ryu pour programmer le comportement du reseau de maniere centralisee.

Les travaux pratiques portaient sur la mise en place d'une architecture SDN complete avec :

  • Configuration de topologies reseau avec des commutateurs OpenFlow
  • Programmation de regles de flux via le controleur Ryu
  • Implementation de politiques de routage et de filtrage du trafic
  • Analyse du comportement du reseau en temps reel

Concepts cles : OpenFlow, controleur SDN, Ryu, plan de controle centralise, regles de flux, QoS, slicing reseau.


4. Wireless Real-Time Networking

Ce module traitait des reseaux sans fil temps reel, une thematique essentielle pour les systemes embarques critiques dans les domaines de l'IoT industriel (IIoT) et de l'aeronautique. Le cours couvrait les protocoles et mecanismes permettant de garantir des communications deterministes sur des supports sans fil intrinsequement non deterministes.

Les thematiques abordees incluaient :

  • Reseaux temps reel embarques : contraintes de latence, gigue et fiabilite
  • Ad Hoc Networks : protocoles de routage distribues pour les reseaux sans infrastructure
  • IIoT (Industrial Internet of Things) : application des reseaux temps reel au contexte industriel, avec des contraintes de securite et de surete
  • Wireless Sensor and Actuator Networks (WSAN) : protocoles de communication pour les reseaux de capteurs-actionneurs

L'etude de papiers de recherche recents permettait de comprendre les defis actuels : comment concilier les exigences temps reel avec les aleas du canal radio, comment dimensionner un reseau sans fil pour garantir un taux de livraison minimum, et comment integrer ces reseaux dans des architectures industrielles existantes.

Concepts cles : Determinisme, latence bornee, reseaux ad hoc, TDMA, ordonnancement, IIoT, WSAN.


5. Projet NFV/SDCI

Le projet NFV/SDCI (Network Function Virtualization / Software Defined Cloud Infrastructure) constituait le projet majeur du Master REOC. Realise en binome avec Yohan Boujon, ce projet combinait SDN et NFV pour concevoir une infrastructure reseau virtualisee complete avec orchestration.

5.1 Architecture reseau

Nous avons concu une topologie reseau composee de plusieurs commutateurs et hotes pour simuler un environnement reseau complexe. La topologie incluait des composants tels que des commutateurs (S1, S2, S3), des hotes (Z1, Z2, Z3), une passerelle intermediaire (GI) et un serveur. Cette configuration nous a permis de tester le filtrage de donnees et la connectivite entre les composants reseau.

Figure : Topologie reseau du projet SDCI

def setup_topology():
    net = DCNetwork(monitor=False, enable_learning=True)

    # Adding switches
    s1 = net.addSwitch('s1')
    s2 = net.addSwitch('s2')
    s3 = net.addSwitch('s3')

    # Adding Docker containers as network hosts
    z1 = net.addDocker('z1', ip='10.0.0.1', dimage="reoc:device")
    z2 = net.addDocker('z2', ip='10.0.0.2', dimage="reoc:device")
    z3 = net.addDocker('z3', ip='10.0.0.3', dimage="reoc:device")

    ordonnanceur = net.addDocker('ordon', ip='10.0.0.100', dimage="reoc:test")
    gateway_inter = net.addDocker('gi', ip='10.0.0.254', dimage="reoc:gateway")
    serveur = net.addDocker('serveur', ip='10.0.0.200', dimage="reoc:server")

    # Creating links between switches and hosts
    net.addLink(s1, z1)
    net.addLink(s1, z2)
    net.addLink(s1, z3)
    net.addLink(s2, s1, intfName1='s2-s1', intfName2='s1-s2')
    net.addLink(s2, ordonnanceur)
    net.addLink(s2, gateway_inter)
    net.addLink(s3, s2, intfName1='s3-s2', intfName2='s2-s3')
    net.addLink(s3, serveur)

    # Adding datacenter and API endpoints
    dc1 = net.addDatacenter("dc1")
    api1 = OpenstackApiEndpoint("0.0.0.0", 6001)
    api1.connect_datacenter(dc1)
    api1.start()
    api1.connect_dc_network(net)

    rapi1 = RestApiEndpoint("0.0.0.0", 5001)
    rapi1.connectDCNetwork(net)
    rapi1.connectDatacenter(dc1)
    rapi1.start()

    # Starting the network
    net.start()
    net.CLI()
    net.stop()

if __name__ == '__main__':
    setup_topology()

5.2 Instances Docker

Nous avons utilise Docker pour creer des instances pour chaque composant reseau. Un script a ete developpe pour construire les images Docker et generer les instances de maniere efficace. Cette configuration a facilite les tests de connectivite et de transmission de donnees entre les differentes zones.

#!/bin/bash
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
cd "$SCRIPT_DIR" || exit 1
for dockerfile in "$SCRIPT_DIR"/*.dockerfile; do
    image_tag="reoc:$(basename "$dockerfile" .dockerfile)"
    echo "Building image: $image_tag from $dockerfile"
    docker build -t "$image_tag" -f "$dockerfile" .
done

5.3 Simulation avec Containernet

J'ai utilise Containernet, un fork de Mininet, pour simuler la topologie reseau. Cela impliquait la creation et la gestion des liens reseau, et la verification de la connectivite entre les instances Docker.

Une fois le script topology_sdn.py lance, j'ai teste la connectivite entre les differents hotes de la topologie :

containernet> z1 ping -c 1 z2
containernet> z1 ping -c 1 serveur
containernet> z2 ping -c 1 z1
containernet> z2 ping -c 1 gi
containernet> ordon ping -c 1 z3
containernet> ordon ping -c 1 serveur

5.4 Application 'Moniteur'

Monitoring

L'interface de monitoring, developpee avec npyscreen, permettait aux utilisateurs de selectionner et d'executer differents scripts en fonction des tests souhaites. Pour surveiller les donnees envoyees par chaque zone, nous nous concentrions sur le commutateur S1. En appelant l'API Ryu, nous pouvions observer des metriques telles que le trafic entrant et sortant, la taille des paquets et le total d'octets en temps reel.

Figure : Interface de monitoring du trafic reseau

Adaptation

Les scenarios d'adaptation incluaient le blocage des trames de Z2 et Z3 ou la reduction de leur bande passante tout en priorisant Z1. Cela etait realise via des requetes POST a l'API Ryu pour appliquer des regles telles que :

{
    "dpid": 1,
    "table_id": 0,
    "priority": 1,
    "match": {
        "in_port": 2
    },
    "instructions": [
        {
            "type": "APPLY_ACTIONS",
            "actions": [
                {
                    "type": "DROP"
                }
            ]
        }
    ]
}

Concepts cles : Containernet, Docker, NFV, MANO, orchestration, monitoring, adaptation, API REST, Ryu.


6. Architecture Modulaire

Le module sur l'Architecture Modulaire traitait de la conception de systemes embarques temps reel, avec un accent particulier sur le Worst-Case Traversal Time (WCTT). Ce concept est fondamental dans les reseaux embarques deterministes, notamment dans l'aeronautique et l'automobile.

Le WCTT represente le temps maximal qu'un paquet peut mettre pour traverser le reseau dans le pire des cas. Le calcul du WCTT est essentiel pour :

  • Garantir le determinisme : s'assurer que chaque message arrive dans les delais impartis
  • Dimensionner les reseaux : choisir les capacites des liens et des commutateurs en fonction des contraintes temporelles
  • Certifier les systemes critiques : fournir des preuves formelles du respect des echeances dans les systemes avioniques

Les methodes d'analyse etudiees incluaient le Network Calculus et les approches par simulation aggregee, permettant d'approximer les bornes du WCTT pour des topologies complexes.

Concepts cles : WCTT, Network Calculus, determinisme, systemes critiques, certification, bornes temporelles.


7. Simulation Avancee avec NetworkX (N7)

Ce module, dispense a l'ENSEEIHT (N7), portait sur la simulation avancee de reseaux en utilisant la bibliotheque Python NetworkX. Le sujet central etait le probleme de consensus dans les reseaux distribues.

Probleme de consensus

L'objectif est que tous les noeuds d'un reseau convergent vers une meme valeur. Chaque noeud est initialise avec une valeur aleatoire, et a chaque cycle, un noeud diffuse sa valeur a ses voisins, qui mettent alors a jour leur propre valeur par moyenne :

while 1 do
    if (time mod T) = 0 then
        broadcast {VAL}
    else if msgReceived(R_VAL) then
        VAL <- (VAL + R_VAL) / 2
    end if
end while

Modelisation matricielle

L'approche mathematique utilisait des matrices de transition pour modeliser l'evolution du systeme. Pour chaque noeud emetteur, une matrice Ei est construite, et le produit de ces matrices sur un cycle donne la matrice de transition globale Pl :

import numpy as np

def create_matrix_Ei(graph, emitter):
    """Creer la matrice Ei pour un noeud emetteur donne."""
    n = len(graph.nodes)
    Ei = np.zeros((n, n))
    for node in graph.nodes:
        if node == emitter:
            Ei[node][node] = 1
        else:
            neighbors = list(graph.neighbors(emitter))
            if node in neighbors:
                Ei[node][node] = 0.5
                Ei[node][emitter] = 0.5
            else:
                Ei[node][node] = 1
    return Ei

def compute_Pl(graph, sequence):
    """Calculer la matrice Pl pour une sequence d'emissions."""
    n = len(graph.nodes)
    Po = np.eye(n)
    for emitter in sequence:
        Ei = create_matrix_Ei(graph, emitter)
        Po = Ei @ Po
    return Po

Resultats de simulation

Les simulations ont ete realisees sur differentes topologies (mesh et ligne) en variant le nombre de noeuds :

TopologieNoeudsCycles moyensEcart-type
Mesh52.40.21
Mesh102.10.26
Ligne52411.17
Ligne106346.8

La correlation entre le plus grand valeur propre de la matrice Pl et le temps de convergence a ete etudiee en generant 1000 sequences aleatoires et en tracant la relation entre ces deux metriques.

Concepts cles : Consensus distribue, NetworkX, matrices de transition, valeurs propres, convergence, topologie reseau.


8. Integrated Modular Avionics (IMA)

Le module Integrated Modular Avionics (IMA) traitait de l'architecture des systemes avioniques modernes. L'IMA est un concept d'architecture informatique dans lequel les ressources de calcul sont partagees entre plusieurs applications avioniques, contrairement a l'approche federee traditionnelle ou chaque fonction dispose de son propre equipement dedie.

Les principes fondamentaux de l'IMA :

  • Partitionnement temporel et spatial : chaque application dispose de creneaux temporels fixes et d'espaces memoire isoles, garantissant l'absence d'interference entre les fonctions
  • Norme ARINC 653 : standard definissant l'interface entre les applications avioniques et le systeme d'exploitation temps reel, assurant la portabilite et l'interchangeabilite
  • AFDX (Avionics Full-Duplex Switched Ethernet) : reseau de communication deterministe utilise pour interconnecter les modules IMA, avec des Virtual Links garantissant des bornes temporelles
  • Certification DO-178C : processus de certification logicielle pour les systemes embarques critiques de l'aeronautique

L'IMA represente une evolution majeure dans l'avionique, permettant de reduire le poids, la consommation energetique et les couts de maintenance des systemes de bord, tout en maintenant les niveaux de securite les plus eleves (DAL A).

Concepts cles : IMA, ARINC 653, AFDX, partitionnement, DO-178C, certification, systemes critiques.


9. Low Power Networks for IoT

Ce module portait sur les reseaux basse consommation pour l'Internet des Objets, avec un focus particulier sur la technologie LoRaWAN. Le cours couvrait les specificites des communications IoT, ou les contraintes de consommation energetique et de cout sont primordiales.

Caracteristiques de l'IoT

Les systemes IoT se distinguent par :

  • Pervasive Computing : dispositifs nombreux, circuits bon marche, memoire et puissance de calcul limitees
  • Connectivite sans fil : alimentation par batterie ou energy harvesting, duree de vie superieure a 10 ans
  • Cout reduit : puce a 2$, abonnement radio a 1$ par dispositif par an
  • Longue portee : 5 a 40 km en champ libre

Pile protocolaire IoT

CoucheStandard
ApplicationIETF CoAP
TransportIETF UDP
AdaptationIETF 6LoWPAN, IETF SCHC
Acces reseauIEEE 802.15.4, LoRaWAN

Travaux pratiques : Simulation LoRaWAN

Les TP consistaient en la simulation d'un deploiement LoRaWAN avec calcul de la couverture par triangulation. L'objectif etait d'evaluer les performances d'un reseau de passerelles LoRa en termes de taux de livraison de paquets (PDR) en fonction de la densite de deploiement et des parametres radio (spreading factor, puissance d'emission).

Un rapport detaille sur le deploiement LoRaWAN et l'analyse par triangulation a ete produit, demontrant l'impact du placement des passerelles sur la couverture et la fiabilite du reseau.

Concepts cles : LoRaWAN, LPWAN, IoT, ALOHA, spreading factor, PDR, energy harvesting, 6LoWPAN, CoAP.


10. Processus Stochastiques

Le module sur les processus stochastiques traitait de la modelisation et de l'evaluation de performances des systemes en file d'attente, un outil fondamental pour l'analyse des reseaux de communication.

Reseaux de files d'attente fermes

Le TP portait sur la simulation et le calcul analytique des performances d'un reseau ferme compose de quatre stations (T, H, R, D) avec N clients circulant en boucle :

def exact_performance_measures(lambdaH, muH, muR, muD, C, N, p):
    # Calcul des taux d'arrivee effectifs
    gamma_H = lambdaH
    gamma_R = gamma_H / p
    gamma_D = (1 - p) * gamma_H / p

    # Calcul des intensites de trafic
    rho_H = gamma_H / muH
    rho_R = gamma_R / (C * muR)
    rho_D = gamma_D / muD

    # Calcul de la constante de normalisation G4(N)
    def calculate_G4(N, rho_H, rho_R, rho_D, C):
        G4 = 0
        for n_T in range(N + 1):
            for n_H in range(N + 1 - n_T):
                for n_R in range(N + 1 - n_T - n_H):
                    n_D = N - n_T - n_H - n_R
                    term = (rho_H**n_H) * (rho_R**n_R / phi_R(n_R, C)) * (rho_D**n_D)
                    G4 += term
        return G4

    G4 = calculate_G4(N, rho_H, rho_R, rho_D, C)
    return G4

Scenarios simules

Plusieurs scenarios ont ete simules en faisant varier les parametres N (nombre de clients) et p (probabilite de routage) :

ScenarioNpDescription
Cas 1150.50Charge moderee, routage equilibre
Cas 2150.22Charge moderee, routage vers le disque dominant
Cas 3300.50Forte charge, routage equilibre
Cas 4300.22Forte charge, routage vers le disque dominant

Les metriques evaluees comprenaient le taux d'utilisation, le debit, le temps de sejour moyen et la probabilite de rejet, calculees a la fois de maniere analytique (loi de Little, distribution stationnaire) et par simulation Monte Carlo.

Concepts cles : Files d'attente, reseaux fermes, loi de Little, chaines de Markov, distribution stationnaire, simulation Monte Carlo, intensite de trafic.


PART D : ANALYSE ET REFLEXION

Competences et connaissances mobilisees

Le Master REOC m'a permis de mobiliser et d'approfondir un ensemble de competences variees :

  • Architecture reseau : comprehension des architectures SDN et NFV, et leur application dans les reseaux embarques et l'orchestration cloud
  • Programmation du data plane : maitrise du langage P4 pour le traitement des paquets au niveau materiel
  • Systemes temps reel : comprehension des contraintes temporelles dans les reseaux embarques critiques (AFDX, IMA, TSN)
  • Simulation et modelisation : utilisation de NetworkX, de simulateurs LoRaWAN et de modeles stochastiques pour l'evaluation de performances
  • Developpement logiciel : programmation Python pour la simulation, l'analyse de donnees et le developpement d'outils de monitoring
  • Travail collaboratif : gestion de projets en binome dans un contexte de double diplome exigeant

Auto-evaluation

Le programme du Master REOC etait intense, d'autant plus que les cours de l'INSA se poursuivaient en parallele. Cependant, cette experience a ete extremement enrichissante car j'ai acquis de nouvelles competences que j'ai pu mettre en oeuvre apres une analyse approfondie des bibliotheques et la comprehension du fonctionnement du SDN. Grace a mon partenaire, Yohan Boujon, notre collaboration etait efficace car nous nous connaissions bien et avons developpe la quasi-totalite de ce qui etait demande dans le temps imparti lors des travaux pratiques.

Mon avis

Si je devais choisir a nouveau, je m'inscrirais sans hesitation au Master REOC. Le programme m'a permis d'elargir ma vision des reseaux dans les systemes embarques et d'acquerir une experience precieuse. Les enseignants ont fourni des bases solides pour comprendre tous les concepts applicables dans le monde professionnel. Les competences acquises seront utiles pour ma carriere. Ce programme a significativement contribue a ma croissance professionnelle et m'a prepare aux defis futurs dans le domaine des systemes en reseau.

La diversite des modules -- de l'avionique deterministe a l'IoT basse consommation, en passant par la virtualisation et la modelisation stochastique -- offre une vision panoramique des enjeux actuels des reseaux embarques. Cette polyvalence est un atout majeur pour aborder les problematiques industrielles complexes qui melent souvent plusieurs de ces domaines.


Rapports et Projets

Rapport du Projet SDCI

Le rapport complet du projet SDCI est disponible sur GitHub - sdci-reoc.

Ouvrir le rapport complet du projet SDCI

Ouvrir le sujet du TP

Rapport sur les Processus Stochastiques

Ouvrir le rapport sur les processus stochastiques


Cours suivi en 2024-2025 dans le cadre du double diplome INSA Toulouse / ENSEEIHT, Master 2 REOC.

Master 2 REOC - Networks and Connected Objects

PART A: GENERAL PRESENTATION

Presentation of the Master REOC

The Master 2 REOC (Reseaux et Objets Connectes / Networks and Connected Objects) is a program offered at ENSEEIHT (Ecole Nationale Superieure d'Electrotechnique, d'Electronique, d'Informatique, d'Hydraulique et des Telecommunications) in Toulouse, as part of a dual degree with INSA Toulouse. This program is part of semester S9 of the 2024-2025 academic year.

This intensive program covers a broad spectrum of technologies related to embedded networks and connected objects. It provides an in-depth understanding of modern network architectures, ranging from network virtualization (SDN, NFV) to real-time networks for aeronautics (AFDX, IMA), including low-throughput networks for IoT (LoRaWAN) and stochastic processes applied to performance evaluation.

The curriculum is organized into about ten complementary modules that cover both theoretical and practical aspects of embedded networked systems. The teaching approach combines lectures, lab sessions and real-world project assignments.

Training objectives

  • Design and deploy virtualized network architectures (SDN/NFV)
  • Understand and implement real-time communication protocols for critical embedded systems
  • Evaluate network performance through simulation and stochastic modeling
  • Master low-throughput communication technologies for the Internet of Things
  • Understand integrated modular architectures for avionics

PART B: EXPERIENCE AND CONTEXT

Environment and context

The Master REOC immersed me in a demanding academic environment at ENSEEIHT in Toulouse, alongside my courses at INSA. This dual program required strong organizational and adaptation skills. Lab sessions were carried out on various platforms: virtualized environments with Docker and Containernet, P4 programming for the data plane, LoRaWAN simulators in Python, and network simulation tools with NetworkX.

The context was one of complete immersion in current networking challenges: how to virtualize network functions, how to guarantee determinism in embedded communications, how to optimize IoT network performance at scale, and how to mathematically model the behavior of queuing systems.

My role and responsibilities

  • Network architecture design: setting up SDN topologies with Containernet, deploying Docker containers to simulate network equipment
  • Data plane programming: implementing parsers and match-action tables in P4 language for AFDX processing
  • Monitoring tool development: creating traffic monitoring and adaptation interfaces via SDN controller APIs (Ryu)
  • Simulation and performance evaluation: network modeling with NetworkX, LoRaWAN deployment simulation, and performance metric computation through stochastic processes
  • Technical report writing: detailed documentation of completed projects, notably the SDCI project and the stochastic processes report

Collaboration

Most projects were carried out in pairs with Yohan Boujon, a trusted partner with whom collaboration was smooth and efficient. Our complementary skills allowed us to successfully complete lab work within the given deadlines, despite the substantial workload associated with the dual degree.


PART C: TECHNICAL ASPECTS

This section details the various modules of the Master REOC, covering the theoretical and practical aspects of each topic addressed.


1. Embedded Network Virtualization and P4

This module covered network virtualization in an embedded context, with a focus on the AFDX protocol (Avionics Full-Duplex Switched Ethernet) used in aeronautics. The objective was to understand how to program the data plane of a network switch using the P4 language (Programming Protocol-Independent Packet Processors).

The lab session focused on implementing an AFDX switch in P4, where frames are routed based on their Virtual Link (VL). Here is the AFDX frame structure defined in P4:

header_type afdx_frame_t {
  fields {
  	const: 32;
  	vl: 16;
  	source: 48;
  	type: 16;
  }
}

header afdx_frame_t afdx_frame;

parser start {
       return parse_afdx_frame;
}

parser parse_afdx_frame {
	extract(afdx_frame);
	return select(afdx_frame.const) {
		0x03000000: ingress;
	}
}

table table_afdx{
	reads{
		afdx_frame.vl : exact;
	}
	actions{
		compute_afdx;
		_drop;
	}
}

action compute_afdx(port){
	modify_field(standard_metadata.egress_spec, port);
}

The topology was simulated with Mininet and the P4 behavioral model switch, allowing testing of AFDX frame routing according to configured Virtual Links.

Key concepts: Programmable data plane, AFDX, Virtual Links, P4, Mininet, SDN for embedded systems, Time-Sensitive Networking (TSN).


2. Information Centric Networking (ICN/NDN)

The Information Centric Networking (ICN) module, and more specifically the Named Data Networking (NDN) paradigm, offered a radically different vision of networking compared to the traditional IP model. Instead of connecting machines to each other, NDN focuses communications on the data itself: rather than asking "connect me to this machine", one asks "give me this content".

The fundamental principles studied:

  • Interest / Data: the consumer sends an "Interest" packet carrying the name of the desired content, and the network delivers a "Data" packet in response
  • Content Store (CS): each network node can cache traversing data, enabling future requests to be served locally
  • Pending Interest Table (PIT): a table that records unsatisfied Interest packets and the interfaces through which they arrived
  • Forwarding Information Base (FIB): the equivalent of a routing table, but based on content names

This paradigm presents significant advantages for embedded and IoT networks: latency reduction through distributed caching, native mobility of producers and consumers, and data-level built-in security (each Data packet is signed by the producer).

Key concepts: NDN, ICN, Content Store, PIT, FIB, name-based routing, distributed cache, data-centric security.


3. Software Defined Networking (SDN) - INSA

The SDN module at INSA deepened the concepts of separation between the control plane and the data plane in networks. The course covered SDN architectures, the OpenFlow protocol, and the use of SDN controllers such as Ryu to program network behavior in a centralized manner.

The lab sessions focused on setting up a complete SDN architecture with:

  • Configuration of network topologies with OpenFlow switches
  • Programming flow rules via the Ryu controller
  • Implementation of routing and traffic filtering policies
  • Real-time network behavior analysis

Key concepts: OpenFlow, SDN controller, Ryu, centralized control plane, flow rules, QoS, network slicing.


4. Wireless Real-Time Networking

This module addressed wireless real-time networks, a topic essential for critical embedded systems in the fields of Industrial IoT (IIoT) and aeronautics. The course covered protocols and mechanisms for guaranteeing deterministic communications over inherently non-deterministic wireless media.

Topics covered included:

  • Embedded real-time networks: latency, jitter and reliability constraints
  • Ad Hoc Networks: distributed routing protocols for infrastructure-less networks
  • IIoT (Industrial Internet of Things): application of real-time networks to the industrial context, with safety and security constraints
  • Wireless Sensor and Actuator Networks (WSAN): communication protocols for sensor-actuator networks

Studying recent research papers helped understand current challenges: how to reconcile real-time requirements with radio channel uncertainties, how to dimension a wireless network to guarantee a minimum delivery rate, and how to integrate these networks into existing industrial architectures.

Key concepts: Determinism, bounded latency, ad hoc networks, TDMA, scheduling, IIoT, WSAN.


5. NFV/SDCI Project

The NFV/SDCI (Network Function Virtualization / Software Defined Cloud Infrastructure) project was the major project of the Master REOC. Carried out in pairs with Yohan Boujon, this project combined SDN and NFV to design a complete virtualized network infrastructure with orchestration.

5.1 Network architecture

We designed a network topology consisting of multiple switches and hosts to simulate a complex network environment. The topology included components such as switches (S1, S2, S3), hosts (Z1, Z2, Z3), an intermediate gateway (GI) and a server. This configuration allowed us to test data filtering and connectivity between network components.

Figure: SDCI project network topology

def setup_topology():
    net = DCNetwork(monitor=False, enable_learning=True)

    # Adding switches
    s1 = net.addSwitch('s1')
    s2 = net.addSwitch('s2')
    s3 = net.addSwitch('s3')

    # Adding Docker containers as network hosts
    z1 = net.addDocker('z1', ip='10.0.0.1', dimage="reoc:device")
    z2 = net.addDocker('z2', ip='10.0.0.2', dimage="reoc:device")
    z3 = net.addDocker('z3', ip='10.0.0.3', dimage="reoc:device")

    ordonnanceur = net.addDocker('ordon', ip='10.0.0.100', dimage="reoc:test")
    gateway_inter = net.addDocker('gi', ip='10.0.0.254', dimage="reoc:gateway")
    serveur = net.addDocker('serveur', ip='10.0.0.200', dimage="reoc:server")

    # Creating links between switches and hosts
    net.addLink(s1, z1)
    net.addLink(s1, z2)
    net.addLink(s1, z3)
    net.addLink(s2, s1, intfName1='s2-s1', intfName2='s1-s2')
    net.addLink(s2, ordonnanceur)
    net.addLink(s2, gateway_inter)
    net.addLink(s3, s2, intfName1='s3-s2', intfName2='s2-s3')
    net.addLink(s3, serveur)

    # Adding datacenter and API endpoints
    dc1 = net.addDatacenter("dc1")
    api1 = OpenstackApiEndpoint("0.0.0.0", 6001)
    api1.connect_datacenter(dc1)
    api1.start()
    api1.connect_dc_network(net)

    rapi1 = RestApiEndpoint("0.0.0.0", 5001)
    rapi1.connectDCNetwork(net)
    rapi1.connectDatacenter(dc1)
    rapi1.start()

    # Starting the network
    net.start()
    net.CLI()
    net.stop()

if __name__ == '__main__':
    setup_topology()

5.2 Docker instances

We used Docker to create instances for each network component. A script was developed to build Docker images and generate instances efficiently. This setup facilitated connectivity and data transmission testing between the different zones.

#!/bin/bash
SCRIPT_PATH=$(realpath "$0")
SCRIPT_DIR=$(dirname "$SCRIPT_PATH")
cd "$SCRIPT_DIR" || exit 1
for dockerfile in "$SCRIPT_DIR"/*.dockerfile; do
    image_tag="reoc:$(basename "$dockerfile" .dockerfile)"
    echo "Building image: $image_tag from $dockerfile"
    docker build -t "$image_tag" -f "$dockerfile" .
done

5.3 Simulation with Containernet

I used Containernet, a Mininet fork, to simulate the network topology. This involved creating and managing network links, and verifying connectivity between Docker instances.

Once the topology_sdn.py script was launched, I tested connectivity between the different hosts in the topology:

containernet> z1 ping -c 1 z2
containernet> z1 ping -c 1 serveur
containernet> z2 ping -c 1 z1
containernet> z2 ping -c 1 gi
containernet> ordon ping -c 1 z3
containernet> ordon ping -c 1 serveur

5.4 'Monitor' application

Monitoring

The monitoring interface, developed with npyscreen, allowed users to select and run different scripts based on the desired tests. To monitor the data sent by each zone, we focused on switch S1. By calling the Ryu API, we could observe metrics such as incoming and outgoing traffic, packet size and total bytes in real time.

Figure: Network traffic monitoring interface

Adaptation

Adaptation scenarios included blocking frames from Z2 and Z3 or reducing their bandwidth while prioritizing Z1. This was achieved via POST requests to the Ryu API to apply rules such as:

{
    "dpid": 1,
    "table_id": 0,
    "priority": 1,
    "match": {
        "in_port": 2
    },
    "instructions": [
        {
            "type": "APPLY_ACTIONS",
            "actions": [
                {
                    "type": "DROP"
                }
            ]
        }
    ]
}

Key concepts: Containernet, Docker, NFV, MANO, orchestration, monitoring, adaptation, REST API, Ryu.


6. Modular Architecture

The Modular Architecture module dealt with the design of real-time embedded systems, with a particular emphasis on Worst-Case Traversal Time (WCTT). This concept is fundamental in deterministic embedded networks, particularly in aeronautics and automotive.

WCTT represents the maximum time a packet can take to traverse the network in the worst case. Computing the WCTT is essential for:

  • Guaranteeing determinism: ensuring that every message arrives within the prescribed deadlines
  • Sizing networks: choosing link and switch capacities based on timing constraints
  • Certifying critical systems: providing formal proof of deadline compliance in avionics systems

The analysis methods studied included Network Calculus and aggregate simulation approaches, allowing approximation of WCTT bounds for complex topologies.

Key concepts: WCTT, Network Calculus, determinism, critical systems, certification, timing bounds.


7. Advanced Simulation with NetworkX (N7)

This module, taught at ENSEEIHT (N7), focused on advanced network simulation using the Python NetworkX library. The central topic was the consensus problem in distributed networks.

Consensus problem

The goal is for all nodes in a network to converge to the same value. Each node is initialized with a random value, and at each cycle, a node broadcasts its value to its neighbors, which then update their own value by averaging:

while 1 do
    if (time mod T) = 0 then
        broadcast {VAL}
    else if msgReceived(R_VAL) then
        VAL <- (VAL + R_VAL) / 2
    end if
end while

Matrix modeling

The mathematical approach used transition matrices to model the system's evolution. For each emitting node, a matrix Ei is constructed, and the product of these matrices over one cycle yields the global transition matrix Pl:

import numpy as np

def create_matrix_Ei(graph, emitter):
    """Create the Ei matrix for a given emitting node."""
    n = len(graph.nodes)
    Ei = np.zeros((n, n))
    for node in graph.nodes:
        if node == emitter:
            Ei[node][node] = 1
        else:
            neighbors = list(graph.neighbors(emitter))
            if node in neighbors:
                Ei[node][node] = 0.5
                Ei[node][emitter] = 0.5
            else:
                Ei[node][node] = 1
    return Ei

def compute_Pl(graph, sequence):
    """Compute the Pl matrix for a given emission sequence."""
    n = len(graph.nodes)
    Po = np.eye(n)
    for emitter in sequence:
        Ei = create_matrix_Ei(graph, emitter)
        Po = Ei @ Po
    return Po

Simulation results

Simulations were carried out on different topologies (mesh and line) with varying numbers of nodes:

TopologyNodesAverage cyclesStandard deviation
Mesh52.40.21
Mesh102.10.26
Line52411.17
Line106346.8

The correlation between the largest eigenvalue of the Pl matrix and the convergence time was studied by generating 1000 random sequences and plotting the relationship between these two metrics.

Key concepts: Distributed consensus, NetworkX, transition matrices, eigenvalues, convergence, network topology.


8. Integrated Modular Avionics (IMA)

The Integrated Modular Avionics (IMA) module covered the architecture of modern avionics systems. IMA is a computing architecture concept in which computing resources are shared among multiple avionics applications, in contrast to the traditional federated approach where each function has its own dedicated equipment.

The fundamental principles of IMA:

  • Temporal and spatial partitioning: each application has fixed time slots and isolated memory spaces, guaranteeing no interference between functions
  • ARINC 653 standard: a standard defining the interface between avionics applications and the real-time operating system, ensuring portability and interchangeability
  • AFDX (Avionics Full-Duplex Switched Ethernet): a deterministic communication network used to interconnect IMA modules, with Virtual Links guaranteeing timing bounds
  • DO-178C certification: software certification process for critical embedded systems in aeronautics

IMA represents a major evolution in avionics, enabling reduced weight, power consumption and maintenance costs for onboard systems, while maintaining the highest safety levels (DAL A).

Key concepts: IMA, ARINC 653, AFDX, partitioning, DO-178C, certification, critical systems.


9. Low Power Networks for IoT

This module focused on low-power networks for the Internet of Things, with a particular focus on LoRaWAN technology. The course covered the specifics of IoT communications, where energy consumption and cost constraints are paramount.

IoT characteristics

IoT systems are distinguished by:

  • Pervasive Computing: numerous devices, low-cost circuits, limited memory and computing power
  • Wireless connectivity: battery-powered or energy harvesting, lifetime exceeding 10 years
  • Reduced cost: $2 chip, $1 radio subscription per device per year
  • Long range: 5 to 40 km in open field

IoT protocol stack

LayerStandard
ApplicationIETF CoAP
TransportIETF UDP
AdaptationIETF 6LoWPAN, IETF SCHC
Network accessIEEE 802.15.4, LoRaWAN

Lab sessions: LoRaWAN simulation

The lab sessions consisted of simulating a LoRaWAN deployment with coverage calculation through triangulation. The objective was to evaluate the performance of a LoRa gateway network in terms of Packet Delivery Rate (PDR) based on deployment density and radio parameters (spreading factor, transmission power).

A detailed report on LoRaWAN deployment and triangulation analysis was produced, demonstrating the impact of gateway placement on network coverage and reliability.

Key concepts: LoRaWAN, LPWAN, IoT, ALOHA, spreading factor, PDR, energy harvesting, 6LoWPAN, CoAP.


10. Stochastic Processes

The stochastic processes module dealt with modeling and performance evaluation of queuing systems, a fundamental tool for the analysis of communication networks.

Closed queuing networks

The lab session focused on simulation and analytical computation of the performance of a closed network composed of four stations (T, H, R, D) with N clients circulating in a loop:

def exact_performance_measures(lambdaH, muH, muR, muD, C, N, p):
    # Compute effective arrival rates
    gamma_H = lambdaH
    gamma_R = gamma_H / p
    gamma_D = (1 - p) * gamma_H / p

    # Compute traffic intensities
    rho_H = gamma_H / muH
    rho_R = gamma_R / (C * muR)
    rho_D = gamma_D / muD

    # Compute normalization constant G4(N)
    def calculate_G4(N, rho_H, rho_R, rho_D, C):
        G4 = 0
        for n_T in range(N + 1):
            for n_H in range(N + 1 - n_T):
                for n_R in range(N + 1 - n_T - n_H):
                    n_D = N - n_T - n_H - n_R
                    term = (rho_H**n_H) * (rho_R**n_R / phi_R(n_R, C)) * (rho_D**n_D)
                    G4 += term
        return G4

    G4 = calculate_G4(N, rho_H, rho_R, rho_D, C)
    return G4

Simulated scenarios

Several scenarios were simulated by varying the parameters N (number of clients) and p (routing probability):

ScenarioNpDescription
Case 1150.50Moderate load, balanced routing
Case 2150.22Moderate load, disk-dominant routing
Case 3300.50Heavy load, balanced routing
Case 4300.22Heavy load, disk-dominant routing

The evaluated metrics included utilization rate, throughput, average sojourn time and rejection probability, computed both analytically (Little's law, stationary distribution) and via Monte Carlo simulation.

Key concepts: Queuing theory, closed networks, Little's law, Markov chains, stationary distribution, Monte Carlo simulation, traffic intensity.


PART D: ANALYSIS AND REFLECTION

Skills and knowledge mobilized

The Master REOC enabled me to mobilize and deepen a diverse set of skills:

  • Network architecture: understanding of SDN and NFV architectures and their application in embedded networks and cloud orchestration
  • Data plane programming: mastery of the P4 language for hardware-level packet processing
  • Real-time systems: understanding of timing constraints in critical embedded networks (AFDX, IMA, TSN)
  • Simulation and modeling: use of NetworkX, LoRaWAN simulators and stochastic models for performance evaluation
  • Software development: Python programming for simulation, data analysis and monitoring tool development
  • Collaborative work: project management in pairs within a demanding dual-degree context

Self-assessment

The Master REOC program was intense, especially since INSA courses continued in parallel. However, this experience was extremely enriching as I acquired new skills that I was able to apply after thorough analysis of libraries and understanding of SDN operations. Thanks to my partner, Yohan Boujon, our collaboration was efficient because we knew each other well and developed almost everything that was required within the allotted time during lab sessions.

My opinion

If I had to choose again, I would enroll in the Master REOC without hesitation. The program allowed me to broaden my vision of networking in embedded systems and gain valuable experience. The instructors provided solid foundations for understanding all concepts applicable in the professional world. The skills acquired will be useful for my career. This program significantly contributed to my professional growth and prepared me for future challenges in the field of networked systems.

The diversity of modules -- from deterministic avionics to low-power IoT, through virtualization and stochastic modeling -- provides a panoramic view of the current challenges in embedded networks. This versatility is a major asset for tackling complex industrial problems that often span multiple domains.


Reports and Projects

SDCI Project Report

The full SDCI project report is available on GitHub - sdci-reoc.

Open the full SDCI project report

Open the lab subject

Stochastic Processes Report

Open the stochastic processes report


Course taken in 2024-2025 as part of the dual degree INSA Toulouse / ENSEEIHT, Master 2 REOC.