# Very High Speed Integrated Circuit Hardware Description Language/Travail pratique/TPs ATTiny861 avec Altera

Nous allons présenter dans ce chapitre une série de 6 TPs réalisés avec une carte Altera DE2-115. Il s'agit de réaliser un compteur de passages d’abord sans processeur puis avec un processeur sans périphérique particulier. On ajoutera ensuite petit à petit des périphériques.
Pour information, ces TPs ont été réalisés avec un format de 6 TPs de durée 1h30 et des étudiants de deuxième année de Génie Électrique (2015/2016). Avec ce format, la seule chose qui peut être réalisée est du TP dirigé ! Il faudrait deux ou trois heures par séance pour un fonctionnement plus interactif avec une plus grande autonomie des étudiants. Le sixième TP n'a pas été réalisé mais a été remplacé par le septième qui est une évaluation. L'objectif était de montrer à des étudiants la possibilité d’utiliser des périphériques sophistiqués pour simplifier la programmation. Il a donc été partiellement atteint avec le TP 5.
Pour éviter la création d'un autre chapitre, nous avons complété cette série par une autre série de 6 TPs qui seront réalisés dans les mêmes conditions que la première série. Ces TPs seront numérotés TP1b, TP2b, ... et TP6b et auront pour thème la réalisation partielle d'un réveil sur des afficheurs 7 segments.
Puis... nous avons encore créé une série de 6 TPs avec un thème similaire : le réveil. Sa sortie est par contre réalisée sur l'afficheur LCD de 2x16 caractères. Ils seront numérotés de TP1c à TP6c. Ils ont été réalisés en 2016/2017 par des étudiants de GEII 2ᵉ année.

## Introduction

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7. La série d'exercices proposée ici peut certainement être réalisée avec d'autres cartes terasIC, comme la DE-2 et même probablement la DE-1. La seule chose qu’il vous faudra adapter sera le fichier de contraintes. Pour le reste, rien à changer !
Le processeur embarqué qui est utilisé dans ces séries de TPs a été conçu par Andreas Hilvarsson. Il a écrit ce cœur ATTinyx61 et l'a publié chez Opencores.org. Nous l'utiliserons avec une mémoire programme de 8ko, d'où l'appellation ATTiny861 dans ce cours. Il sera programmé en C.
Le compteur de passages est évoqué dans un autre livre : Compteur de passages revu et corrigé. Il sera le fil conducteur de la première série de TPs (TP1 à TP7).
Le réveil sera abordé dans la deuxième série de TPs (TP1b à TP6b) comme dans la troisième série (TP1c à TP6c). La différence entre les deux séries est l'affichage : soit sur des afficheurs sept segments soit sur un afficheur lcd.
Nous allons, dans cette première série de TPs, construire d’abord complètement un compteur de passages sans processeur. Une fois terminé, nous allons utiliser un processeur (embarqué) sans périphérique particulier. Pour terminer cette série, nous allons d’abord déporter le transcodage vers l'extérieur, puis l’ensemble des deux compteurs BCD et des deux transcodeurs. L'objectif de ce travail est donc de bien comprendre les rapports entre le matériel et le logiciel pour des exemples relativement simples.

## TP 1 (1h30)
### Exercice 1

On vous demande simplement de réaliser un transcodeur pour afficher tout nombre sur 4 bits (entrée) sur un afficheur 7 segments. Avec notre carte DE2-115, pour allumer un segment il faut mettre un '0' sur la broche correspondante. Une autre caractéristique est l'absence de multiplexage des afficheurs sept segments. Pour information il y en a 8 sur la carte en question et cela nécessite donc 8x7=56 broches de FPGA.

#### Indication 1

Vous devez réaliser l'architecture correspondante pour l'entité VHDL suivante :
Si le nom des entrées sorties ne vous convient pas, changez-les mais assumez alors ces changements lors des nombreux câblages de ce transcodeur. Tous nos schémas gardent cette convention de noms, à commencer par le fichier de contraintes que nous donnons maintenant.

#### Indication 2

Le fichier de contraintes sera :
L'enseignant vous expliquera comment trouver ces contraintes avec la documentation de la carte.

### Exercice 2

Réaliser la même chose avec deux afficheurs. On aura donc maintenant 8 entrées et 14 sorties. On vous demande cette réalisation avec deux composants correspondant à l'exercice 1 (transcodeurs)
Le fichier de contraintes sera :
Nous mettons ici un lien vers les corrigés qui se trouvent sur le WIKI de l'IUT de Troyes. Comme ces TPs sont effectivement réalisés par les étudiants, les solutions en question ne sont accessibles qu'en accès réservé sur une partie de l'année. Essayez le lien, il est librement accessible une quarantaine de semaines dans l'année :
* Corrigé du TP1

## TP 2 (1h30)

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.

### Exercice 1

En vous aidant du compteur décompteur décimal présenté ici, on vous demande de compléter le code pour faire un compteur décimal cascadable.

### Exercice 2

Le compteur cascadable de l'exercice 1 doit être testé. Pour cela vous devez lui envoyer une horloge lente. Vous allez donc assembler :
* un compteur destiné à réaliser une horloge lente (division par 2**24)
* deux compteurs décompteurs décimaux cascadés
* deux transcodeurs
Le fichier de contraintes sera :
Ce fichier de contraintes correspond à "en" interrupteur complètement à droite, "DownUp" juste à côté et "Init" complètement à gauche.
Nous mettons ici un lien vers les corrigés qui se trouvent sur le WIKI de l'IUT de Troyes. Comme ces TPs sont effectivement réalisés par les étudiants, les solutions en question ne sont accessibles qu'en accès réservé sur une partie de l'année. Essayez le lien, il est librement accessible une quarantaine de semaines dans l'année :
* Corrigé du TP2

## TP 3 (1h30)

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Le compteur de passages comporte deux entrées capteurs notés CapteurDroit et CapteurGauche qui sont supposés détecter un passage. Pour nous ce sera deux interrupteurs. L'objectif du montage est de compter le nombre de personnes dans une pièce (à une seule entrée) ou de voitures dans un parking (lui aussi à une entrée). On considère donc que lorsqu'on passe devant un capteur puis devant l'autre on entre dans la pièce (ou dans le parking) et lorsque les choses se passent dans l'autre sens on sort. Un séquenceur devra être couplé à un compteur décompteur pour réaliser ce cahier des charges.

### Exercice 1

Réaliser le séquenceur en complétant le code correspondant trouvé ICI dans un autre livre. Vous allez ensuite assembler :
* un compteur destiné à réaliser une horloge lente (division par 2**20) : ce sera l'horloge générale
* un séquenceur
* deux compteurs décompteurs décimaux cascadés
* deux transcodeurs
Le fichier de contrainte sera :
CapteurDroit est l'interrupteur complètement à droite, CapteurGauche est juste à côté tandis que Init est complètement à gauche.
Voici en schéma ce que vous devez réaliser.
Notez que ce séquenceur suppose qu’il n’est pas possible d’avoir en même temps capteurGauche et capteurDroit. Si ce n’est pas le cas, il serait bon d'ajouter un état sur chaque branche.

### Exercice 2

Changer le séquenceur pour laisser la possibilité de réaliser un demi-tour.
Nous mettons ici un lien vers les corrigés qui se trouvent sur le WIKI de l'IUT de Troyes. Comme ces TPs sont effectivement réalisés par les étudiants, les solutions en question ne sont accessibles qu'en accès réservé sur une partie de l'année. Essayez le lien, il est librement accessible une quarantaine de semaines dans l'année :
* Corrigé du TP3

## TP 4 (1h30)

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Indication : Pour la mise à jour du contenu de la mémoire seulement, sans passer par un temps de recompilation complet de l’application (donc plus ou moins équivalent à data2mem), il faut valider l'option "use smart compilation". Pour y accéder : menu assignements => settings => compilation process settings => puis cocher l'option. Ne pas oublier de faire "apply" avant de quitter la fenêtre !
Vous allez maintenant réaliser vos premiers programmes en C destinés à un processeur dans le FPGA. Le code source complet du processeur vous est donné. Vous allez donc réaliser un projet pour compiler ce processeur. Cette compilation peut être assez longue (près de 10 min) mais la simple mise en RAM/ROM du programme ne prendra que 2 min une fois cette première compilation réalisée.
Voici sous forme schématique l’ensemble du processeur.

### Ressources

Andreas Hilvarsson a écrit ce cœur ATTiny861 et l'a publié chez Opencores.org. Nous avons modifié sa façon d'y créer des périphériques et en particulier retiré tous les PORTs bidirectionnels qui ne servent à rien dans un FPGA. Nous en avons fait aussi une version directement utilisable pour les circuits Altera.
* L'hébergement de mon site perso se termine le 5 septembre 2023 ! À ce jour je n'ai pas encore décidé comment je vais gérer ce problème dont je ne suis pas à l'origine. Il en résulte que les liens de l'ensemble des corrections qui utilisent mon site perso seront indisponibles à partir de cette date pour tout ce livre. Cela concerne entre autre la remarque ci-dessous !
Nous mettons la ressource complète sur notre site : M4209TinyStart.zip. Tant qu'elle est disponible, il est inutile de lire la suite de cette section. Cette ressource est destinée uniquement aux circuits Altera. Pour une version Xilinx, cherchez dans le chapitre précédent.
Mon site n'étant pas indéfiniment disponible, nous en publions ici une version utilisée dans ce TP. Les modifications citées n'ont été réalisées que dans le fichier "microcontroleur.vhd".

#### Fichier top

Toutes les modifications qui seront demandées dans les TPs suivants seront à effectuer dans ce fichier (et ce fichier seulement).

#### Fichier mémoire ROM

Ce fichier est donné et expliqué dans l'annexe I plus loin.

#### Fichier de contraintes

Nous donnons le fichier de contraintes sous la forme csv. Il vous faudra importer ce fichier pour qu’il soit pris en compte.
Ce fichier pourra être utilisé pour toute la partie processeur du TP.

### Pour information

Pour information la réalisation des périphériques en sortie a été réalisée comme dans la figure ci-contre. Rappelez-vous que la réalisation de périphérique de sortie se fait dans le fichier microcontroleur.vhd et dans le process iowr... et que c’est ce qui est montré dans cette figure.

### Exercices

Voici un exemple de programme C :
Repérez dans ce code comment ne pas aller trop vite, comment décaler une valeur, comment sortir sur les leds....

#### Exercice 1

Vous allez réaliser divers chenillards dans un premier temps :
* chenillard gauche droite (très facile non ?)
* chenillard droite gauche
* chenillard droite et gauche simultanés
* chenillard à accumulation

#### Exercice 2

On vous donne deux sous-programmes facilitant cet exercice :
ainsi qu'un tableau de valeurs précalculées
Vous allez réaliser divers compteurs et utiliser le ou les afficheurs sept segments.
* compteur binaire assez lent pour que l’affichage se fasse correctement en hexadécimal sur deux digits
* compteur décimal sur deux digits
Notez que c’est à vous, programmeur, de réaliser le transcodage. Un moyen simple de faire cela est d’utiliser un tableau. Ce n'est peut être pas un hasard si l’on vous a donné un tableau.

#### Exercice 3

Réaliser le compteur de passages. On vous demande de repérer dans le code ci-dessous la réalisation du séquenceur.
Modifier ce code pour être plus conforme au séquenceur du TP3 (7 états contre 5 ici).
Nous mettons ici un lien vers les corrigés qui se trouvent sur le WIKI de l'IUT de Troyes. Comme ces TPs sont effectivement réalisés par les étudiants, les solutions en question ne sont accessibles qu'en accès réservé sur une partie de l'année. Essayez le lien, il est librement accessible une quarantaine de semaines dans l'année :
* Corrigé du TP4

## TP 5 (1h30)

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7. Nous mettons la ressource complète sur notre site : M4209TinyStart.zip.
Nous allons déporter le transcodage du langage C vers le matériel, comme le montre la figure ci-contre.
Vous devez remarquer sur cette figure que maintenant le PORTB (8 bits) permet de commander deux afficheurs sept segments. Votre seul problème maintenant est de réaliser un compteur BCD sur 8 bits et de sortir sa valeur dans PORTB.

### Exercice 1

Réaliser la partie matérielle dans microcontroleur.vhd en ajoutant les deux transcodeurs.

### Exercice 2

Réaliser C un compteur BCD qui compte ou décompte en fonction d'une entrée sur un interrupteur. Évidemment ce que l’on vous demande de faire ici, c’est un programme C qui sera compilé et chargé dans le processeur.

### Exercice 3

Refaire le compteur de passages correctement. Inspirez-vous de ce que vous venez de faire dans l'exercice précédent et du compteur de passages du TP précédent.
Nous mettons ici un lien vers les corrigés qui se trouvent sur le WIKI de l'IUT de Troyes. Comme ces TPs sont effectivement réalisés par les étudiants, les solutions en question ne sont accessibles qu'en accès réservé sur une partie de l'année. Essayez le lien, il est librement accessible une quarantaine de semaines dans l'année :
* Corrigé du TP5

## TP 6 (1h30)

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7. Nous mettons la ressource complète sur notre site : M4209TinyStart.zip.
Nous arrivons maintenant au terme de notre série de TPs. Notre objectif maintenant est d'ajouter les deux compteurs BCD comme périphériques. Ils attaqueront les deux transcodeurs qui seront chargés de l'affichage.
À partir de maintenant, fini les calculs d'additions et de soustractions BCD en C. C'est le matériel qui fera tout. Bien, le matériel fait tout mais il faut lui en donner l'ordre. Et cela, c’est de la responsabilité du processeur.
Il y a plusieurs possibilités pour réaliser cela. Nous avons choisi de réaliser cela de la manière suivante :
* le processeur est incapable de mettre une valeur particulière dans les deux compteurs BCD
* pour incrémenter le processeur écrit '1' dans le PORTB
* pour décrémenter, le processeur écrit '0' dans le PORTB

### Exercice 1

* Réaliser la partie matérielle correspondant à la figure.
* Modifier et tester le programme du compteur de passages
La compréhension de la présence de la bascule D n’est pas forcément très facile à appréhender. Elle est liée au fait que le bit de poids faible de PORTB sert à changer l'entrée UD (choix comptage ou décomptage) des deux compteurs. Si en même temps on valide avec 'en' et bien on aura toujours un temps de retard. En retardant, on positionne d’abord 'UD' puis on valide le comptage ou le décomptage.

### Exercice 2

Modifier, pour terminer, la partie matérielle pour que la lecture par le processeur des deux compteurs BCD soit possible. Réaliser maintenant un programme pour tester. Une idée possible est d'afficher la valeur lue sur les LEDs du PORTA qui ne sont pas utilisées.
Nous mettons ici un lien vers les corrigés qui se trouvent sur le WIKI de l'IUT de Troyes. Comme ces TPs sont effectivement réalisés par les étudiants, les solutions en question ne sont accessibles qu'en accès réservé sur une partie de l'année. Essayez le lien, il est librement accessible une quarantaine de semaines dans l'année :
* Corrigé du TP6

## TP 7 Évaluation (1h30)

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7. Nous mettons la ressource complète sur notre site : M4209TinyStart.zip.
1°) À partir de la Correction du TP6, on vous demande de montrer que vous êtes capables de :
* faire un projet à partir de la ressource fournie
* mettre au bon endroit le programme C donné dans la correction
* le transformer en fichier .mif
* compiler la partie matérielle en remplaçant le microcontroleur.vhd de la ressource par celui de la correction
* faire le test qui montre que l’on a bien un compteur de passages
2°) Vous allez maintenant ajouter 8 leds en supplément dans votre microcontrôleur pour réaliser un chenillard sur 16 leds. Les 8 premières leds sont présentent depuis le TP4 et sont commandées par PORTA. Les 8 nouvelles seront reliées à DDRB qui n'est plus utilisé. Montrer que vous êtes capable de rajouter une sortie sur 8 bits comme indiqué dans le schéma ci-dessous :
Comme d'habitude, ce que vous avez à réaliser est indiqué en rouge. Tout ce qui est en noir est déjà réalisé dans la correction qui est accessible.
Les leds ajoutées nécessitent l'ajout des contraintes :
Réaliser ensuite un chenillard simple montrant le bon fonctionnement. Il devra obligatoirement être sur 16 LEDs.
* À partir de maintenant, c'est une autre série de TP qui commence.
L'objectif de ces Travaux pratiques est de réaliser partiellement un réveil. Les trois premiers TP réalisent un comptage pour réveil en logique traditionnelle avec des composants combinatoires, les transcodeurs sept segments, et des composants séquentiels, des compteurs décimaux et modulo 6. Puis nous introduirons un processeur pour faciliter la gestion du réveil.

## TP1b : Réalisation d'un transcodeur sept segments

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Pour commencer simplement avec l'environnement Quartus, nous allons réaliser le célèbre transcodeur 7 segments.

### Exercice 1

Vous partirez du code suivant :
Le fichier de contraintes sera :

### Exercice 2 : Utilisation de 4 digits

On désire étendre le travail réalisé en exercice 2 sur 4 digits.
Le fichier de contraintes sera :
et vous donne le nom de vos entrées et des sorties.

## TP2b : Réalisation d'un réveil HH:MN à Trois hertz

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Nous disposons d'un compteur BCD sur 4 digits et nous allons réaliser un réveil en modifiant un peu l'ensemble.

### Exercice 1 : Faire fonctionner l'ensemble donné

Nous allons réaliser ce qui est présenté dans la figure ci-contre mais sans le multiplexeur. Le retrait du multiplexeur est lié à la gestion des afficheurs sur la carte qui va nous servir pour les TPs. Sur cette carte il n'y a aucun multiplexage, c'est-à-dire qu'il est possible d'envoyer des valeurs différentes sur chacun des afficheurs sept segments.
Étant donné que chacun des compteurs a une sortie sur 4 bits et que celle-ci doit commander un affichage 7 segments, il faut donc remplacer le multiplexeur par 4 transcodeurs.
Pour vous entraîner à la lecture des "PORT MAP", un exercice intéressant est de partir du code donné ci-dessous et de refaire le schéma correspondant. Une autre manière de dire les choses est que le schéma ci-contre donne l'idée générale (cascader des compteurs BCD) mais ne représente pas complètement le code ci-dessous. Nous garderons cet étrangeté pour vous obliger à faire un dessin.
On vous donne donc le code suivant :
Le fichier de contraintes sera :

### Exercice 2 : Compteur modulo6

Pour compter les dizaines des minutes, il nous faut un compteur modulo 6 qui soit cascadable. Modifier le compteur BCD donné pour qu'il compte de 0 à 5 et génère un signal ENO quand il est à 5 et quand son entrée EN est à 1.
Indication : le compteur BCD à modifier est donné ci-dessous :
Vous remplacerez le compteur des dizaines des minutes par ce nouveau compteur et en ferez un test. Restera donc la réalisation correcte des heures.

### Exercice 3 : Compteur des heures

Nous allons ajouter un comptage correct des heures au compteur de l'exercice 2 qui compte normalement la partie minutes.
Le comptage des heures est lui aussi très particulier. Les unités nécessitent un compteur décimal mais qui doit être interrompu lorsque les dizaines passent à 2 ! On ne doit pas alors dépasser 3. Nous allons utiliser un montage bouclé pour réaliser cela : lorsque l'on est à 23, un EN='1' fait repasser les heures à 0. Ce n'est pas la peine de le faire pour les minutes, cela sera automatique.
Indication : la gestion du bouclage peut être réalisé par quelque chose du genre :
Faites un schéma pour comprendre.
D'abord la correction du schéma :
Vous devez retirer le multiplexeur pour ce que l'on vous demande et le remplacer par 4 transcodeurs binaire vers sept segments.
Vient ensuite le code source :
Le fichier de contraintes correspondant est :

## TP3b : Réaliser un réveil qui sonne

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Le graphe d'évolution du réveil qui sonne est présenté ci-contre. La réalisation de ce graphe d'évolution nécessite la réalisation de ses deux entrées :
* Key : sera simplement une entrée (un switch). Il sert pour l'armement de la sonnerie du réveil.
* Trip : détecte que l'heure de sonnerie est égale à l'heure courante. L'heure courante est naturellement réalisé par le travail du TP2. L'heure de réveil à ce stade sera réalisée par 16 interrupteurs
La sortie sonnerie sera matérialisée par une LED. Une autre LED peut être utilisée pour matérialisée l'armement du réveil

### Exercice : Un réveil qui sonne

Le graphe d'évolution sera réalisé avec un case when et sans initialisation. Le test de bon fonctionnement ne peut se faire qu'avec deux interrupteurs en entrées (un pour ArmKey et un pour Trip) et pas à 50 MHz pour éviter la prise en compte des rebonds. La sortie se fera sur une LED.
Indication 1 : On rappelle encore une fois que le style « case when » permet de ne pas chercher les équations de récurrences. Mais comme nos diagrammes d'évolutions se sont compliqués (par l'ajout d'étiquettes sur les transitions), il nous faudra ajouter des "if then". Cela est tellement intuitif que nous passons directement aux exemples. Nous commençons par présenter partiellement le réveil.
Indication 2 : Programmation sans initialisation : le principe consiste à déclarer d'abord un type énuméré avec une définition symbolique de chacun des états (ici Armed, Off, Ringing) :
Ensuite dans un « case when » on détaillera toutes les transitions possibles comme montré ci-dessous dans le cas où l'on ne s'intéresse pas à une initialisation :
L'idée générale est donc d'utiliser un « case » sur les états avec des « if » pour gérer l'ensemble des transitions.
Indication 3 : Il serait bon d'ajouter au réveil une entrée ENA qui sera une division de l'horloge par 2**20. Ceci pour éviter les rebonds des interrupteurs.
Indication 4 : le réveil est abordé dans un autre livre sous toutes les formes et il est même possible d'y trouver une solution sans initialisation et avec l'entrée ena.

### Exercice 2 : Un réveil qui sonne (suite)

Compléter l'exercice 1 pour utiliser le séquenceur de la sonnerie mais avec Trip réalisé avec l'heure courante qui défile. Par contre l'heure de sonnerie sera réalisée par des interrupteurs.

## TP4b : Un processeur seul

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Indication : Pour la mise à jour du contenu de la mémoire seulement, sans passer par un temps de recompilation complet de l’application (donc plus ou moins équivalent à data2mem), il faut valider l'option "use smart compilation". Pour y accéder : menu assignements => settings => compilation process settings => puis cocher l'option. Ne pas oublier de faire "apply" avant de quitter la fenêtre !
Voir le TP4 de ce chapitre pour la présentation.
Évidemment, la ressource donnée n'est pas identique à celle du TP4 puisque nous avons besoin de 4 digits d'affichage. C'est ce qui est présenté dans la figure.
Votre objectif sera de prendre contact avec un processeur qui ne possède aucun périphérique. Votre travail consistera à réaliser :
* quelques chenillards
* un comptage BCD sur 4 digits, en utilisant les sous-programmes du TP4, puis

## TP5b : Déplacer les transcodeurs et s'en servir comme périphérique

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Indication : Pour la mise à jour du contenu de la mémoire seulement, sans passer par un temps de recompilation complet de l’application (donc plus ou moins équivalent à data2mem), il faut valider l'option "use smart compilation". Pour y accéder : menu assignements => settings => compilation process settings => puis cocher l'option. Ne pas oublier de faire "apply" avant de quitter la fenêtre !
L'utilisation de l'affichage sur quatre digits avec le Tiny861 nécessite l'utilisation de quatre registres : un par afficheur. Elle nécessite aussi l'utilisation d'un tableau pour transcoder. En clair pour que 0x1234 finisse sur les afficheurs sept segments il faut d'abord découper 0x1234 en quatre parties contenant 1, 2, 3 et 4 et les transcoder. Cela représente un travail important à réaliser par programme. Nous désirons simplifier le travail du programmeur en déplaçant le transcodage logiciel (par tableau) dans le matériel à l'aide des transcodeurs déjà réalisés dans les TPs précédents. L'affichage de 0x1234 sera alors simplement coupé en deux 0x12 et 0x34 et envoyés sur deux ports. Le transcodage sera alors complètement automatique.

### Exercice 1

* Réaliser le périphérique demandé. Ce qui est demandé est dessiné en rouge dans la figure de cette section.
* Modifier le programme de l'exercice précédent pour que l'on affiche toujours les heures d'un réveil sur ce nouveau matériel.

## TP6b : Un compteur complet comme périphérique

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Indication : Pour la mise à jour du contenu de la mémoire seulement, sans passer par un temps de recompilation complet de l’application (donc plus ou moins équivalent à data2mem), il faut valider l'option "use smart compilation". Pour y accéder : menu assignements => settings => compilation process settings => puis cocher l'option. Ne pas oublier de faire "apply" avant de quitter la fenêtre !
Nous allons utiliser la correction de l'exercice 3 du TP2b et en faire un périphérique. Il s'agit de l'ajouter à ce qui a été fait dans le TP5b. Ainsi l'heure du TP 5b correspond à une heure de réveil. Il est très facile de manipuler celle-ci en incrémentation ou décrémentation par un processeur.

### Exercice 1

Prendre les 4 compteurs HH:MM du TP2 et en faire un composant.
Il devra donc avoir 2 entrées :
* horloge encore appelée clk,
* EN entrée de validation qui est reliée à un signal de 3 Hz. Le processeur devra pouvoir accéder directement aux sorties de tous les compteurs, avant le transcodage. Celles-ci devront donc être des entrées pour le processeur.
Les nouvelles sorties globales sept segments devront utiliser quatre autre digits.
Montrer qu'après réalisation de la partie matérielle, vous êtes capable de détecter que l'heure réveil est égale à l'heure courante en allumant une LED.

### Exercice 2

Pouvez-vous améliorer le comportement de votre réveil pour un réglage de l'heure réveil ?
* À partir de maintenant, c'est une autre série de TP qui commence.

## TP1c : premier contact avec Quartus et l'affichage LCD

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7. Cette carte DE2-115 possède un afficheur LCD de deux lignes de 16 caractères.
Contrairement à ce qu'il se passe pour les TPs TP1 et TP1b, la sortie ne peut pas être directe sur l'afficheur LCD. Nous voulons dire que ce que vous allez réaliser est enfoui dans une partie de code VHDL qui est donné. Vous devez donc repérer l'entité et l'architecture à modifier pour arriver à vos fins.

### Exercice 1

On vous donne complètement le module qui affiche sur l'afficheur. Pour cela, nous allons essayer dans cette section, d'utiliser un module VHDL touvé chez Opencores. Il se trouve dans Projets → Other → 16x2 LCD controller et a été réalisé par Daniel Drescher. Pour éviter d'aller les chercher sur Internet, ces fichiers vous sont fournis maintenant.
* d'abord le fichier de démonstration
* puis le fichier du cœur lcd, fichier que l'on gardera tout au long de ce TP
1°) En suivant ce que fait l'enseignant, on vous demande de compiler et d'essayer le module d'Opencores.org
2°) Modifier le texte affiché à votre convenance
Indications :
* chercher les informations sur le code ASCII dans Wikipédia
* le fichier de contraintes vous est fourni :

### Exercice 2

Notre objectif étant d'afficher des heures minutes, nous allons spécialiser un peu cet afficheur. Dans un premier temps, on le destine à afficher les 4 digits d'un compteur binaire. En clair il doit afficher entre 0000 et FFFF. Mais l'exercice précédent vous a montré que l'afficheur lcd ne connaît que les codes ASCII. Vous aller réaliser un circuit combinatoire qui réalise cela. Comme il nous faut garder le gestionnaire de l'écran lcd, nous allons vous proposer un fichier lcd16x2_ctrl_demo.vhd modifié dans lequel on vous demande de modifier la partie combinatoire en fin de fichier.
Indications :
* on vous a préparé une horloge à 10 Hz pour le compteur
* L'ensemble donné fonctionne mais pas correctement : il affiche mal les chiffres au-delà de 9 !!!
* la seule chose que vous avez à réaliser est le transcodeur tout en bas du fichier. Vous remplacerez l'équation naïve par un "with select when"

## TP2c : réalisation d'un affichage HH:MN

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.

### Exercice 1

Le problème du transcodeur réalisé dans l'exercice 2 du TP1c peut être facilement résolu si l'on remplace les compteurs hexadécimaux par des compteurs BCD (qui ne comptent que de 0 à 9). C'est ce que fait le code ci-dessous. Vous y remarquerez la disparition du transcodeur de l'exercice 2 tu TP1c. Essayez de comprendre pourquoi.
Dans cet exercice, on vous demande simplement d'insérer un ":" entre les deux premiers digits et les deux derniers. On vous rappelle en effet que l'on finira par afficher les heures et minutes (qui en général sont séparées par ce ":") d'où le titre de ce TP.

### Exercice 2 : Compteur modulo6

Pour compter les dizaines des minutes, il nous faut un compteur modulo 6 qui soit cascadable. Modifier le compteur BCD donné pour qu'il compte de 0 à 5 et génère un signal ENO quand il est à 5 et quand son entrée EN est à 1.
Indication : le compteur BCD à modifier est donné ci-dessous :
Vous remplacerez le compteur des dizaines des minutes par ce nouveau compteur et en ferez un test. Restera donc la réalisation correcte des heures.

### Exercice 3 : Compteur des heures

Nous allons ajouter un comptage correct des heures au compteur de l'exercice 2 qui compte normalement la partie minutes.
Le comptage des heures est lui aussi très particulier. Les unités nécessitent un compteur décimal mais qui doit être interrompu lorsque les dizaines passent à 2 ! On ne doit pas alors dépasser 3. Nous allons utiliser un montage bouclé pour réaliser cela : lorsque l'on est à 23, un EN='1' fait repasser les heures à 0. Ce n'est pas la peine de le faire pour les minutes, cela sera automatique.
Indication : la gestion du bouclage peut être réalisé par quelque chose du genre :
Faites un schéma pour comprendre, avant d'en regarder la solution.
D'abord la correction du schéma :
Le multiplexeur n'existe pas dans ce que nous allons réaliser.
Nous mettons ici un lien vers les corrigés qui se trouvent sur le WIKI de l'IUT de Troyes. Comme ces TPs sont effectivement réalisés par les étudiants, les solutions en question ne sont accessibles qu'en accès réservé sur une partie de l'année. Essayez le lien, il est librement accessible une quarantaine de semaines dans l'année voire plus si le TP est abandonné :
* Corrigé du TP2c

## TP3c : réalisation d'une sonnerie

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Quand l'heure courante est égale à l'heure de réveil et que le réveil est armé il faut que le réveil sonne. Ceci doit être géré par une machine séquentielle que l'on cherche à réaliser.
Le graphe d'évolution du réveil qui sonne est présenté ci-contre. La réalisation de ce graphe d'évolution nécessite la réalisation de ses deux entrées :
* Key : sera simplement une entrée (un switch). elle sert pour l'armement de la sonnerie du réveil.
* Trip : détecte que l'heure de sonnerie est égale à l'heure courante. L'heure courante est naturellement réalisé par le travail du TP2. L'heure de réveil à ce stade sera réalisée par 16 interrupteurs
La sortie sonnerie sera matérialisée par une LED. Une autre LED peut être utilisée pour matérialisée l'armement du réveil

### Exercice 1 : Un mécanisme de sonnerie pour sonnerie de réveil

Vous allez partir de la correction de l'exercice 2 du TP2c disponible ICI
* Il n'y aura aucune interaction entre l'heure courante et l'heure réveil (qui n'existe pas à ce stade). On rajoute simplement l'automatisme de sonnerie. Ceci permet simplement un test de l'automatisme de sonnerie.
Ajoutez deux entrées (ArmKey et Trip) et une sortie "led_out" pour tester votre machine d'états. L'entrée "ena" du mécanisme de sera reliée à la sortie du timer "eno10Hz" du module "lcd16x2_ctrl_demo.vhd". Le fichier de contrainte sera :
avec Trip en sw0 et ArmKey en sw1.
Le graphe d'évolution sera réalisé avec un case when et sans initialisation.
Indication 1 : On rappelle encore une fois que le style « case when » permet de ne pas chercher les équations de récurrences. Mais comme nos diagrammes d'évolutions se sont compliqués (par l'ajout d'étiquettes sur les transitions), il nous faudra ajouter des "if then". Cela est tellement intuitif que nous passons directement aux exemples. Nous commençons par présenter partiellement le réveil.
Indication 2 : Programmation sans initialisation : le principe consiste à déclarer d'abord un type énuméré avec une définition symbolique de chacun des états (ici Armed, Off, Ringing) :
Ensuite dans un « case when » on détaillera toutes les transitions possibles comme montré ci-dessous dans le cas où l'on ne s'intéresse pas à une initialisation :
L'idée générale est donc d'utiliser un « case » sur les états avec des « if » pour gérer l'ensemble des transitions.
Indication 3 : Il serait bon d'ajouter au réveil une entrée ENA qui serait une division de l'horloge par 2**20. Ceci pour éviter les rebonds des interrupteurs.
Indication 4 : le réveil est abordé dans un autre livre sous toutes les formes et il est même possible d'y trouver une solution sans initialisation et avec l'entrée "ena".

### Exercice 2 : Un réveil qui sonne (suite)

Compléter l'exercice 1 pour utiliser le séquenceur de la sonnerie mais avec Trip réalisé avec l'heure courante qui défile. Par contre l'heure de sonnerie sera réalisée par des interrupteurs. Il serait bon aussi d'afficher correctement l'heure de réveil sur la deuxième ligne, en supposant qu'elle soit décimale.
Indications :
* Vous partirez de la correction : Corrigé du TP2c
* l'entité du fichier lcd16x_ctrl_demo.vhd devra donc évoluer maintenant :
* vous remarquez l'apparition de l'entrée HHMMAlarm sur 16 bits. Elle sera donc reliée aux interrupteurs de la carte.
* l'entrée Trip a disparu. Elle doit être remplacée par un signal, par exemple "egalite" pour coller à l'égalité de l'heure courante et de l'heure de l'alarme.
* le fichier de contraintes peut être :
* le code VHDL pour réaliser un test d'égalité peut être :
Nous mettons ici un lien vers les corrigés qui se trouvent sur le WIKI de l'IUT de Troyes. Comme ces TPs sont effectivement réalisés par les étudiants, les solutions en question ne sont accessibles qu'en accès réservé sur une partie de l'année. Essayez le lien, il est librement accessible une quarantaine de semaines dans l'année voir plus si le TP est abandonné :
* Corrigé du TP3c

## TP4c : Un processeur seul

Comme nous utilisons la carte DE2-115, le FPGA utilisé est un Cyclone IVE de référence EP4CE115F29C7.
Indications :
* Pour la mise à jour du contenu de la mémoire seulement, sans passer par un temps de recompilation complet de l’application (donc plus ou moins équivalent à data2mem), il faut valider l'option "use smart compilation". Pour y accéder : menu assignements => settings => compilation process settings => puis cocher l'option. Ne pas oublier de faire "apply" avant de quitter la fenêtre !
* La figure représente schématiquement la ressource que vous avez à disposition. Elle utilise directement l'afficheur lcd comme en TP3c. Pour être précis, l'affichage ne se fera pas exactement au même endroit qu'en TP3c ! L'heure courante du TP3c est gardée en matériel et le processeur n'agit que sur l'heure réveil.
Voir le TP4 de ce chapitre pour la présentation.
Évidemment, la ressource donnée n'est pas identique à celle du TP4 puisque nous avons besoin de 4 digits d'affichage et en plus l'affichage se fait sur lcd. Nous mettons la ressource complète sur notre site : TinyReveilLCDStart.zip. Cette ressource est destinée uniquement aux circuits Altera. Pour une version Xilinx, cherchez dans le chapitre précédent.
Votre objectif sera de prendre contact avec un processeur qui est câblé comme dans la figure. Votre travail consistera à :
* comprendre l'organisation de la ressource avec le sous-répertoire soft qui est absolument obligatoire
* comprendre comment compiler un programme. Un script est disponible pour cela "compile_c.sh". il compile un programme qui a pour nom "test_tiny.c" pour en faire un fichier "test_tiny.mif"
* si vous êtes curieux, ouvrez le fichier "pm.vhd" et vous verrez que le contenu de la mémoire est donné par "test_tiny.mif"
* essayer de comprendre le rapport entre ce que vous voyez, sur les leds et le lcd, et le contenu du programme
* réaliser quelques chenillards
* réaliser un compteur binaire et afficher... Encore le problème des codes ASCII à résoudre. Comment le faire ?
* réaliser un comptage BCD sur 4 digits, en utilisant les sous-programmes du TP4, puis
* réaliser un comptage HH:MM (Pour la réalisation de l'arithmétique particulière des heures minutes :
* éditer le nouveau test_tiny.c (qui se trouve dans le sous-répertoire soft)
* lancer un Terminal (qui restera ouvert)
* aller dans soft qui doit ABSOLUMENT être un sous-répertoire du répertoire du PROJET
* lancer compile_c.sh (avec la commande ./compile_c.sh)
* retourner dans Quartus et compiler (en 2019 la smart compilation met 7s contre 1mn45 sur Intel Core i5)
* utiliser le programmateur pour télécharger dans le FPGA

## TP5c : Économiser deux PORTs

La figure du TP4c montrait l'utilisation d'un PORT par digit affiché sur l'écran lcd. Ainsi, il est possible d'afficher n'importe quoi sur les 4 digits à disposition.
Cependant, cela ne nous sert pas puisque nous avons l'intention de n'y afficher que des chiffres de 0 à 9.
Avec cette modification il n'est possible que d'afficher les chiffres de 0 à 9 et les caractères : ; < = > ? Pour ce que l'on désire faire c'est naturellement suffisant. Nous avons spécialisé au maximum notre afficheur.

### Exercice

1°) On vous demande donc de faire la gestion des affichages des nombres de 0 à 9 sur 4 digits avec deux PORTs seulement et, malgré tout, sans utiliser de transcodeur.
2°) Réaliser ensuite la gestion des heures minutes sur ces afficheurs. On vous donne un petit bout de programme en C capable de réaliser l'arithmétique spéciale des Heures minutes. Il n'y a plus qu'à sortir sur les afficheurs.
3°) Sur le même principe, on vous demande de réaliser une décrémentation heures/minutes.
Nous mettons ici un lien vers les corrigés qui se trouvent sur le WIKI de l'IUT de Troyes. Comme ces TPs sont effectivement réalisés par les étudiants, les solutions en question ne sont accessibles qu'en accès réservé sur une partie de l'année. Essayez le lien, il est librement accessible une quarantaine de semaines dans l'année voir plus si le TP est abandonné :
* Corrigé du TP5c
Voici le dode d'incrémentation et décrémentation d'un réveil HH:MM :