Travaux Pratiques
2024 – 2025
Master Ingénierie Digitale pour les Métiers de la Santé
VerilogHDL – FPGA
Session d’Automne
Enseignant: BABA
[Link]@[Link]
ENSAM Casablanca FPGA – Travaux Pratiques
Table des Matières
TP#1
Section 1 : Introduction & Setup
i. Outils précompilés
ii. Webfpga IDE
Section 2 : Premiers Pas
i. Blink
ii. Bouton
TP#2
Section 3 : Cœurs IP Soft
i. USART
ii. WS2812
TP#3
Section 4 : Mémoires
i. EBRAM
ii. SDRAM Exception
Règles de conduite
- Suivre ce document pour installer les outils de développement ;
- L’utilisation de Ubuntu (WSL2) est souhaitable pour réussir les applications du TP ;
- Préparer les TP avant de venir en classe. Tout ce qu’on peut faire chez-soi doit être fait chez-soi ;
- Le compte rendu du TP doit être envoyé en format PDF à l’adresse e-mail : mesnawi@[Link]
avant le samedi de la semaine du TP. Au-delàs de ce délai l’e-mail sera ignoré ;
- Un TP est réalisé en groupes de cinq (05) personnes maximum. Le nombre minimal de
personnes par groupe est de trois (03). Au-moins deux (02) étudiants par groupe devront assister
au TP. Un étudiant n’a pas le droit de passer seul le TP. C’est un travail d’équipe ;
- Une absence est équivalente à la note de 0. Pour toute absence planifiée, la personne doit
contacter le professeur en charge de TP avant le début de la séance ;
- La validation de chaque application avec le professeur de TP est obligatoire ;
- La note de chaque TP est la même pour l’ensemble des membres d’un groupe, mais elle devient
individuelle s’il s’avère qu’une seule personne fait tout le travail.
- Trois (03) points seront réservés à l’optimisation du code (le nombre de LUT consommées) ;
- La note des comptes rendus représente 20% de la note finale.
Master – Département GE – BABA 2 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Section 1 : Introduction & Setup
Ce guide est destiné pour la mise en marche de la carte webfpga : [Link]
Il est nécessaire d’installer python3 s’il n’est pas déjà installé.
Installer webfpga
Ouvrir le terminal [Link] et taper les commandes suivantes, une à la fois :
pip install webfpga #ou pip3 install webfpga
Pour vérifier que l’outil webfpga est installé, exécuter la commande :
webfpga --help
Pour Linux, ajouter les <<udev rules>> pour les permissions d’écriture et de lecture de USB.
# /etc/udev/rules.d/[Link]
# Run this command to reload the udev rules without rebooting:
# udevadm control --reload-rules && udevadm trigger
# [Link]
SUBSYSTEM=="usb", ATTR{idVendor}=="16d0", ATTR{idProduct}=="0e6c", TAG+="uaccess"
i. Outils précompilés
Les outils précompilés pour Linux, macOS et Windows via le projet Fomu-Toolchain.
Linux
export PATH=[path-to-toolchain]/bin:$PATH
Windows
Si vous utilisez PowerShell :
$ENV:PATH = "[path-to-toolchain]\bin;" + $ENV:PATH
Si vous utilisez [Link] :
PATH=[path-to-toolchain]\bin;%PATH%
Pour vérifier votre installation, exécuter la commande yosys :
yosys
Plusieurs étudiants ont rencontré un problème sous WINDOWS avec la commande webfpga qui
n’est pas reconnue dans le cas où vous avez plusieurs versions de python installées.
Master – Département GE – BABA 3 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Créer un répertoire de nom webfpga_app_1/ et y insérer les trois fichiers : top.v , makefile,
[Link] que vous trouverez en annexe. Ouvrir un terminal et exécuter la commande make :
make
Si tout est bon, un fichier [Link] sera généré. Connecter la carte au port USB de votre PC et
exécuter la commande make burn pour téléverser le fichier de configuration [Link] à la carte :
make burn
Le téléversement du fichier [Link] à la carte commence et après un moment la led sur la carte
commence à clignoter. Si vous rencontrez une erreur lié au port USB, exécuter la commande :
pip install libusb # et ajouter le chemin de la dll au PATH
ii. Webfpga ide
Aller à la page web : [Link] et cliquer sur Web IDE.
Trois grandes sections se présentent :
La partie centrale pour écrire vos codes VerilogHDL.
La partie de droite pour afficher les logs.
Sur les boutons de la partie de gauche :
- Appuyer une seule fois et attendre sur Run Synthesis (F4) pour lancer
la vérification, la synthèse et l’implémentation de votre code HDL afin
de générer le fichier de configuration bitstream
- Appuyer sur Connect Device (F9) pour connecter la carte à votre PC.
- En fin, appuyer sur Flash Device (F7) pour configurer votre FPGA.
- Cliquer sur le petit triangle pour utiliser un exemple précompilé. Une
liste déroulante affiche plusieurs exemples.
- Appuyer sur LOAD LOCAL FILE pour charger un fichier Verilog sur votre
machine.
Master – Département GE – BABA 4 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Section 2 : Premiers Pas
i. Blink
Application 1 Q1. Écrire un module fpga_top qui utilise l’horloge externe WF_CLK pour
clignoter la WF_LED à 1Hz ( 0.5s ON et 0.5s OFF)
Application 2 Q2. Écrire un module fpga_top qui utilise l’horloge interne 48Mhz pour
clignoter la WF_LED à 1Hz. Utiliser une instance du module : SB_HFOSC
SB_HFOSC #( .CLKHF_DIV("0b10")) hfosc (
.CLKHFPU(clkhfpu), .CLKHFEN(clkhfen), .CLKHF(clkhf));
ii. Bouton
Application 3 Q3. Écrire un module fpga_top qui connecte le buton poussoir blanc
(WF_BUTTON) de la carte à la led (WF_LED).
Application 4 Q4.1. Écrire un module fpga_top qui bascule l’état de WF_LED à chaque
appui sur WF_BUTTON. Q4.2. La LED réagit-elle à chaque appui ?
Qu'est-ce que le rebond de commutation ?
Lorsque le bouton de la figure ci-dessous est appuyé, la sortie !"#$ ne fournit pas un front
descendant net. Le problème réside dans les contacts mécaniques à l'intérieur de l'interrupteur.
Un circuit antirebond
Nombreuses approches pour éliminer les
rebonds d’un bouton poussoir. Le circuit
ci-contre utilise un trigger de schmitt après
un pré-filtrage passe bas de premier ordre.
L'idée est d'utiliser un condensateur pour
filtrer les transitions rapides du signal de
!"#$.
Master – Département GE – BABA 5 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Interrupteur ouvert Interrupteur fermé
Le condensateur (1 se chargera via &1 et *1. Le condensateur se déchargera à travers &2.
Avec le temps, !% atteindra !++ – 0.7V Avec le temps, !% atteindra 0.7V
Par conséquent, la sortie de l’inverseur à Par conséquent, la sortie de l’inverseur à
Trigger de Schmitt sera 0 logique. Trigger de Schmitt sera 1 logique.
Si un rebond se produit à courtes durées, la tension !% (fonction continue en $) changera lentement
et, l'hystérésis du Trigger de Schmitt empêchera la sortie de commuter. La résistance &2 est
nécessaire pour décharger le condensateur, sans elle, (1 sera court-circuité lorsque le bouton est
pushed . Sans la diode *1, (1 se chargera à travers &1 et &2, en augmentant le temps de charge.
Antirebond soft
L'idée est de sonder le signal !"#$ à intervalles réguliers et appliquer un filtrage. On suppose que
le bouton poussoir est connecté à une résistance de rappel.
Méthode 1
La première approche utilise un compteur. Si le signal reste à l’état logique 0 pendant une durée
prédéfinie, le bouton est alors considéré comme pushed et stable.
1. Déclarer une variable compteur, initialiser la variable à 0.
2. Établir un générateur de pulse (par ex. toutes les 10ms) pour sonder le signal switch.
3. Au moment de chaque pulse :
4. Si le signal switch est à 1 logique Alors
5. Reseter le compteur à 0.
6. Mettre l’état de switch à released
7. Sinon
8. Incrémenter le compteur d’un pas de 1
9. fin si
10. Si compteur =10 alors
11. Mettre l’etat de switch à pushed
12. Fin si
Master – Département GE – BABA 6 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Méthode 2
La deuxième approche utilise un registre à décalage, 8-bit, au lieu d'un compteur.
1. Déclarer un reg val 8-bit, initialiser le à 4’hff.
2. Établir un générateur de pulse (toute les 10ms) pour échantillonner le signal switch.
3. Au moment de chaque pulse :
4. Décaler le registre vers son MSB
5. Mettre le LSB à la valeur courante du switch
6. Si val = 0 Alors
7. Mettre l’état de switch à pushed
8. Sinon
9. Mettre l’état de switch à released
10. Fin si
Application 5 Q5. Modifier le code de l’application 4 pour améliorer le comportement de
la LED. Vous pouvez utiliser le module suivant qui implémente la méthode 2
:
module WF_switch ( input clk, en , in, output pushed, released, output reg out);
reg [2:0] switch;
reg out_d;
always @ (posedge clk)
begin
if (en) switch <= { switch[1:0],in };
if (switch == 3'b000) out <= 1'b0;
else if (switch == 3'b111) out <= 1'b1;
out_d <= out;
end // @ always(clk)
assign pushed = ~out && out_d;
assign released = out && ~out_d;
endmodule
Master – Département GE – BABA 7 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Section 3 : Cœurs IP Soft
i. USART
Principe
Une interface série est une méthode simple pour communiquer un FPFA et un PC.
Nous avons besoin d’un module récepteur et un autre transmetteur.
Transmetteur asynchrone
Il crée un signal TxD en sérialisant les données à transmettre.
Récepteur asynchrone
Il reçoit un signal externe RxD et le désérialise pour extraire les données à traiter dans le FPGA.
Comment l’interface série fonctionne ?
Une interface RS-232 a les caractéristiques suivantes :
• Utilise un connecteur DB-9 (DB-25 pour les anciens PC)
• Autorise une communication full-duplex
• La vitesse de communication maximale peut atteindre 10kBytes/s.
Connecteur DB-9
Il a 9 pins, mais seulement trois sont importants :
• Pin 2 : RxD (broche de réception de données)
• Pin 3 : TxD (broche d’émission de données)
• Pin 5 : GND (la masse).
Master – Département GE – BABA 8 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
En utilisant 3 fils vous pouvez envoyer et recevoir des données. Généralement, les données sont
envoyées par bytes (1 byte = 8 bits) : le bit 0 (LSB) est envoyé en premier.
Communication asynchrone
L’interface est sans horloge. Le récepteur synchronise sa ligne à la vitesse des bits reçus :
• L’émetteur et le récepteur doivent se mettre d’accord avant d’initier une transmission.
• L’émetteur envoie un état idle (= 1) et continue à envoyer un 1 tant que l’état est idle.
• L’émetteur envoie un état start (= 0) avant chaque octet (byte) envoyé, donnant ainsi la
possibilité au récepteur de savoir qu’un octet va être reçu.
• Les 8 bits d’un octet sont transmis.
• L’émetteur envoie un état stop (= 1) après chaque octet transmis.
L’exemple suivant illustre l’envoie de l’octet 0x55 :
0x55 vaut 01010101b. Mais le bit-0 envoyé en premier, la trame apparait inversée : 10101010.
Un autre exemple pour envoyer 0xC4 :
Il est parfois difficile de lire les bits envoyées. D’où la nécessité pour le récepteur de savoir la
vitesse à laquelle les bits sont transmis.
Vitesse de transmission
L’unité de la vitesse de transmission est le baud, c.-à-d. le nombre de bits-par-seconde à envoyer.
Des vitesses de communication conventionnelles ont été prédéfinies :
9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600, 1000000, 1500000
A 115200 bauds, chaque bit prend (1/115200) = 8.7µs. 8-bits de données prennent 69µs. Mais
chaque octet nécessite au-moins 2 autres bits (start et stop), il faut donc 87µs.
At 115200 bauds, certains PCs nécessitent un bit de stop plus "long" (1.5 ou 2 bits).
Couche physique pour RS-232
Les signaux dans les fils utilisent une tension positive et une autre négative :
"1" envoyé est traduit par mettre la ligne à -10V (ou entre -5V et -15V).
"0" envoyé est traduit par mettre la ligne à +10V (ou entre +5V et +15V).
Couche physique pour l’UART
Les signaux dans les fils utilisent une tension positive et une autre négative :
"1" envoyé est traduit par mettre la ligne à +VCC (5V, 3V3 ou 1V8).
"0" envoyé est traduit par mettre la ligne à GND (la masse).
Master – Département GE – BABA 9 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Contrôleur UART en Verilog
module AsyncReceiver ( input clk, rstn, RxD, module AsyncTransmitter ( input clk, rstn,
input [31:0] divider, output [7:0] data, TxD_start, input [31:0] divider, input [7:0]
output reg data_ready ); TxD_data, output TxD, output reg done);
reg [3:0] state; reg [3:0] state;
reg [31:0] cnt; reg [31:0] divcnt;
reg [7:0] pattern, buf_data; reg [7:0] pattern;
reg TxD = 1'b1;
assign data = data_ready ? buf_data : ~0;
always @(posedge clk) begin
always @(posedge clk) begin if (!rstn) begin
if(!rstn) begin state <= 0; divcnt <= 0;
state <= 0; cnt <= 0; pattern <= 0; done <= 0;
pattern <= 0; buf_data <= 0; end else begin
data_ready <= 0; end divcnt <= divcnt + 1;
else begin case (state)
cnt <= cnt + 1; 0: begin
data_ready <= 0; TxD <= 1'b1;
case(state) done <= 0;
0: begin if (TxD_start) begin
if(!RxD) state <= 1; divcnt <=0;
cnt <= 0;end state <= 1;
1: begin pattern <= TxD_data; end end
if(cnt > divider/2) begin 1: begin
state <= 2; TxD <= 1'b0;
cnt <= 0;end end if (divcnt > divider) begin
10: begin state <= 2;
if (cnt > divider) begin divcnt <= 0; end end
buf_data <= pattern; 10: begin
data_ready <= 1; TxD <= 1'b1;
state <= 0;end end if (divcnt > divider) begin
default: begin done <= 1;
if (divcnt > divider) begin state <= 0; end end
pattern <= {RxD, default: begin
pattern[7:1]}; TxD <= pattern[0];
state <= state + 1; if (divcnt > divider) begin
cnt <= 0;end end pattern <= (pattern >> 1);
endcase state <= state + 1;
end // else: !if(!rstn) divcnt <= 0; end end
end // always @ (posedge clk) endcase
endmodule // AsyncReceiver end // else
end // always
endmodule // AsyncTransmitter
Application 6 Q6. Écrire un code HDL qui renvoie un caractère lu à l’écran
Master – Département GE – BABA 10 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
ii. WS2812
Principe
Une LED adressable qu’on peut modifier sa luminosité et sa couleur. Le contrôleur intégré à la
LED récupère et traite les données séries reçues par sa broche d’entrée pour allumer sa LED et
transmet des données à sa broche de sortie, selon des contraintes temporelles bien définies.
Protocole de transmission série one-wire
Le bit MSB est transmis en premier. Au démarrage ou après un signal reset, le contrôleur utilise
les premiers 24 bits reçus pour allumer sa LED et transmet les bits restants à sa sortie :
Pour piloter 2 LED par exemple, on envoie 48 bits à la première LED. Un signal reset est
nécessaire pour que les couleurs des LED changent, et de nouveaux 48 bits peuvent être envoyés.
Contraintes de temps
Pour envoyer le bit 0 on met la broche d’entrée de la LED à " 1 " pour une durée T0H suivi par
un état " 0 " pour une durée T0L. Pour envoyer le bit 1 on met la broche d’entrée de la LED à " 1
" logique pour une durée H1H suivie par un état " 0 " logique pour une durée T1L.
Le temps de reset de la LED de la carte webfpga est >= 50 µs.
T0H = 0,4 µs, T0L = 0,85 µs, T1H = 0,8 µs, T1L = 0,45 µs, avec une tolérance ± 150 ns.
Contrôleur Verilog
module WF_neo ( input wire [23:0] data, input wire load, clk, output wire dout );
parameter ton = 12, toff = 6, trst = 800; //for 16MHz or 9//4//600 for 12MHz
localparam tprd = ton + toff;
reg [23:0] rgb;
reg [4:0] bcnt; // bit counter (0 to 23)
reg [9:0] tcnt; // time counter
reg state;
Master – Département GE – BABA 11 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
always @(posedge clk) begin if(load) rgb<= data; end
always @(posedge clk) begin
tcnt <= tcnt - 1;
if(tcnt == 0) begin
tcnt <= tprd;
case(state)
1'b0: begin // data transmission
bcnt <= bcnt - 1;
if(bcnt == 0) begin //go to reset
tcnt <= trst;
bcnt <= 23 ;
state <= 1'b1;
end
end
1'b1: begin // reset state
state <= 1'b0;
end
endcase
end
end
assign neo = (!state) & (rgb[bcnt] ? tcnt > toff : tcnt > ton);
endmodule
Application 7 Q7.1. Modifier le code de l’Application 7 pour avoir le comportement
suivant :
• A l’appui sur la lettre " r " la RGB LED s’allume en rouge.
• A l’appui sur la lettre " o " la RGB LED s’allume en orange.
• A l’appui sur la lettre " y " la RGB LED s’allume en jaune.
• A l’appui sur la lettre " g " la RGB LED s’allume en vert
• A l’appui sur la lettre " c " la RGB LED s’allume en cyan.
• A l’appui sur la lettre " b " la RGB LED s’allume en bleu.
• A l’appui sur la lettre " p " la RGB LED s’allume en violet
• A l’appui sur une autre lettre la RGB LED garde sa couleur.
Q7.2. Donner le nombre de LUT utilisées.
Q7.3. Comparer ce nombre avec les autres équipes.
Noter bien que pour les applications 7 et 8, on aura besoin de :
• Un convertisseur USB/UART ;
• Une console série : PuTTy ([Link] pour Windows, ou
• Screen pour Linux ou macOS…
Master – Département GE – BABA 12 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Section 4 : Mémoires
i. EBRAM
Principe
Le module FPGA iCE40UP5k installé sur la carte webfpga intègre 30 blocks mémoire, chacun
de taille 256×16 bits (256 éléments de 16bits). Pour une raison (que je ne connais pas) ou une
autre, le synthétiseur HDL utilisé par le serveur [Link] ne permet pas de les inférer, comme
il est indiqué dans l’exemple du cours. Mais, on peut instancier le module SB_RAM256x16 ou
le module SB_RAM40_4K de manière explicite autant de fois qu’on le souhaite sans dépasser la
limite de 30 instances.
Module de taille 4Kbit = 4096 bits
Le module SB_RAM40_4K est le module de base pour utiliser les Blocks RAM embarqués :
Module de taille 4Kbit
Master – Département GE – BABA 13 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Exemple de code Verilog pour utiliser le module SB_RAM256x16 :
module WF_ram1 (input wire clk, defparam ram.INIT_0 = 256'h0;
input [7:0] radd, defparam ram.INIT_1 = 256'h0;
output [15:0] rdata); defparam ram.INIT_2 = 256'h0;
defparam ram.INIT_3 = 256'h0;
SB_RAM256x16 ram(. defparam ram.INIT_4 = 256'h0;
WDATA(16'b0), defparam ram.INIT_5 = 256'h0;
.MASK(16'b0), defparam ram.INIT_6 = 256'h0;
.WADDR(8'b0), defparam ram.INIT_7 = 256'h0;
.WE(1'b0), defparam ram.INIT_8 = 256'h0;
.WCLKE(1'b0), defparam ram.INIT_9 = 256'h0;
.WCLK(1'b0), defparam ram.INIT_A = 256'h0;
.RDATA(rdata), defparam ram.INIT_B = 256'h0;
.RADDR(radd), .RE(1'b1), defparam ram.INIT_C = 256'h0;
.RCLKE(1'b1), defparam ram.INIT_D = 256'h0;
.RCLK(clk)); defparam ram.INIT_E = 256'h0;
defparam ram.INIT_F = 256'h0;
endmodule
Rréférez-vous à l’exemple « WF_neopixel8_fading_demo.v » sur le site constructeur de la carte :
[Link]
Exemple de code Verilog pour utiliser le module SB_RAM40_4K :
module WF_ram2 (input wire clk, defparam ram.INIT_0 = 256'h0;
input wire [10:0] raddr, defparam ram.INIT_1 = 256'h0;
output wire [15:0] rdata ); defparam ram.INIT_4 = 256'h0;
defparam ram.INIT_5 = 256'h0;
SB_RAM40_4K ram( defparam ram.INIT_6 = 256'h0;
.RDATA(rdata), defparam ram.INIT_7 = 256'h0;
.RADDR(raddr), defparam ram.INIT_8 = 256'h0;
.WADDR(11'b0), defparam ram.INIT_9 = 256'h0;
.MASK(16'b0), defparam ram.INIT_A = 256'h0;
.WDATA(16'b0), defparam ram.INIT_B = 256'h0;
.RCLKE(1'b1), defparam ram.INIT_C = 256'h0;
.RCLK(clk), defparam ram.INIT_D = 256'h0;
.RE(1'b1), defparam ram.INIT_E = 256'h0;
.WCLKE(1'b0), defparam ram.INIT_F = 256'h0;
.WCLK(1'b0), endmodule
.WE(1'b0) );
Noter bien que les deux modules sont utilisés ici en lecture seule. En fait, le paramètre WE reçoit
un 0, ce qui signifie que le mode écriture est désactivée. Même remarque pour les paramètres
WCLKE et WCLK. Un block EBRAM peut être initialisé lors de la configuration. Par défaut il
est à l’état 0 logique.
Master – Département GE – BABA 14 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Application 8 Q8.1. Modifier le code de l’Application 8 pour avoir le comportement
suivant :
• A l’appui sur la lettre " r " la RGB LED s’allume en rouge.
• A l’appui sur la lettre " o " la RGB LED s’allume en orange.
• A l’appui sur la lettre " y " la RGB LED s’allume en jaune.
• A l’appui sur la lettre " g " la RGB LED s’allume en vert
• A l’appui sur la lettre " c " la RGB LED s’allume en cyan.
• A l’appui sur la lettre " b " la RGB LED s’allume en bleu.
• A l’appui sur la lettre " p " la RGB LED s’allume en violet
- Noter bien que les valeurs des couleurs sont stockées dans la mémoire
BRAM.
- La taille d’un mot dans la mémoire est 16 bits, et 24bits pour une couleur
- Penser à représenter une couleur sous la forme {4’h0,16’hXY,4’h0}
Ex : pour la couleur verte : 24’h10_00_00 (faible luminescence),
On peut la représenter par : 24’h0f_00_00, sans changer sa luminescence.
- Ainsi, une couleur est définie par un code de 16 bits, et donc chaque
couleur peut être représentée par un mot 16bits de la mémoire.
- Utiliser les modules suivants :
SB_HFOSC hfosc (
.CLKHFPU(1'b1), .CLKHFEN(1'b1), .CLKHF(clk));
defparam hfosc.CLKHF_DIV = "0b10";
WF_ram ebram (
.clk(clk), .raddr(raddr),.rdata(rdata));
AsyncReceiver rx(.clk(clk), .resetn(1'b1), .ser_rx(pin4),
.cfg_divider(120000/96),.data(uart_in), .valid(rx_valid));
AsyncTransmitter tx(.clk(clk),.resetn(1'b1),.tx(pin5), .valid(tx_valid),
.cfg_divider(120000/96),.data(uart_in),.go(rx_valid));
WF_neo #(.ton(9), .toff(4),.trst(600))
neo (.neo(WF_NEO), .clk(clk), .data(data), .load(go));
Q8.2. Donner le nombre de LUT utilisées.
Q8.3. Comparer ce résultat avec les autres équipes.
Q8.4. Comparer ce résultat avec celui de l’application 7.
Master – Département GE – BABA 15 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
ii. SDRAM
Master – Département GE – BABA 16 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Annexe 1
Master – Département GE – BABA 17 Modifié le 11 Oct. 2024
ENSAM Casablanca FPGA – Travaux Pratiques
Annexe 2
[Link] (Pin Constraints File)
set_io -nowarn WF_LED 31 set_io -nowarn pin12 34
set_io -nowarn WF_NEO 32 set_io -nowarn pin13 35
set_io -nowarn WF_CLK 35 #PIN_13_G0 set_io -nowarn pin14 36
set_io -nowarn WF_BUTTON 42 set_io -nowarn pin15 37 #G1
set_io -nowarn pin17 44
set_io -nowarn pin0 17 set_io -nowarn pin18 46
set_io -nowarn pin1 16 set_io -nowarn pin19 47
set_io -nowarn pin2 14 set_io -nowarn pin20 45
set_io -nowarn pin3 23 set_io -nowarn pin21 48
set_io -nowarn pin4 20 #G3 set_io -nowarn pin22 2
set_io -nowarn pin5 19 set_io -nowarn pin23 3
set_io -nowarn pin6 18 set_io -nowarn pin24 4
set_io -nowarn pin7 21 set_io -nowarn pin25 9
set_io -nowarn pin8 25 set_io -nowarn pin26 6
set_io -nowarn pin9 26 set_io -nowarn pin27 43
set_io -nowarn pin10 28 set_io -nowarn pin30 38
set_io -nowarn pin11 27 set_io -nowarn pin31 15
makefile
all:
yosys -p "synth_ice40 -json [Link]" -q top.v
nextpnr-ice40 --up5k --package sg48 --json [Link] --asc [Link] --pcf [Link] -q
Icepack [Link] [Link]
burn:
webfpga flash [Link]
top.v
module fpga_top ( input WF_CLK, output reg WF_LED );
reg [23:0] counter;
always @ (posedge WF_CLK) begin
if (&counter ) begin
WF_LED <= ~WF_LED;
counter <= 'b0;
end else
counter <= counter + 'b1;
end
endmodule
Couleurs et Représentations
Couleur Symbol Code Ascii Représentation RGB 24-bits
Black k 8’h71 24'h00_00_00
Blue b 8’h62 24'h00_00_10
Cyan c 8’h63 24'h10_00_10
Green g 8’h67 24'h10_00_00
Red r 8’h72 24'h00_10_00
Purple p 8’h70 24'h00_10_10
Yellow y 8’h79 24'h10_10_00
White w 8’h77 24'h10_10_10
Master – Département GE – BABA 18 Modifié le 11 Oct. 2024
