L'introduction des systèmes embarqués dans l'automobile à commandes électriques (X-by-Wire) pose des problèmes nouveaux et spécifiques pour la tenue des exigences de sûreté de fonctionnement. En effet, ils sont dépourvus de la redondance mécanique (barre de direction, circuit hydraulique...) capable d'offrir un service minimum en cas de dysfonctionnement important de l'électronique. Ces systèmes largement distribués sont particulièrement sensibles aux perturbations d'ordre électromagnétique, et chaque faute transitoire peut éventuellement être la cause d'une défaillance catastrophique.<br />Dans ce contexte, le travail présenté ici est d'ordre méthodologique. En particulier, nous proposons une méthode de vérification des contraintes temps réel en mode nominal (mode non perturbé), et une méthode de prévision quantitative de fautes (mode perturbé) dont l'objectif est de mesurer l'influence des fautes transitoires liées à l'environnement et des performances temps réel du système sur la sûreté (probabilité d'occurrences de défaillances catastrophiques par zone perturbée) de ce même système. Nos travaux ont été appliqués sur les systèmes de direction Steer-by-Wire, mais les méthodes d'évaluation proposées sont génériques. Pour l'instant, seule des préconisations internes aux entreprises sont ciblées. Ainsi, une exigence dont la garantie devrait être prouvée est, par exemple : la probabilité de défaillance catastrophique doit être inférieure à 1.10-9 par heure de fonctionnement. Grâce à la méthode que nous avons développée, cette garantie sera alors complétée par l'évaluation de la fiabilité comportementale du système. Fournissant des résultats quantitatifs, cette technique permet de réaliser plusieurs études de sensitivité, comme, par exemple, l'influence de la durée du cycle de communication sur un protocole de communication de type TDMA (Time Division Multiple Access), l'influence de la diversification dans la redondance des sous-systèmes, ou encore l'influence d'un mécanisme de tolérance aux fautes proposé par TTP/C et FlexRay.

À l'heure actuelle, les dispositifs embarqués regroupent une grande variété d'applications, ayant des fonctionnalités complexes et demandant une puissance de calcul de plus en plus importante. Ils évoluent actuellement de systèmes multiprocesseur sur puce vers des architectures many-core et posent de nouveaux défis au développement de logiciel embarqué. En effet, Il a classiquement été guidé par les performances et donc par les besoins spécifiques des plates-formes. Or, cette approche s'avère trop couteuse avec les nouvelles architectures matérielles et leurs évolutions rapprochées. Actuellement, il n'y a pas un consensus sur les environnements à utiliser pour programmer les nouvelles architectures embarquées. Afin de permettre une programmation plus rapide du logiciel embarqué, la chaîne de développement a besoin d'outils pour la mise au point des applications. Cette mise au point s'appuie sur des techniques d'observation, qui consistent à recueillir des informations sur le comportement du système embarqué pendant l'exécution. Les techniques d'observation actuelles ne supportent qu'un nombre limité de processeurs et sont fortement dépendantes des caractéristiques matérielles. Dans cette thèse, nous proposons EMBera~: une approche à base de composants pour l'observation de systèmes multiprocesseurs sur puce. EMBera vise la généricité, la portabilité, l'observation d'un grand nombre d'éléments, ainsi que le contrôle de l'intrusion. La généricité est obtenue par l'encapsulation de fonctionnalités spécifiques et l'exportation d'interfaces génériques d'observation. La portabilité est possible grâce à des composants qui, d'une part, ciblent des traitements communs aux MPSoCs, et d'autre part, permettent d'être adaptés aux spécificités des plates-formes. Le passage à l'échelle est réussi en permettant une observation partielle d'un système en se concentrant uniquement sur les éléments d'intérêt~: les modules applicatifs, les composants matériels ou les différents niveaux de la pile logicielle. Le contrôle de l'intrusion est facilité par la possibilité de configurer le type et le niveau de détail des mécanismes de collecte de données. L'approche est validée par le biais de différentes études de cas qui utilisent plusieurs configurations matérielles et logicielles. Nous montrons que cette approche offre une vraie valeur ajoutée dans le support du développement de logiciels embarqués.

Dans cette thèse, Nous présentons différents aspects d'attaques physiques sur les implémentations cryptographiques de l'algorithme de chiffrement AES, ainsi qu'une étude sur les contre-mesures possibles. La première méthode d'injection utilisée est basée sur la violation temps de setup. Nous avons démontré pour la première fois que cette méthode globale permet l'injection de fautes exploitables dans les circuits cryptographiques ASIC et FPGA . On a également réalisé une attaque locale sur un microprocesseur ATmega128 en utilisant un laser. Nous présentons aussi dans cette thèse, une nouvelle approche pour contré les attaque en fautes basé sur la résilience. La résilience n'impose aucune destruction des secrets dans le cas d'une attaque en faute. Dans une implémentation protégée par résilience, quand une faute est injecté avec succès mais n'a pas de conséquence dans le calcul, le circuit ne présente aucune réaction par contre si le circuit est protégé par un système de détection arrête automatiquement le calcul même si la faute n'a pas d'effet. Dans une implémentation résilience même si la faute est injectée lors du calcul l'attaquant ne peut pas exploiter le résultat a fin d'exécuter une attaque DFA. Plusieurs méthodes concrètes pour mettre en oeuvre la résilience pour les chiffrements symétriques sont proposées, parmi lesquelles un mode aléatoire de fonctionnement qui convient pour des cartes à puce a faible coût. Nous proposons d'utiliser les logiques DPL comme méthode de protection. Ces logiques protègent simultanément contre les attaques par observation et par perturbation, et sont moins coûteux que la détection basée sur les codes.

Les travaux présentés dans cette thèse portent sur le prototypage virtuel des systèmes embarqués hétérogènes. La complexité des systèmes embarqués fait qu'il est difficile de trouver une solution optimale. Ainsi, les approches adoptées par les ingénieurs reposent sur la simulation qui requiert le prototypage virtuel. L'intérêt du prototypage virtuel est de fournir des modèles exécutables de systèmes embarqués afin de les étudier du point de vue fonctionnel et non-fonctionnel. Notre contribution consiste en la définition d'une nouvelle approche à composants pour le prototypage virtuel des systèmes embarqués, appelé 42. 42 n'est pas un nouveau langage pour le développement des systèmes embarqués, mais plutôt un outil pour la description et l'assemblage de composants pour les systèmes embarqués, au niveau système. Un modèle pour le prototypage virtuel des systèmes embarqués doit prendre en compte leur hétérogénéité. Des approches comme Ptolemy proposent un catalogue de MoCCs (Models of Computation and Communication) qui peuvent être organisés en hiérarchie afin de modéliser l'hétérogénéité. 42 s'inspire de Ptolemy dans l'organisation hiérarchique de composants et de MoCCs. Cependant, les MoCCs dans 42 ne sont pas fournis sous forme de catalogue, ils sont décrits par des programmes qui manipulent un petit ensemble de primitives de base pour activer les composants et gérer les communications entre eux. Une approche à composants comme 42 requiert un formalisme de spécification de composants. Nous étudierons les moyens proposés par 42 pour décrire les composants. Nous nous intéresseront particulièrement aux contrats de contrôle de 42. 42 est indépendant de tout langage ou formalisme. Il est conçu dans l'optique d'être utilisé conjointement avec les approches existantes. Nous donnerons une preuve de concept afin de montrer l'intérêt d'utiliser 42 et les contrats de contrôle associés aux composants, conjointement avec des approches existantes.

Nowadays, computer systems are everywhere. From simple portable devices such as watches and MP3 players to large stationary installations that control nuclear power plants, computer systems are now present in all aspects of our modern and every-day life. In about only 70 years, they have completely perturbed our way of life and they reached a so high degree of sophistication that they will be soon capable of driving our cars and cleaning our houses without any human intervention. As computer systems gain in responsibilities, it becomes essential that they provide both safety and reliability. Indeed, a failure in systems such as the anti-lock braking system (ABS) in cars could threaten human lives and generate catastrophic and irreversible consequences. Hence, for many years, researchers have addressed these emerging problems of system safety and reliability which come along with this fulgurant evolution. This thesis provides a general overview of embedded real-time computer systems, i.e., a particular kind of computer system whose number grows daily. We provide the reader with some preliminary knowledge and a good understanding of the concepts that underlie this emerging technology. We focus especially on the theoretical problems related to the real-time issue and briefly summarizes the main solutions, together with their advantages and drawbacks. This brings the reader through all the conceptual layers constituting a computer system, from the software level---the logical part---that specifies both the system behavior and requirements to the hardware level---the physical part---that actually performs the expected treatments and reacts to the environment. In the meanwhile, we introduce the theoretical models that allow researchers for theoretical analyses which ensure that all the system requirements are fulfilled. Finally, we address the energy consumption problem in embedded systems. We describe the various factors of power dissipation in modern technologies and we introduce different solutions to reduce this consumption./Cette thèse se focalise sur un type de systèmes informatiques bien précis appelés “systèmes embarqués temps réel”. Un système est dit “embarqué” lorsqu’il est développé afin de servir un but bien précis. Un téléphone portable est un parfait exemple de système embarqué étant donné que toutes ses fonctionnalités sont rigoureusement définies avant même sa conception. Au contraire, un ordinateur personnel n’est généralement pas considéré comme un système embarqué, les concepteurs ne sachant pas à l’avance à quelles fins il sera utilisé. Une grande partie de ces systèmes embarqués ont des contraintes temporelles très fortes, ce qui les distingue encore plus des ordinateurs grand public. A titre d’exemple, lorsqu’un conducteur de voiture freine brusquement, l’ordinateur de bord déclenche l’application ABS et il est primordial que cette application soit traitée endéans une courte échéance. Autrement dit, cette fonctionnalité ABS doit être traitée prioritairement par rapport aux autres fonctionnalités du véhicule. Ce type de système embarqué est alors dit “temps réel”, dû à ces notions de temps et de priorités entre les applications. La problèmatique posée par les systèmes temps réel est la suivante. Comment déterminer, à tout moment, un ordre d’exécution des différentes fonctionnalités de telle sorte qu’elles soient toutes exécutées entièrement endéans leur échéance ? De plus, avec l’apparition récente des systèmes multiprocesseurs, cette problématique s’est fortement complexifiée, vu que le système doit à présent déterminer quelle fonctionnalité s’exécute à quel moment sur quel processeur afin que toutes les contraintes temporelles soient respectées. Pour finir, ces systèmes embarqués temp réel multiprocesseurs se sont rapidement retrouvés confrontés à un problème de consommation d’énergie. Leur demande en terme de performance (et donc en terme d’énergie) à évolué beaucoup plus rapidement que la capacité des batteries qui les alimentent. Ce problème est actuellement rencontré par de nombreux systèmes, tels que les téléphones portables par exemple. L’objectif de cette thèse est de parcourir les différents composants de tels système embarqués et de proposer des solutions afin de réduire leur consommation d’énergie.

Nous nous intéressons à la conception sûre de systèmes répartis. Nous montrons qu'avec la complexité et l'intégration croissante des systèmes embarqués, la structure fonctionnelle du système peut entrer en conflit avec la structure de son architecture. L'approche traditionnelle de conception par raffinement de cette architecture compromet alors la modularité fonctionnelle du système. Nous proposons donc une méthode permettant de concevoir un système réparti défini comme un programme unique, dont la structure fonctionnelle est indépendante de l'architecture du système. Cette méthode est basée sur l'ajout de primitives de répartition à un langage flots de données synchrone. Ces primitives permettent d'une part de déclarer l'architecture sous la forme d'un graphe définissant les ressources existantes et les liens de communication existant entre ces ressources, et d'autre part de spécifier par des annotations la localisation de certaines valeurs et calculs du programme. Nous définissons ensuite la sémantique formelle de ce langage étendu. Cette sémantique a pour but de rendre compte de manière formelle l'effet des annotations ajoutées par le programmeur. Un système de types à effets permet ensuite de vérifier la cohérence de ces annotations. Ce système de types est muni d'un mécanisme d'inférence, qui permet d'inférer, à partir des annotations du programmeur, la localisation des calculs non annotés. Nous définissons ensuite, à partir de ce système de types, une méthode de répartition automatique permettant d'obtenir, à partir d'un programme annoté, un fragment de programme par ressource de l'architecture. La correction du système de types avec la sémantique du langage est prouvée, ainsi que l'équivalence sémantique de l'exécution des fragments obtenus par la méthode de répartition automatique avec le programme initial. Cette méthode a été implémentée dans le compilateur du langage Lucid Synchrone, et testée sur un exemple de radio logicielle.

Un système embarqué peut être défini comme un système électronique et informatique autonome, dédié à une tâche bien définie et soumis à des contraintes. Les défaillances des systèmes embarqués sont de plus en plus difficiles à prévoir, comprendre et réparer. Des travaux sur la sûreté de fonctionnement ont mis au point les techniques de vérification et des recommandations de conception pour maîtriser les risques. En même temps d'autres travaux ont entrepris d'améliorer la fiabilité de ces systèmes en rénovant les méthodologies de conception. Les méthodes de diagnostic, à leur tour, ont évolué afin d'améliorer la tolérance des systèmes embarqués aux pannes et leur capacité à s'auto-diagnostiquer. Ainsi, le domaine de l'analyse de la " diagnosticabilité " a vu le jour. Aujourd'hui, le concepteur d'un système doit s'assurer que celui-ci est diagnosticable, c'est-àdire que les fautes qui peuvent y apparaitre sont identifiables, avant de construire ou fabriquer le système. Les méthodes d'analyse de la diagnosticabilité se focalisent sur ce que nous appelons " la diagnosticabilité fonctionnelle " où l'architecture matérielle du système n'était pas directement considérée. Cette thèse contribue à l'analyse de l'impact de l'interaction des fonctions-architecture sur la diagnosticabilité d'un système embarqué. L'approche que nous avons conçue est intégrable dans le cycle de conception des systèmes embarqués ; elle commence par l'analyse de la diagnosticabilité des systèmes à événements discrets (telle qu'elle est présentée dans la littérature). Notre méthode, exige ensuite la vérification d'un ensemble de propriétés que nous avons définies et appelées " propriétés de la diagnosticabilité fonctionnelle-architecturale ". La vérification des propriétés s'effectue en deux étapes : la première étape est la vérification de la description de l'architecture (réalisée en AADL) et la deuxième étape est la vérification de l'interaction fonctions-architecture (réalisée en SystemC-Simulink). Pour l'analyse de l'interaction des fonctions avec l'architecture, réalisée en SystemC-Simulink, nous avons développé un prototype d'outil COSITA basé sur l'analyse des traces de la co-simulation du co-modèle. Nous avons comparé les résultats de l'analyse des traces de co-simulation avec des résultats que nous avons obtenus suite à une émulation sur une plateforme physique automobile dans le laboratoire Heudiasyc. Finalement, nous avons mis au point à travers cette thèse une méthodologie originale d'analyse de la diagnosticabilité qui prend en considération les contraintes de l'architecture matérielle du système.

Notre objectif est de proposer une méthodologie pour le développement d'un intergiciel embarqué dans l'automobile offrant des services de communication aux applications. Le cadre d'utilisation de nos travaux est la conception de systèmes embarqués dans les véhicules. Ces applications requièrent un intergiciel capable de fournir des services standards de communication, qui cachent la localisation des participants aux échanges, qui masquent l'hétérogénéité des plates-formes de communication, et qui garantissent le respect des contraintes temporelles imposées sur les échanges et sur l'exécution des participants.<br />La méthodologie proposée vise la conception d'un intergiciel optimisé et pour cela aborde deux aspects : la spécification d'une architecture d'implémentation, et la construction d'une configuration faisable. L'architecture d'implémentation est optimisée dans le sens où l'intergiciel est adapté à l'environnement d'exécution (le système d'exploitation OSEK/VDX OS), et minimise son utilisation des ressources disponibles. Elle apporte une réponse, d'une part, au niveau de la spécification d'une architecture logicielle (construite à l'aide de design patterns), et, d'autre part, à la manière dont cette architecture est déployée sur une plate-forme concrète (sous la forme d'un ensemble de tâches). La procédure proposée pour la construction de la configuration de l'intergiciel calcule les caractéristiques temporelles faisables de l'intergiciel et des trames émises par les stations d'un réseau CAN. Elle prévoit aussi une étape pour le calcul d'une allocation de priorités faisable pour les tâches de l'application sur chaque station. L'optimalité de la configuration est atteinte en assurant le respect de toutes les contraintes temporelles imposées sur les échanges et sur l'exécution des tâches de l'application et de l'intergiciel.

L'implémenation distribuée des systèmes temps-réel a été toujous une tâche non-triviale. La coordination des composants s'exécutant sur une plate-forme distribuée doit être assurée par des protocoles de communication complexes en tenant compte de leurs contraintes de temps. Dans cette thèse, nous proposons un flot de conception rigoureux à partir d'un modèle de haut niveau d'un logiciel d'application décrit en BIP (Behavior, Interaction, Priority) et conduisant à une implémenation distribuée. Le flot de conception implique l'utilisation de transformations de modèles tout en conservant les propriétés fonctionnelles des modèles originaux de BIP. Un modèle BIP se compose d'un ensemble de composants qui se synchronisent à travers les interactions et les priorités. Notre méthode transforme les modèles BIP en un modéle Send/Receive qui fonctionnent en utilisant le passage de messages asynchrones. Les modèles obtenus sont directement implémenté sur une plate-forme donnée. Nous présentons trois solutions pour obtenir un modéle Send/Receive. Dans la première solution, nous proposons des modéles Send/Receive qui fonctionnent avec un engin centralisé qui implémente les interactions et les priorités. Les composants atomiques des modèles originaux sont transformés en composants Send/Receive qui communiquent avec l'engin centralisé via des interactions Send/Receive. L'engin centralisé exécute les interactions sous certaines conditions définies par les modèles à états partiels. Ces modèles représentent une déscription haut niveau de l'exécution parallèle de modèles BIP. Dans la deuxième solution, nous proposons de décentraliser l'engin. Les modéles Send/Receive obtenus sont structurées en trois couches: (1) les composants Send/Receive (2) un ensemble d'engin, chacun exécutant un sous-ensemble d'interactions, et (3) un ensemble de composants implémentant un protocole de résolution des conflits. Avec les solutions décrites ci-dessus, nous supposons que les latences de communication sont négligeables. Ceci est du au fait que les modéles Send/Receive sont concu de telle sorte qu'il n'y ait pas retard entre la décision d'exécuter une interaction dans un engin et son exécution dans les composants participant. Dans la troisième solution, nous proposons des modéles Send/ Receive qui exécutent correctement même en présence de latences de communication. Cette solution est basée sur le fait que les engin planifient l'exécution des interactions et notifient les composants à l'avance. Afin de planifier correctement les interactions, nous montrons que les engins sont tenus à observer des composants supplémentaires, en plus de ceux qui participent aux interactions. Nous présentons également une méthode pour optimiser le nombre de composants observés, en se basant sur l'utilisation de techniques d'analyse statique. A partir d'un modéle Send/Receive donné, nous générons une application distribuée où les interactions Send/Receive sont implémentées par les sockets TCP. Les résultats expérimentaux sur des exemples non triviaux et des études de cas montrent l'efficacité de notre méthode. / Correct distributed implementation of real-time systems has always been a challenging task. The coordination of components executing on a distributed platform has to be ensured by complex communication protocols taking into account their timing constraints. In this thesis, we propose rigorous design flow starting from a high-level model of an application software in BIP (Behavior, Interaction, Priority) and leading to a distributed implementation. The design flow involves the use of model transformations while preserving the functional properties of the original BIP models. A BIP model consists of a set of components synchronizing through multiparty interactions and priorities. Our method transforms high-level BIP models into Send/Receive models that operate using asynchronous message passing. The obtained models are directly implementable on a given platform. We present three solutions for obtaining Send/Receive BIP models. -In the first solution, we propose Send/Receive models with a centralized scheduler that implements interactions and priorities. Atomic components of the original models are transformed into Send/Receive components that communicate with the centralized scheduler via Send/Receive interactions. The centralized scheduler is required to schedule interactions under some conditions defined by partial state models. Those models represent high-level representation of parallel execution of BIP models. - In the second solution, we propose to decentralize the scheduler. The obtained Send/Receive models are structured in 3 layers: (1) Send/Receive atomic components, (2) a set of schedulers each one handling a subset of interactions, and (3) a set of components implementing a conflict resolution protocol. With the above solutions, we assume that the obtained Send/Receive models are implemented on platforms that provide fast communications (e.g. multi-process platforms) to meet perfect synchronization in components. This is because the obtained schedulers are modeled such that interactions scheduling corresponds exactly to execution in components. - In the third solution, we propose Send/Receive models that execute correctly even if communications are not fast enough. This solution is based on the fact that schedulers plan interactions execution and notify components in advance. In order to plan correctly the interactions, we show that the schedulers are required to observe additional components, in addition to the ones participating in the interactions. We present also a method to optimize the number of observed components, based on the use of static analysis techniques. From a given Send/Receive model, we generate a distributed implementation where Send/Receive interactions are implemented by TCP sockets. The experimental results on non trivial examples and case studies show the efficiency of our design flow.

Ces deux dernières décennies, les systèmes embarqués ont été introduits dans de nombreux domaines d'application (transport, industrie, habitat, médical...). Ces systèmes se sont vu confier des tâches plus importantes pour délivrer de nouveaux services aux utilisateurs avec des délais de mise sur le marché toujours plus courts et à moindre coût. L'intégration rapide de ces systèmes au sein de produits manufacturés est un avantage concurrentiel pour les industriels. Cependant, les pannes associées à ces systèmes et le niveau de complexité croissant des équipements ont rendu les interventions de maintenance bien plus délicates. L'identification des causes de certaines pannes représente actuellement un véritable challenge dans les activités de la maintenance. Elles entrainent une indisponibilité excessive des équipements.Cette thèse propose une architecture générique de surveillance "active" pour l'aide à la maintenance de systèmes mobiles. Cette architecture repose sur des entités de surveillance "intelligentes" capables d'évaluer l'état de santé des équipements surveillés. Notre contribution se situe à la rencontre de différentes communautés de Recherche et s'appuie notamment sur des concepts développés par lacommunauté PHM (Pronostics and Health Management).L'architecture proposée est mise en œuvre et appliquée a la surveillance d'un système réel de transport ferroviaire dans le cadre du projet SURFER (SURveillance active FERroviaire) conduit par Bombardier-Transport.