Dans ce TP, nous allons utiliser ISE pour construire un contrôleur. C’est en VHDL que vous développerez ce contrôleur. Vous verrez qu’un squelette de construction de FSM en VHDL peut être défini. En séparant au mieux les concepts d’une FSM, la difficulté est sensiblement du même type que celle du TP1 où il a fallu développer en VHDL un process de conversion de signaux. À ce squelette, il faudra y apporter votre contribution afin de réaliser les fonctions supportées par votre contrôleur qui sont principalement de cadencer le système, de produire les signaux de sorties et d’avancer dans l’automate de contrôle. Vous vérifierez par simulation puis par exécution sur la carte que les comportements de votre automate correspondent à vos spécifications. Cet apprentissage sera réutilisé par la suite pour construire l’unité de contrôle de votre processeur S3.

Programmation d’un FSM en VHDL

La meilleure façon de représenter un comportement temporel consiste à utiliser une FSM (Finite State Machine). Cette FSM permet de définir ce qu’il faut déclencher comme signaux à chaque instant et cela en fonction du contexte dans lequel elle évolue. La réalisation d’une FSM peut se faire en schématique et vous l’avez déjà fait pour la réalisation de l’afficheur 4 chiffres. L’utilisation d’un compteur d’état et ensuite de multiplexeurs avec éventuellement des bascules de transition d’état permettent de réaliser un tel circuit. Néanmoins pour une FSM conséquente, il commence à falloir pas mal de composants. Il me semble que la programmation en VHDL est plus lisible et maintenable. C’est pourquoi je vous propose lors de cette séance une mise en œuvre en VHDL. C’est la leçon la plus « VHDL » de cette série. Je vais cette fois encore vous guider vers une utilisation simple des fonctionnalités de VHDL qui en font alors un langage accessible à tout programmeur.

Connaissances requises

Automates, FSM, notions de programmation.

Objectifs

Dans ce TP, nous allons utiliser ISE pour construire un contrôleur. C’est en VHDL que vous développerez ce contrôleur. Vous verrez qu’un squelette de construction de FSM en VHDL peut être défini. En séparant au mieux les concepts d’une FSM, la difficulté est sensiblement du même type que celle du TP1 où il a fallu développer en VHDL un process de conversion de signaux. À ce squelette, il faudra y apporter votre contribution afin de réaliser les fonctions supportées par votre contrôleur qui sont principalement de cadencer le système, de produire les signaux de sorties et d’avancer dans l’automate de contrôle. Vous vérifierez par simulation puis par exécution sur la carte que les comportements de votre automate correspondent à vos spécifications. Cet apprentissage sera réutilisé par la suite pour construire l’unité de contrôle de votre processeur S3.

Le projet

Vous allez concevoir un composant et son symbole de gestion des feux de circulation. C’est en VHDL que vous développerez ce contrôleur qui devra afficher sur les leds, les 6 lampes d’un croisement (2 x Rouge + Orange + Vert). Il faudra ensuite instancier ce symbole dans un schéma qui intègre les entrées/sorties soit les switches et les leds de la carte. Plusieurs niveaux de difficulté seront successivement abordés.

Un contrôleur de feux de circulation

Nos spécifications du système initial se limitent un à automate à 4 états pour un croisement perpendiculaire de deux rues Nord-Sud (NS) et Est-Ouest (EO). On définit ces 4 états de la façon suivant :

Rouge_Vert (RV): Rouge sur NS et Vert sur EO

Rouge_Orange (RO): Rouge su NS et Orange sur EO

Vert_Rouge (VR): Vert sur NS et Rouge sur EO

Orange_Rouge (OR): Orange su NS et Rouge sur EO

L’automate est lui aussi très simple, il s’agit d’une boucle cyclique infinie sur 4 états. Le système change d’état à chaque top d’horloge et pour chaque top il allume les leds correspondantes : les trois leds de droite représentent led(2)=>Rouge, led(1)=> Orange et led(0)=>Vert d’un sens de circulation. Les trois leds les plus à gauche représentent led(7)=>Rouge, led(6)=>Orange et led(5)=> Vert de l’autre sens. Voici une représentation de l’automate qui positionne ces leds à chaque top d’horloge sur le front montant. La valeur des leds est ici validée en sortie de l’état correspondant.

Figure 59 Automate feux tricolores

Vous allez créer votre nouveau projet TP5, insérez de suite un Schematic de nom toplevel et placez les deux Properties pour ucf et JTAG. Vous allez ensuite créer une New Source de type VHDL Module que vous nommerez fsm. ISE vous guide dans la définition du module. Ici vous avez besoin de créer un signal clk en entrée, c’est l’horloge qui permettra d’avancer dans l’automate. Il n’y a pas pour l’instant d’autres signaux en entrée. Par contre vous pouvez de suite créer aussi un port de sorties led(7:0). Enfin validez la création.

Figure 60 Création du squelette vhdl pour la fsm

Ise vous ouvre l’éditeur sur le fichier fsm.vhd. La spécification de l’architecture est vide.

Une FSM sera composée de trois circuits s’exécutant en parallèle. On appelle transition tout changement d’état de notre automate.

Circuit Next_node : va produire en fonction de l’état courant et des entrées éventuelles de la FSM, le prochain état (les cercles de votre automate) dans lequel il faudra se déplacer lors de la prochaine transition. Cela doit correspondre aux flèches de votre automate.

Circuit Next_output : va produire en fonction de l’état courant et des entrées éventuelles de la FSM, des signaux internes à la FSM que nous nommerons xxx_i (xxx étant le nom du port de sortie correspondant) et représentant les valeurs à fournir en sortie lors de la prochaine transition.

Circuit Synchro : permet de détecter le front montant de l’horloge et à chaque détection il génère les sorties effectives sur les ports de la FSM en validant les signaux internes produits par Next_output. Il change également la valeur de l’état courant en fonction de l’état proposé par Next_node.

Ces trois circuits se programment en VHDL par trois process au sein de la même architecture behavioral. Les signaux internes xxx_i doivent être définis localement pour cette architecture. Chaque process se limite à un code séquentiel principalement construit avec des If Then Else et des Case qui ne sont rien d’autre que des If multiples comme dans tous les langages de programmation. La particularité d’un process reste la liste de sensibilité. Ce ne sont pas des paramètres de fonction ou autres, c’est une liste de signaux en entrée qui doivent être observés par le process afin de pouvoir réagir à tous changements de valeur sur un de ces signaux. Entre deux changements le circuit garde exactement le même fonctionnement puisqu’il garde les mêmes entrées. Nous placeront dans cette liste tous les ports d’entrée et signaux internes de notre FSM présents dans les prédicats de nos If ou Case. La création d’une FSM devient systématique dès l’instant où l’automate et les ports sont définis.

Vous pouvez commencer les modifications de votre FSM pour cet automate de contrôle des feux.

1. Déclarez les signaux internes correspondants aux ports de sortie, ici on doit déclarer Led_i.

1. Déclarez à la suite les noms de vos états (les nœuds de l’automate). On utilise un type énumératif, ISE transformera ce type en mots binaires pour vous. Déclarez ensuite les deux états qui permettront d’avancer dans l’automate state pour l’état actuel et next_state pour l’état suivant.

1. Commençons par le process Next_output. Ce process est sensible à state : pour chaque état il faut définir les prochaines valeurs de sortie de led en fonction de la transition. Vous allez créer le process avec State dans la liste de sensibilité. Avant toute chose TOUS les signaux internes xxx_i doivent recevoir une valeur par défaut, ISE sera alors en mesure de générer du code efficace. Ensuite le code se limite à un Case en fonction de l’état courant : chaque fois que state change d’état le process modifie le signal Led_i en respect de l’automate spécifié.

1. Le second process va permettre de prévoir le prochain état actif de votre automate. Ici encore le process ne sera sensible qu’au signal state, il n’y a pas de signaux en entrée pour l’instant. On obtient un process du même style construit autour d’un Case. Le but de ce process est de produire la valeur du signal next_state. Son fonctionnement reprend la structure de votre automate.

1. Il vous reste le process Synchro. Celui-ci n’est sensible qu’au signal d’horloge clk. Il doit détecter le front montant de clk et alors seulement appliquer le changement d’état courant et la mise à jour des sorties depuis les signaux internes xxx_i.

Vous êtes en mesure de lancer la simulation. Vous pouvez ajouter une nouvelle source de type VHDL Test Bench nommée fsm_tb. ISE va anticiper votre travail, il reconnait clk comme une horloge et va créer le process qui stimule ce signal. Il vous reste ici à commenter le process de stimuli stim_proc car seul clk sera généré par le simulateur. Le résultat obtenu vous valide la périodicité des affichages de Led. Vous pouvez créer le symbole de fsm.

Figure 61 Simulation de la fsm

Allez-y pour la synthèse, il vous faut donc ajouter à votre projet une copie du fichier S3.ucf modifié lors du TP4, une copie de clkdiv.sch dont vous allez produire le symbole. Placez dans toplevel une instance de clkdiv, une instance de fsm. Connectez clksec à l’entrée de votre fsm. Placez les deux I/O Marker sur les ports clk et Led(7:0). ISE créera pour vous directement les deux fil et bus qu’il faudra renommer clk et led(7:0). La compilation peut être lancée puis chargez le toplevel.bit sur la carte.

Figure 62 Toplevel tricolore

FSM avec entrée

Figure 63 FSM tricolore avec travaux

Vous allez transformer votre fsm de telle sorte que lorsque le switches(0) est actif, les feux se mettent en mode travaux c’est-à-dire en clignotement Orange sur les deux axes. Les contraintes de réactivité étant faible pour ce système, je vous propose de passer en mode travaux seulement quand votre automate est dans l’état Rouge_Vert. Il faut donc transformer votre automate en ajoutant deux nouveaux états Orange_on, Orange_off. Les modifications à apporter à votre FSM sont de plusieurs types :

1. Ajoutez un port en entrée, je vous propose de le nommer travaux.

1. Ajoutez deux nouveaux états dans votre définition de type : Orange_on et Orange_off.

1. Modifiez le process Next_node afin de réaliser votre nouvel automate qui prend en compte cette nouvelle entrée.

1. Modifier Next_output de façon à faire clignoter les Oranges sur les deux axes.

La simulation par fsm_tb ne fonctionne plus, puisque travaux n’était pas défini auparavant. Je vous propose de créer une nouvelle source VHDL test bench nommée fsmtravaux_tb qui sera associée à votre nouvelle fsm. Il faut cette fois stimuler le signal travaux pendant un certain laps de temps. Il suffit pour cela d’ajouter dans le process Stim_proc le bout de code suivant :

La simulation est lancée sur fsmtravaux_tb. Vous observez le comportement suivant.

Figure 64 Simulation fsm avec travaux

Pour la vérification sur la carte il vous faut modifier toplevel. ¹ Avant tout il faut recréer le symbole associé à fsm par un Create schematic symbol visible en mode implementation : les ports ne sont plus les mêmes, il y a maintenant un port d’entrée travaux qui doit apparaître. Pour mettre à jour ce symbole dans toplevel, il suffit de faire un clic gauche sur la page, vous obtenez la liste des symboles obsolètes avec la possibilité de le mettre à jour en cliquant Update. Allez-y pour fsm. En rouvrant la fenêtre associée à toplevel, on obtient un autre écran de mise à jour des symboles obsolètes du même genre.

Figure 65 Mise à jour des symboles obsolètes

Ajouter un bus et son I/O Marker nommé switches(7:0).Placez un Bus Tap entre switches(0) et le port travaux. Ça doit être prêt pour la compilation et exécution sur la carte. À vous de tester la réactivité du switches(0).

Figure 66 Toplevel fsm avec travaux

FSM avec entrées et sorties

On peut toujours construire une FSM où la séparation entre ces trois fonctions est respectée. La construction de l’automate reste le point crucial de la conception, ensuite ce n’est qu’un travail de traduction en VHDL. D’ailleurs certains outils existent et le font pour vous à partir d’une interface graphique permettant la construction d’une FSM. Je vous conseille de construire si possible des automates simples donc avec le moins d’états possible.

Vous allez ajouter à votre automate une nouvelle fonctionnalité à vos feux de croisement. On vous demande d’avoir un temps d’affichage d’un feu vert 8 fois plus long sur un axe. Comment modifier votre automate ? Vous pourriez ajouter 7 autres nœuds Vert_Rouge1… Vert_Rouge7. Ces états intermédiaires s’intercaleraient entre Vert_Rouge et Orange_Rouge et ne seraient utiles que pour laisser passer le temps. Je vous propose plutôt d’utiliser un compteur externe à la FSM. Celui-ci doit être initialisé à zéro quand l’état courant est Rouge-Orange via l’activation d’un signal de sortie reset_cpt. Le compteur est incrémenté à chaque top d’horloge indéfiniment. Sa sortie est un signal d’entrée pris en compte par Next_node. Elle permet de passer sur l’état suivant Vert_Rouge lorsque la valeur atteinte est égale à 7.

Figure 67 FSM avec compteur sur un axe

Si vous désirez garder une copie de la FSM précédente, faites juste un File>Save As avec le nom fsm_travaux.vhd. Fermez la fenêtre associée et ouvrez celle de fsm.vhd à nouveau. Vous allez créer une nouvelle source de type Schematic nommée controleur. Je vous propose d’y instancier un compteur CB4CE que vous trouverez sous la bibliothèque counter. Maintenant il faut modifier le fichier fsm.vhd.

1. Ajoutez les nouveaux ports en entrée et sortie ici deux ports reset_cpt et cpt dans l’entity.

1. Ajoutez un signal interne pour chaque nouveau signal de sortie, ici pour reset_cpt vous créez le signal reset_cpt_i.

1. Dans le process Next_ouput, il faut initialiser le nouveau signal interne reset_cpt_i, puis placez les activations dans les bons nœuds, ici reset_cpt_i dans l’état Rouge_Orange devient actif.

1. Dans le process Next_node vous devez prendre en compte la modification du comportement de votre automate. Comme le signal Cpt apparaît dans les prédicats de notre process il doit aussi apparaître dans la liste de sensibilité.

1. Dans le process Synchro, il vous suffit de valider les nouveaux ports de sortie à partir des nouveaux signaux internes.

Vous pouvez alors générer le symbole associé à FSM et en placez une instance dans votre schéma controleur.sch. La sortie reset_cpt doit être connectée à l’entrée CLR (Clear) du CB4CE. Placez un bus en entrée de Cpt et nommez-le Cpt. Avec 4 Bus Tap connectez les sorties Q3 Q2 Q1 Q0 aux fils du bus Cpt de même indice (commencez par Q3 sur Cpt(3)). Le même fil d’horloge clk est connecté à C et clk de chacun des composants, placez-y de suite l’I/O Marker. IL faut aussi un I/O Marker led(7:0) et sur travaux. Enfin l’entrée CE est forcée à 1 par un symbole Vcc. Vous pouvez créer le symbole controleur pour la suite.

Figure 68 Contrôleur avec compteur

Pour la simulation de votre contrôleur, créez un fichier controleur_tb de type VHDL test bench. Il suffit de générer l’horloge clk pour observer le comportement de notre composant. Vous l’avez déjà fait lors de la leçon 4.

La simulation vous permet de comprendre pourquoi cpt est comparé à la valeur 6…

Figure 69 Simulation du contrôleur

Dernière étape, vous allez placez un composant controleur dans toplevel à la place de fsm. Vous pouvez ensuite le tester sur la carte.

Figure 70 Toplevel avec contrôleur

A vous de jouer

Proposez un feu de croisement avec 8 cycles sur NS et 4 cycles sur EO. Un seul compteur devrait suffire…

Réponses

1^. Il arrive que le fichier ne soit plus visible dans la hiérarchie de design. Dans ce cas il faut sous l’onglet Files cliquer droit sur le fichier et remettre le Source Properties> View Association à All.