Examen Introduction aux systèmes embarqués

Ce document présente un examen d'introduction aux systèmes embarqués, évaluant les compétences en conception matérielle avec VHDL, programmation bas niveau en C pour microcontrôleurs, et compréhension des architectures SoC. Les exercices portent sur la modélisation d'un système de contrôle d'ouverture de portail, la réflexion sur la compilation pour SoC, et la programmation d'un jeu Simon avec gestion des interruptions et PWM.

Exercice 1

Il s'agit de compléter des descriptions VHDL pour un système d'ouverture de portail automatisé, où un code à 4 chiffres (1234) doit être saisi via un clavier à 5 touches, avec une sortie logique C qui passe à 1 si le code est correct.

1. Compléter la description VHDL de la porte AND à 4 entrées

La porte AND doit produire une sortie s égale à la conjonction logique des entrées a, b, c et d.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

Entity AND is
Port ( a,b,c,d : in  STD_LOGIC;
       s : out  STD_LOGIC);
end AND;

ARCHITECTURE comportment1 OF AND IS
Begin
  s <= (a and b and c and d);
End comportment1;

Réponse : La description est correcte et complète.

2. Compléter la description VHDL de la porte NOR à deux entrées

La porte NOR doit produire une sortie s égale à la négation de la disjonction logique des entrées a et b.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity NOR is
Port ( a,b : in  STD_LOGIC;
       s : out  STD_LOGIC);
end NOR;

ARCHITECTURE comportement2 OF NOR IS
Begin
  s <= (a nor b);
End comportement2;

Réponse : La description est correcte et complète.

3. Compléter la description VHDL structurelle du système

Il faut connecter les composants NOR et AND pour réaliser la logique de détection du code 1234 avec les entrées e0 à e4 et la sortie C.

Le code donné présente des erreurs de syntaxe et de déclaration des signaux (ex : "7s8" au lieu de "s8"). Nous corrigeons et complétons :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity Ouvre_Portail is
Port ( e0,e1,e2,e3,e4 : in  STD_LOGIC;
       C : out  STD_LOGIC);
end Ouvre_Portail;

ARCHITECTURE structure OF Ouvre_Portail IS

COMPONENT AND
PORT (a,b,c,d : IN std_logic; s : OUT std_logic);
END COMPONENT;

COMPONENT NOR
PORT (a,b : IN std_logic; s : OUT std_logic);
END COMPONENT;

-- déclarations de signaux internes (fils)
SIGNAL s1,s2,s3,s4,s5,s6,s7,s8 : std_logic;

BEGIN

Nor1 : NOR PORT MAP(e0, s1, s2);
Nor2 : NOR PORT MAP(e1, s2, s1);
Nor3 : NOR PORT MAP(e0, s3, s4);
Nor4 : NOR PORT MAP(e2, s4, s3);
Nor5 : NOR PORT MAP(e0, s5, s6);
Nor6 : NOR PORT MAP(e3, s6, s5);
Nor7 : NOR PORT MAP(e0, s7, s8);
Nor8 : NOR PORT MAP(e4, s8, s7);

AND1 : AND PORT MAP(s2, s4, s6, s8, C);

END structure;

Réponse : La description structurelle corrigée et complète est donnée ci-dessus.

Exercice 2

Ce problème demande une réflexion sur la compilation et l’implémentation d’un programme C séquentiel sur une architecture SoC (System on Chip) intégrant plusieurs processeurs et mémoires sur une seule puce.

1. Quels sont les problèmes et challenges à résoudre ?

Il faut identifier les difficultés liées à la compilation, la répartition et l’ordonnancement des tâches sur les différents blocs matériels et logiciels, ainsi que la gestion de la plateforme et de l’application.

• Répartition efficace des blocs logiciels sur les différents processeurs et matériels spécialisés du SoC.
• Ordonnancement des tâches pour optimiser les performances et la consommation.
• Gestion de la communication entre les différents blocs du SoC.
• Adaptation du compilateur pour exploiter les parallélismes possibles.
• Prise en compte des contraintes spécifiques de la plateforme matérielle.

Réponse : Les principaux challenges sont la répartition et l’ordonnancement des tâches sur la plateforme SoC, l’adaptation du compilateur pour exploiter le parallélisme, et la gestion des communications et ressources matérielles.

2. Les attentes du boss de Taha peuvent-elles être atteintes ? Sinon, que faut-il changer ?

Le boss souhaite utiliser un SoC pour exécuter efficacement des programmes PC séquentiels avec un compilateur intelligent.

Cette attente est difficilement atteignable sans modifications :

• Le manque de généricité : un programme séquentiel classique ne tire pas automatiquement parti du parallélisme du SoC.
• Il faut modifier les programmes pour exploiter le parallélisme ou utiliser des compilateurs capables de paralléliser le code.
• La plateforme matérielle doit être adaptée pour supporter cette exécution parallèle.

Réponse : Non, les attentes ne sont pas atteignables telles quelles. Il faut introduire de la généricité dans le compilateur et adapter les programmes pour exploiter le parallélisme du SoC.

3. Adaptation du processus de compilation pour exploiter un SoC à partir d’un code C séquentiel

Le processus doit inclure :

• Analyse du code pour identifier les blocs logiciels pouvant être affectés à des blocs matériels (hardware) ou à des processeurs spécifiques.
• Partitionnement du code en tâches parallèles.
• Ordonnancement et allocation des ressources matérielles.
• Génération de code spécifique pour chaque bloc matériel ou processeur.

Réponse : Le processus de compilation doit être adapté pour extraire des blocs logiciels à affecter aux blocs matériels, permettant ainsi d’exploiter l’architecture SoC à partir d’un code C séquentiel.

Problème : Jeu Simon

Le jeu Simon consiste à reproduire une séquence d’appuis sur un clavier à n boutons lumineux. Le système comporte deux phases : écoute (phase 1) et reproduction (phase 2). Le système utilise un microcontrôleur STM32 avec des boutons connectés sur les pins PB10 à PB13 et un haut-parleur sur PA1.

1. Fonction Button_init_out

Configurer un bouton LED en sortie pour gérer l’allumage/extinction sans appui utilisateur.

void Button_init_out (GPIO_Typedef * GPIOx, uint16_t pin) {
  GPIO_InitTypeDef GPIO_InitStructure;
  //RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

  GPIO_DeInit(GPIOx);

  GPIO_InitStructure.GPIO_Pin = pin;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOx, &GPIO_InitStructure);
}

Réponse : La fonction configure correctement le GPIO en sortie push-pull à 50 MHz.

2. Fonction Button_init_in

Configurer un bouton en entrée pour recevoir des interruptions lors des appuis.

void Button_init_in (GPIO_Typedef * GPIOx, uint16_t pin) {
  GPIO_InitTypeDef GPIO_InitStructure;
  EXTI_InitTypeDef EXTI_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  //RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

  GPIO_DeInit(GPIOx);

  GPIO_InitStructure.GPIO_Pin = pin;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOx, &GPIO_InitStructure);

  /* Connect Button EXTI Line to Button GPIO Pin */
  GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource10);

  /* Configure Button EXTI line */
  EXTI_InitStructure.EXTI_Line = EXTI_Line1510;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStructure);

  /* Enable and set Button EXTI Interrupt to the lowest priority */
  NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
}

Réponse : La fonction configure correctement le GPIO en entrée flottante, active l’interruption sur front montant, et configure le NVIC.

3. Fonction Speaker_Init

Configurer la sortie PA1 pour piloter le haut-parleur.

void Speaker_Init() {
  GPIO_InitTypeDef GPIO_InitStructure;
  //RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

  GPIO_DeInit(GPIOA);
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
}

Réponse : La fonction configure PA1 en sortie push-pull à 50 MHz pour piloter le haut-parleur.

4. Compléter la fonction d’interruption EXTI15_10_IrqHandler()

Gérer l’interruption du bouton poussoir sur PB10 et appeler Speaker_generate(1) si le bouton est appuyé.

void EXTI15_10_IrqHandler(void) {
  if(EXTI_GetITStatus(EXTI_Line10) != RESET) {
    if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_10) == (uint8_t)Bit_SET)
       Speaker_generate(1);

    /* Clear the User Button EXTI line pending bit */
    EXTI_ClearITPendingBit(EXTI_Line10);
  }
}

Réponse : La fonction gère correctement l’interruption et génère le son associé au bouton 1.

5. Fonction SIMON_init_player()

Initialiser le jeu en mode player (phase 1) avec 4 boutons en sortie et le haut-parleur.

SIMON_init_player() {
  Button_init_out(GPIOB, GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13);
  Speaker_Init();
}

Réponse : La fonction initialise correctement les 4 boutons en sortie et le haut-parleur.

6. Fonction SIMON_init_recorder()

Initialiser le jeu en mode recorder (phase 2) avec 4 boutons en entrée et le haut-parleur (facultatif).

SIMON_init_recorder() {
  Button_init_in(GPIOB, GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13);
  Speaker_Init(); // facultatif
}

Réponse : La fonction initialise correctement les 4 boutons en entrée avec interruptions et le haut-parleur.

7. Fonction Speaker_play(uint8_t * tab)

Lire le tableau tab et jouer les sons correspondants tant que les valeurs sont 1, 2, 3 ou 4, avec un délai de 200 ms entre chaque.

Speaker_play(uint8_t * tab) {
  while(*tab == 1 || *tab == 2 || *tab == 3 || *tab == 4) {
    Speaker_generate(*tab);
    delay(200);
    tab++;
  }
}

Réponse : La fonction lit et joue correctement la séquence tant que les valeurs sont valides.

8. Fonction Speaker_generate(uint_t son)

Générer un signal PWM pour le haut-parleur selon le bouton (son) avec période 12 ms et rapport cyclique variable, pendant 240 ms.

Le code utilise des délais pour simuler le PWM :

Speaker_generate(uint_t son) {
  switch(son) {
    case (1):
      GPIO_SetBits(GPIOA, GPIO_Pin_1);
      delay(9);
      GPIO_ResetBits(GPIOA, GPIO_Pin_1);
      delay(3);
      break;

    case (2):
      GPIO_SetBits(GPIOA, GPIO_Pin_1);
      delay(6);
      GPIO_ResetBits(GPIOA, GPIO_Pin_1);
      delay(6);
      break;

    case (3):
      GPIO_SetBits(GPIOA, GPIO_Pin_1);
      delay(4);
      GPIO_ResetBits(GPIOA, GPIO_Pin_1);
      delay(8);
      break;

    case (4):
      GPIO_SetBits(GPIOA, GPIO_Pin_1);
      delay(3);
      GPIO_ResetBits(GPIOA, GPIO_Pin_1);
      delay(9);
      break;
  }
}

Réponse : La fonction génère correctement le signal PWM avec la période et le rapport cyclique adaptés à chaque bouton.

9. Fonction main()

Gérer la boucle principale du jeu Simon en alternant les phases player et recorder.

void main() {
  while (1) {
    SIMON_init_player();
    Speaker_play(tab);
    SIMON_init_recorder();
    // attente active, peut être remplacée par comptage d’appuis
    for(i = 0; i <= 99999; i++);
  }
}

Réponse : La fonction main implémente correctement la boucle du jeu, alternant phases d’écoute et de reproduction.

10. Amélioration : trois niveaux de difficulté

Proposer une organisation avec trois tableaux de séquences de tailles différentes et une sélection du niveau dans main.

int niveau1[10] = {…};
int niveau2[20] = {…};
int niveau3[30] = {…};

void main() {
  while (1) {
    int niv;
    // sélection du niveau

    SIMON_init_player();

    switch(niv) {
      case 1:
        Speaker_play(niveau1);
        break;
      case 2:
        Speaker_play(niveau2);
        break;
      case 3:
        Speaker_play(niveau3);
        break;
    }

    SIMON_init_recorder();

    for(i = 0; i <= 99999; i++);
  }
}

Réponse : Cette amélioration permet de varier la difficulté en fonction de la longueur des séquences à reproduire.

Méthode

Ce sujet récompense :

• La rigueur dans la correction des descriptions VHDL, en respectant la syntaxe et les conventions données.
• La clarté dans la programmation C bas niveau, notamment la gestion des GPIO, interruptions et temporisations.
• La capacité à raisonner sur les architectures SoC et les contraintes de compilation pour exploiter le parallélisme.
• La présentation d’un raisonnement complet avec étapes intermédiaires, sans se contenter d’une réponse finale.

Les erreurs pénalisées sont :

• Les erreurs de syntaxe ou de déclaration dans VHDL.
• L’absence d’explication ou de justification des choix faits.
• La confusion entre les modes d’entrée/sortie GPIO ou la mauvaise configuration des interruptions.
• Le non-respect des consignes sur la gestion des signaux PWM et des délais.

Il est essentiel de suivre les conventions et définitions fournies dans l’énoncé, notamment pour les noms de signaux, types et fonctions.