Vous êtes sur la page 1sur 4

Introduction aux Systèmes Embarqués

Système embarqué
1-​Système ordinateur : Processeur(s), Mémoire(s), E/S.​ 2-​Contrôler des opérations physiques (temps-réel) ​3- ​90% des Processeurs sont
utilisés dans les systèmes embarqués
Caractéristiques
•Autonome -Tâche définie -Enfoui dans un appareil -Pas de clavier ni d’affichage -Temps-réel
Contraintes
-​Prix​ -​Performances (temps-qualité) ​-​Taille ​-​Energie ​-​Time-to-market ​-​Maintenabilité​ -​Fiabilité (Safety)
Temps-réel
« Contrôler un environnement en recevant des données, les traiter et renvoyer le résultat d’une manière suffisamment rapide pour affecter
cet environnement à cet instant »
Temps-réel
Temps-réel strict: -Applications critiques -Pas de dépassement du temps limite -Pas d’abandon de données
Temps-réel mou: -Les échéances peuvent êtres abandonnées -On peut fournir une réponse dégradée
Du Logiciel et du Matériel
De nos jours:
•Matériel: plus de matériel programmable
•Logiciel: Complexité et volume augmente
•Co-design: -Conception du logiciel et du matériel en même temps -Les méthodes du partitionnement Logiciel/matériel
Logiciel
Implémentation en assembleur : DSP, µC…
Langage haut niveau : C, OpenCL…
A base de modèles : Model based design (Matlab-simulink)
Matériel
*CPU (RISC, CISC, Superscalaire) *ASIC *ASIP *DSP, VLIW *Microcontrôleurs *FPGA *SoC, MPSoC *NoC
Co-design
*Partitionnement Sw/Hw *Génération du Matériel et du logiciel *Génération des communications
Exemples de problématiques
*Instructions spécialisées *Compilateur – optimisation du code *Analyse de temps d’exécution *Consommation électrique *Simulation
Instructions spécialisées
*Gagner en performance *S'adapter à certains programmes *Diminuer la taille du programme *Améliorer la sécurité
Compilateur – Optimisation du code
*Nécessaire avec l’augmentation de la taille des logiciels enfouis
*Utilisé en avance de phase pour la validation et le dimensionnement : -Déterminer les temps d’exécution
*Mais doit : -Produire un code très compact et très optimisé -Être mis en œuvre rapidement (recyclable)
Analyse de temps d’exécution
*Déterminer le temps maximum d’exécution des programmes
*Prendre en compte les éléments dynamiques : -Chemin dans les programmes -Comportement de l’architecture
Consommation électrique
*Techniques VLSI mais aussi architecturales et logicielles pour diminuer la consommation *Contrôle de la fréquence et du voltage
Simulation
*Nécessaire à la validation et au dimensionnement des systèmes
*Simulation à partir: RTL, VHDL, … Lente mais précise
*Simulation compilée: un code compilé imite le comportement du code sur le processeur : -simulation rapide -éventuellement imprécise
temporellement
*Ad-hoc
Rapide (parfois) mais coûteuse à produire
Exemple Simics/Virtutech : système complet

​****************Méthodologie de conception *****************


Evolution technologiques
*Nombre d’ingénieurs *Outils de développement avancés : -Langages haut niveau -Conception assistée par ordinateur *Méthodologie de
conception
IP cores
*Intellectual property *Schéma de conception d’un CI, logique, cellule… réutilisable *Réutilisation des blocs propriétaires *Acheter des blocs
conçus par d’autres concepteurs (sous License ou open source) *Utiliser les générateurs de macro-cellules *Utilisation ASIC et FPGA
*Blocs fonctionnels complexes réutilisables
-Hard : dépendant de la technologie, fortement optimisé
-Soft : Programmable, portable : ​--​dans un langage de haut niveau (VHDL, Verilog, C++…), paramétrables​ --​Netlist: protection contre reverse
engineering ​--​Environnement de développement (codesign, co-spécification, co-verification) ​--​Performances moyennes (peu optimisé)
*Interfaces normalisées
*Comportement défini et vérifié
IP cores
Réutiliser un bloc IP: *​Connaître les fonctionnalités ​*​Estimer les performances dans un système ​*​Etre sûr du bon fonctionnement de l’IP
*​Intégrer cet IP dans le système ​*​Valider le système
Méthodologie de conception
Pourquoi?​ ​*​Augmentation de la complexité d’intégration ​*​Algorithmes multitudes et complexes ​*​Time-to-market
Objectifs:​ *​Faciliter les tâches de conception​ *​Assurer le fonctionnement et limiter les erreurs ​*A
​ utomatiser les tâches répétitives et
laborieux
*​Indépendance vis-à-vis de la technologie
Méthode, Modèle, Méthodologie
Méthode​ : approche de résolution de problème caractérisée par un ensemble de règles bien définies qui conduisent à une solution correcte
Modèle​ : une représentation d'un aspect partiel et cohérent du «monde» réel
Méthodologie​ : un ensemble structuré et cohérent de modèles, méthodes, guides et outils permettant de déduire la manière de résoudre un
problème
Méthodologie de conception​ : Passer d’un cahier de charge vers une réalisation
Niveaux d'abstraction
*​Niveau spécification: définir le problème ​*​Niveau architectural: agencement général de la réalisation ​*​Niveau Logique: Conception détaillée
*​Niveau Implémentation: Réalisation
La réalisation peut être matérielle, logicielle ou conjointe
Démarches de conception
-*​Démarche ascendante (Bottom-up) ​*​Démarche descendante (Top-Down)
Démarche de conception

-
-Approche ascendante
*​la conception commence par une optimisation au niveau physique ​*​chaque niveau d’abstraction possède une bibliothèque d’éléments
optimisés
*​facilité de réutilisation des éléments ​*​utiliser dans la recherche
mais ​*​nécessite une étude longue et coûteuse ​*​grande bibliothèque (composant inutilisable)
Approche descendante
*​On commence une description des spécifications de notre système ​*​A chaque niveau on développe selon les exigence du niveau supérieur
*​Système optimisé, temps de développement réduit ​*​On ne code que ce qui est util ​*​utilisé dans le développement
Mais: ​*​les tests ne peuvent être faite que jusqu’à un avancement défini ​*​Difficulté de réutilisation les éléments ​*​Difficulté de corriger le
design
Combinaison des approches
*​Combiner entre les deux approches ​*​Développement des niveaux supérieurs en utilisant les éléments des niveaux inférieurs
*​Limiter l’espace de recherche ​*​réduire le temps de conception
Flot de conception
Co-design
une conception conjointe Logicielle/Matérielle : 1- Spécification 2- Partitionnement 3- Synthèse logicielle et matérielle 4- Co-simulation
1-Spécification : ​*​Evaluation d’un cahier de charge : -Aspects techniques -Aspects économiques ​*​Choix de la cible matérielle
2-Partitionnement : ​*​Evaluation des performances et des coûts ​*​Affecter chaque fonction à une des parties logicielle ou matérielle
3-Synthèse :
*​Logicielle: exécutable par un processeur ​*​Matériel: circuit accélérateur ​*​Interface: les protocoles et les modes de communication entre
Sw/Hw
4-Partitionnement :
Méthode simple:
*​Profilage et partitionnement -trouver la partie du code qui consomme beaucoup en terme de temps d'exécution -Faire un partitionnement
selon les résultats du profiling ​*​loi d’Amdahl
Profilage
*​c’est une analyse de l’exécution d’un logiciel pour connaitre son comportement ​*​Il mesure le temps passé par les différentes parties de ce
logiciel, les appels mémoires…
réalisation:
intrusif (instrumentation): insertion de code espion pour mesurer
non intrusive(statistiques): échantillonnage, interruption périodique de l’OS ou du processeur et lecture de l’état
Partitionnement
Certaines fonctions ne sont pas triviales à réaliser en matériel
Inconvénient: on ne considère pas l’aspect transfert de données
Approches bipartitionnement
*​Utilisation des graphes, v nœuds (sommets) et e arcs
*​chaque nœud ou arc a un poids
*​Diviser le graphe en deux de sorte que: -Le nombre d’arcs entre les deux sous-graphes soient minimiser --Le partitionnement soit équilibré
Approches bipartitionnement
- min-cut/max-flow (Ford-Fulkerson 1962)
- Kernighan-Lin (1970)
- Fiduccia-Mattheyses(1982)
Kernighan-Lin
*​Les sommets sont de même poids ​*​Le but est de minimiser le nombre d’arcs qui coupent la frontière ​*​Deux sommets déplacés à la fois.
*​Le déplacement est fait à base du gain
*​Découpage aléatoire équilibré ​*​D(v) = E​c​(v) - E​nc​(v) ​*​D > 0, v doit être déplacé ​*​D < 0, v ne doit pas être déplacé
*​Δg = D(v1) + D(v2) – 2*c(v1,v2) ​*​c(v1,v2) = 1 si il existe un arc qui relie v1 à v2. ​*​Le gain Δg montre l’efficacité d’alterner ces deux
sommets.
*​Δg(a,f) = D(a) + D(f) – 2*c(v1,v2) ​*​Δg(a,f) = 1 + 2 – 0 = 3 ​*​Verrouiller a et f ​*​Passer aux 2 suivants ​*​Δg = 3 ​*​Cut cost = 2
*​Gm = Σ(Δg) ​*​Choisir l’étape où Gm est maximum. ​*​Cut cost = 2 ​*​Gm = Δg​1​=3

********************Programmation C pour l’embarqué**********************


But
*​Les fonction sont correctes ​*​Le code source est concis, lisible et maintenable ​*​Les sections critiques du programme s'exécutent assez
rapidement
*​Le code objet est petit et efficace ​*​Optimiser l'utilisation de trois ressources : ​-​Temps d'exécution ​-​Memory ​-​Temps de développement /
maintenance
Calcul arithmétique
*​Entiers -> Calcul rapide ​*​Virgule flottante en matériel -> calcul lent ​*​Virgule flottante en logiciel-> calcul très lent
*Utiliser l’addition/soustraction des entiers *Eviter l’utilisation des multiplications et les opérations en virgule flottante sauf si on a des
accélérateurs dédiés *Eviter la division *Eviter les librairies mathématiques
Manipulation de bits
& -> AND | -> OR ^ -> XOR ~ -> NOT >> -> Shift left << -> shift right
Multiplication
*Utilisation des opérations shift *Pour les opérations de multiplication par un constant *Inexistence de multiplication en hardware
Décisions Multiples
*If-else: OK *Switch case: Mieux *Utilisation de vecteur: Meilleur pour les fonctions discrètes, LUT à temps constant.
Optimisation
● Optimiser le code pour : -Compilation rapide -Code de petite taille
● -O0: code non optimiser en taille, compilation rapide, préféré pour le débogage
● -O1, -O2… optimisation du code -> petite taille, peut affecter les résultats.
● -Og , Os, Ofast…
Stockage mémoire
*Types de variables *Allocation dynamique
Types de variables
*2 types: variables empilées, variables globales *Temps d’accès rapides *Variables empilées sont préférées *Eviter les algorithmes récursifs
-> danger d’épuisement d’espace de stockage
Allocation dynamiques
*malloc() et free() *Temps de d’allocation et désallocation lent (imprévisible) *Fragmentation de mémoire. *Danger d’épuisement de
mémoire
*Utiliser avec précaution
Mémoire mappée E/S
*​Des positions mémoires qui adresses des entrées sorties d’un matériel. ​*​Ecriture/Lecture, correspond à envoi/recevoir de données.
​*​Peuvent être lecture seule ou écriture seule ​*​Lecture et écriture peuvent avoir accès aux différentes données.
Variable volatile vs non volatile
Communication HW/SW
*MM E/S: CPU est le maître: seul qui peut initier la communication : -Lire registre d’état (prêt?) -Envoyer une commande -Lire registre d’état
(terminé?) *Sondage (polling) *Interruption *Le périphérique peut initier la communication en demandant l’attention du CPU. *Le CPU
réponds par interrompre le programme courant et appelle une routine d’interruption
*************************Interfaces Matériel/Logiciel******************************
Un système avec processeur : *​Processeur + Mémoire(s) + Périphériques *Buses d’adresses et de données *Processeur -> Maître *Autres
composants -> Esclaves
Adressage de périphériques
*Schéma isolé : -Espace d’adressage des périphériques est différent de celui de la mémoire -Différentes instructions d’accès
*E/S mappées en mémoire : -Les périphériques et la mémoires partagent le même espace d’adressage. -Même instructions d’accès
Interfaces
*Une interface son rôle est de synchroniser le transfert de données avec le CPU *Elle peut contenir des registres (registres d’état, de
contrôle, de direction, données…) *Chaque interface doit être adressable, et doit avoir des pins de données. *Le transfert de données se fait
à travers des buses, peut être en parallèle ou en série
E/S Mappées en mémoire
*Le processeur voit tous comme mémoire *les périphériques se voient comme des espaces mémoires *Registre d’états: donne l’état du
périphérique *Registre de contrôle: changer l’état du périphérique
Exemple
*Port parallèle: -Lire le registre d’état ( occupé?, nBusy) -Ecrire les données (reg de données) -Mettre à zéro nStrobe (reg de control)
-Attendre nBusy, Ack ( reg d’état), peut être bypasser Ack pour gagner du temps
Sondage vs interruptions
Deux méthodes pour avoir les données:
*Sondage: le CPU initie la communication : ​-​Lecture: lire le registre d’état du périphérique pour savoir si la donnée est prête pour être lu
-​Ecriture: lire le registre d’état pour savoir si le périphérique peut recevoir une donnée *Puis la lecture/écriture peut se faire à partir du
registre de données.
*Interruptions: ​-​le périphérique initie la communication
Lecture: interrompre le CPU si une donnée est prête dans le registre de données
Ecriture: interrompre si le registre de données est vide, et le périphérique peut recevoir une donnée
​-​Le périphérique interrompre le CPU ​-​Le CPU transfère le contrôle à l’ISR correspondante temporairement ​-​L’ISR commence le transfert de
données et acquitte l’interruption ​-​L’ISR rendre le contrôle au programme interrompu
Bus Avalon
-C’est un bus développé par Altera (IntelFPGA) -Utiliser avec le processeur NIOS II -Protocole définie entre le bus et les périphériques
Maîtres et esclaves
*Deux types de composants communicants à travers le bus avalon *Maître: peut initier une communication, et spécifier une adresse
*Esclave: réponds aux requêtes d’un maître *Plusieurs maîtres -> arbitre
Types d’interfaces dans un bus Avalon
*Avalon Memory Mapped interface - Plage d’adresse -Deux type de transfert: simple ou burst
*Avalon streaming interface -Une seule adresse
Signaux d’un bus Avalon
*Clk *Reset *Chhipselect *Address *Read *Write *Writedata *Byteenable *Readdata *irq

Vous aimerez peut-être aussi