Partie 1: Généralités et Architecture des Systèmes Embarqués

1. Définitions et Caractéristiques:
o Expliquez en détail les caractéristiques clés d'un système embarqué. Quels sont
les principaux défis liés à la conception de systèmes embarqués?
o Comparez les architectures RISC et CISC, en mettant en avant leurs avantages et
inconvénients dans le contexte des systèmes embarqués.
2. Systèmes Temps Réel:
o Définissez ce qu'est un système temps réel. Donnez des exemples d'applications
nécessitant des systèmes temps réel et discutez des contraintes associées.
o Expliquez les différences entre les systèmes temps réel mou et les systèmes temps
réel dur. Comment pouvez-vous garantir la gestion des contraintes temporelles
dans un système embarqué?

Partie 2: Programmation Multi-Processus en C

Exercice 1: Version Distribuée du Tri Fusion

Considérons un système embarqué distribué composé de quatre processeurs. L'objectif est de

réaliser une version distribuée du tri fusion en utilisant des processus pour chaque processeur. Le
programme doit être écrit en langage C.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

void merge(int arr[], int left, int mid, int right) {

// À compléter
}

void mergeSort(int arr[], int left, int right) {

// À compléter
}

int main() {
int arr[] = {12, 11, 13, 5, 6, 7, 3, 9, 10, 2, 1, 8, 4};
int n = sizeof(arr) / sizeof(arr[0]);

// Créez un processus fils pour chaque processeur

pid_t pid1, pid2, pid3;

// Divisez le tableau en quatre parties

int mid1 = n / 4;
int mid2 = mid1 * 2;
int mid3 = mid1 * 3;

// Utilisez l'appel système fork()

if (pid1 == 0) {
// Processus fils 1 - tri de la première partie
 // À compléter
} else if (pid2 == 0) {
// Processus fils 2 - tri de la deuxième partie
// À compléter
} else if (pid3 == 0) {
// Processus fils 3 - tri de la troisième partie
// À compléter
} else {
// Processus père - tri de la quatrième partie
// À compléter

// Attendez que tous les processus fils aient terminé avant la fusion
waitpid(pid1, NULL, 0);
waitpid(pid2, NULL, 0);
waitpid(pid3, NULL, 0);

// Fusionnez les quatre parties triées

// À compléter
}

// Affichez le tableau trié

printf("Tableau trié : ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");

return 0;
}

a. Complétez le programme C pour fonctionner avec quatre processeurs

b. Modifiez le programme pour qu'il utilise des threads au lieu de processus pour réaliser le tri
fusion.

Exercice 2: Gestion de la Mémoire Partagée

Considérez un système embarqué avec un espace de mémoire partagée entre plusieurs processus.
Implémentez un programme en C qui utilise la mémoire partagée pour permettre la
communication et la synchronisation entre deux processus.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/wait.h>

int main() {
// Créez une clé pour la mémoire partagée
key_t key = ftok("shmfile", 65);

// Créez un segment de mémoire partagée

int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
 // Attachez le segment de mémoire partagée au processus
int* shared_memory = (int*)shmat(shmid, (void*)0, 0);

// ... (code à compléter)

// Détachez le segment de mémoire partagée du processus

shmdt(shared_memory);

// Supprimez le segment de mémoire partagée

shmctl(shmid, IPC_RMID, NULL);

return 0;
}

a. Utilisez les appels système IPC (Inter-Process Communication) appropriés pour créer et gérer
la mémoire partagée.

b. Assurez-vous que les processus peuvent partager des informations et synchroniser leur
exécution à l'aide de la mémoire partagée.

Exercice 3: Ordonnancement Temps Réel

Supposons que vous ayez une liste de tâches à effectuer dans un système temps réel. Chaque
tâche a une durée d'exécution et une échéance à respecter. Implémentez un algorithme
d'ordonnancement pour garantir que toutes les tâches respectent leurs échéances. Choisissez un
algorithme d'ordonnancement temps réel approprié (par exemple, Rate Monotonic Scheduling) et
implémentez-le en utilisant des threads ou des processus pour représenter les différentes tâches.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// À compléter

int main() {
// ... (code à compléter)

return 0;
}

Partie 3: Applications Pratiques

1. Système Embarqué dans l'Industrie:

o Choisissez une application industrielle qui utilise des systèmes embarqués (par
exemple, un système de contrôle dans une usine).
o Expliquez comment les caractéristiques des systèmes embarqués sont exploitées
dans cette application spécifique.
o Discutez des défis potentiels liés à cette mise en œuvre.
2. Optimisation du Code:
 o Donnez une portion de code C représentant une opération critique dans un
système embarqué.
o Proposez des améliorations pour optimiser le code en termes de temps d'exécution
et d'utilisation de la mémoire.

Remarques:

• Les réponses doivent être claires, détaillées et correctement documentées.

• La compréhension approfondie des concepts théoriques ainsi que la capacité à appliquer
ces concepts dans des scénarios pratiques seront évaluées.