Manuel d'utilisation du générateur d'interface de test UART VHDLwhiz

Ce produit vous permet de générer des interfaces personnalisées pour la lecture et l'écriture de valeurs de registre FPGA à l'aide de l'UART. Le module VHDL généré et le script Python offrent la possibilité d'interagir avec différents types de registres dans votre conception FPGA.

Exigences

Interpréteur Python 3
Paquet pyserial

Protocole

Le produit utilise un protocole de cadrage de données avec quatre caractères de contrôle :

Nom: LIRE_REQ, Valeur: 0x0A – Commande de l'hôte au FPGA pour lancer une séquence d'écriture afin de renvoyer tous les registres via UART
Nom: DÉMARRER_ÉCRIRE, Valeur: 0x0B – Marque le début d'une séquence d'écriture dans les deux sens

Nom: FIN_ÉCRITURE, Valeur: 0x0C – Marque la fin d'une séquence d'écriture dans les deux sens
Nom: S'ÉCHAPPER, Valeur: 0x0D – Caractère d'échappement utilisé pour échapper les mots de contrôle

Instructions d'utilisation du produit

Exécution des scripts

Pour utiliser le produit, assurez-vous que Python 3 et le package Pyserial sont installés. Exécutez les scripts via un interpréteur Python 3.

Générer des interfaces personnalisées

Utilisez le script gen_uart_regs.py pour générer des interfaces personnalisées pour la lecture et l'écriture des valeurs de registre FPGA. Vous pouvez spécifier la composition des registres d'entrée et de sortie et les types lors de la génération de la sortie files.

Interagir avec les registres

Vous pouvez lire ou écrire dans n'importe quel nombre de registres de votre conception FPGA à l'aide du module VHDL généré et du script Python. Les registres accessibles peuvent avoir des types tels que std_logic, std_logic_vector, signé ou non signé.

Licence

La licence MIT couvre les exigences en matière de droits d'auteur et les conditions d'utilisation du code source. Reportez-vous au fichier LICENSE.txt file dans le zip file pour plus de détails.

Journal des modifications

Ces changements font référence au projet files, et ce document est mis à jour en conséquence

Version	Remarques
1.0.0	Version initiale
1.0.1	Correction d'un bug de référence « auto » manquant lors de l'importation en tant que uart_regs.py en tant que module Python. Modification de l'impression d'échec d'écriture en exception évitez d'imprimer sur la console lors de l'exécution en tant que module importé.
1.0.2	Correction de l'erreur Vivado [Synth 8-248] lorsqu'il n'y a pas de régulations de mode de sortie.
1.0.3	Correction de l'avertissement Vivado Linter : le registre a été activé par réinitialisation synchrone
1.0.4	Corrigez le cas particulier lors de la réception d'un mot mal formé avec le caractère d'échappement comme dernier octet. Le mot suivant serait également perdu car nous n'avons pas effacé recv_data_prev_is_escape lors du retour à IDLE. Le script gen_uart_regs.py autorise désormais uniquement les noms de registre uniques.

Description

Ce document décrit les éléments suivants files et dossiers :
gen_uart_regs.py

généré/uart_regs.vhd
généré/uart_regs.py
généré/instantiation_template.vho
rtl/uart_regs_backend.vhd
rtl/uart_rx.vhd
rtl/uart_tx.vhd
démo/lattice_icestick/
démo/xilinx_arty_a7_35/
démo/xilinx_arty_s7_50/
Le script gen_uart_regs.py et le support VHDL fileLes éléments de ce projet vous permettent de générer des interfaces personnalisées pour lire et écrire des valeurs de registre FPGA de différents types et largeurs à l'aide d'UART.
Vous pouvez utiliser le module VHDL généré et le script Python pour lire ou écrire dans n'importe quel nombre de registres de votre conception. Les registres accessibles UART peuvent avoir les types std_logic, std_logic_vector, signés ou non signés.
Vous pouvez décider de la composition précise des registres et des types d'entrée et de sortie lors de la génération de la sortie. files en utilisant le script gen_uart_regs.py.
Les scripts Python ont été créés en partie à l'aide de l'outil d'intelligence artificielle ChatGPT, tandis que le code VHDL est fabriqué à la main.

Exigences

Les scripts de ce projet doivent être exécutés via un interpréteur Python 3 et le package Pyserial doit être installé.
Vous pouvez installer pyserial via Pip en utilisant cette commande : pip install pyserial

Protocole

Le VHDL fileLes scripts s et Python utilisent un protocole de cadrage de données avec quatre contrôles

Nom	Valeur	Commentaire
LIRE_REQ	0x0A	Commande de l'hôte au FPGA pour lancer une écriture séquence pour renvoyer tous les registres via UART
START_WRITE	0x0B	Marque le début d'une séquence d'écriture dans l'un ou l'autre direction
END_WRITE	0x0C	Marque la fin d'une séquence d'écriture dans les deux sens
S'ÉCHAPPER	0x0D	Caractère d'échappement utilisé pour échapper l'un des mots de contrôle, y compris le caractère ESCAPE lui-même, lorsqu'ils apparaissent sous forme de données entre les marqueurs START_WRITE et END_WRITE.

Tout octet READ_REQ non échappé envoyé au FPGA est une instruction pour renvoyer tous ses registres accessibles par UART (entrées et sorties) à l'hôte via UART. Cette commande est généralement émise uniquement par le script uart_regs.py.
Dès réception de cette commande, le FPGA répondra en renvoyant le contenu de tous les registres à l'hôte. D’abord les signaux d’entrée, puis les signaux de sortie. Si leurs longueurs ne totalisent pas un multiple de 8 bits, les bits inférieurs du dernier octet seront complétés par des zéros.
Une séquence d'écriture commence toujours par l'octet START_WRITE et se termine par l'octet END_WRITE. Tous les octets entre ces deux octets sont considérés comme des octets de données. Si des octets de données ont la même valeur qu'un caractère de contrôle, l'octet de données doit être échappé. Cela signifie qu'un caractère ESCAPE supplémentaire doit être envoyé avant l'octet de données pour indiquer qu'il s'agit en fait de données.
Si un START_WRITE non échappé arrive n'importe où dans le flux d'octets, il est considéré comme le début d'une séquence d'écriture. Le module uart_regs_backend utilise ces informations pour se resynchroniser au cas où la communication serait désynchronisée.

gen_uart_regs.py

C'est le script avec lequel vous devez commencer pour générer l'interface. Vous trouverez ci-dessous une capture d'écran du menu d'aide que vous pouvez obtenir en exécutant : python gen_uart_regs.py -h
Pour générer une interface personnalisée, vous devez exécuter le script avec chacun de vos registres contrôlables UART souhaités répertoriés comme arguments. Les types disponibles sont std_logic, std_logic_vector, non signé et signé.
Le mode (direction) par défaut est in et le type par défaut est std_logic_vector sauf si le registre est de longueur : 1. Ensuite, il sera par défaut std_logic.

Ainsi, si vous souhaitez créer un signal d'entrée std_logic, vous pouvez utiliser l'un de ces arguments :
mon_sl=1
my_sl=1:dans

mon_sl=1:in:std_logic
Toutes les variantes ci-dessus entraîneront la génération par le script de ce signal accessible par UART :
Exécutons le script avec des arguments pour générer une interface avec plusieurs registres de directions, longueurs et types différents

Généré files

Une exécution réussie du script gen_uart_regs.py produira un dossier de sortie nommé généré avec les trois filesont répertoriés ci-dessous. S'ils existent déjà, ils seront écrasés.
généré/uart_regs.vhd

généré/uart_regs.py
généré/instantiation_template.vho
uart_regs.vhd

Il s'agit du module d'interface personnalisé généré par le script. Vous devez l'instancier dans votre conception, où il peut accéder aux registres que vous souhaitez contrôler à l'aide de UART.
Tout ce qui se trouve au-dessus de la section « – Registres accessibles UART » sera identique pour chaque module uart_regs, tandis que la composition des signaux de port en dessous de cette ligne dépend des arguments donnés au script du générateur.
La liste ci-dessous montre l'entité du module uart_regs résultant de la commande generate exampfichier affiché dans la section gen_uart_regs.py

Vous n'avez pas besoin de synchroniser le signal uart_rx, car cela est géré dans uart_rx. module.
Lorsque le module reçoit une demande de lecture, il capture les valeurs de tous les signaux d'entrée et de sortie dans le cycle d'horloge actuel. L'instantané instantané est ensuite envoyé à l'hôte via UART.
Lorsqu'une écriture se produit, tous les registres de sortie sont mis à jour avec les nouvelles valeurs au cours du même cycle d'horloge. Il n'est pas possible de modifier individuellement les valeurs des signaux de sortie.

Cependant, le script uart_regs.py permet à l'utilisateur de mettre à jour uniquement les sorties sélectionnées en relisant d'abord les valeurs actuelles de tous les registres. Il réécrit ensuite toutes les valeurs, y compris celles mises à jour.
uart_regs.py
Le généré/uart_regs.py file est généré avec le module uart_regs VHDL et contient les informations de registre personnalisé dans l'en-tête du file. Avec ce script, vous pouvez facilement lire ou écrire dans vos registres personnalisés.

Menu d'aide

Tapez python uart_regs.py -h pour imprimer le menu d'aide :

Configuration du port UART

Le script dispose d'options permettant de définir le port UART à l'aide du commutateur -c. Cela fonctionne sous Windows et Linux. Définissez-le sur l'un des ports disponibles répertoriés dans le menu d'aide. Pour définir un port par défaut, vous pouvez également modifier la variable UART_PORT dans le script uart_regs.py.

Répertorier les registres

Les informations sur le mappage des registres sont placées dans l'en-tête du script uart_regs.py par le script gen_uart_regs.py. Vous pouvez répertorier les registres disponibles avec le commutateur -l, comme indiqué ci-dessous. Il s'agit d'une commande locale qui n'interagira pas avec le FPGA cible.

Écrire dans les registres

Vous pouvez écrire dans n'importe lequel des registres du mode sortie en utilisant le commutateur -w. Fournissez le nom du registre suivi de « = » et la valeur donnée sous forme binaire, hexadécimale ou décimale, comme indiqué ci-dessous.
Notez que l'implémentation VHDL nécessite que le script écrive tous les registres de sortie simultanément. Par conséquent, si vous ne spécifiez pas un ensemble complet de registres de sortie, le script effectuera d'abord une lecture à partir du FPGA cible, puis utilisera ces valeurs pour les valeurs manquantes. Le résultat sera que seuls les registres spécifiés changeront
Lorsque vous effectuez une écriture, tous les registres spécifiés changeront au cours du même cycle d'horloge, et non dès leur réception via UART.

Lecture des registres

Utilisez le commutateur -r pour lire toutes les valeurs de registre, comme indiqué ci-dessous. Les valeurs marquées en jaune sont celles que nous avons modifiées lors de l'écriture précédente.ample
Chaque lecture affiche un instantané instantané de tous les registres d'entrée et de sortie. Ils sont tous sampLED pendant le même cycle d'horloge

Débogage

Utilisez le commutateur -d avec l'un des autres commutateurs si vous devez déboguer le protocole de communication. Ensuite, le script imprimera tous les octets envoyés et reçus et tag s'il s'agit de personnages de contrôle, comme indiqué ci-dessous.

Utilisation de l'interface dans d'autres scripts Python

Le script uart_regs.py contient une classe UartRegs que vous pouvez facilement utiliser comme interface de communication dans d'autres scripts Python personnalisés. Importez simplement la classe, créez-en un objet et commencez à utiliser les méthodes, comme indiqué ci-dessous.

Reportez-vous aux docstrings dans le code Python pour connaître la méthode, les descriptions et les types de valeurs de retour.

instanciation_template.vho

Le modèle d'instanciation est généré avec le module uart_regs pour votre commodité. Pour gagner du temps de codage, vous pouvez copier l'instanciation du module et les déclarations de signal dans votre conception.

RTL statique files

Vous devez inclure les éléments suivants files dans votre projet VHDL afin qu'ils soient compilés dans la même bibliothèque que le module uart_regs :
rtl/uart_regs_backend.vhd

rtl/uart_rx.vhd
rtl/uart_tx.vhd
Le module uart_regs_backend implémente les machines à états finis qui pointent l'entrée et la sortie des données du registre. Il utilise les modules uart_rx et uart_tx pour gérer la communication UART avec l'hôte.

Projets de démonstration

Il y a trois projets de démonstration inclus dans le Zip file. Ils vous permettent de contrôler les périphériques des différentes cartes ainsi que quelques registres internes plus grands.
Les dossiers de démonstration incluent uart_regs.vhd et uart_regs.py pré-générés fileest spécialement conçu pour ces conceptions.

iCEstick en treillis

Le dossier demo/icecube2_icestick contient une implémentation de démonstration d'accès au registre pour la carte FPGA Lattice iCEstick.
Pour exécuter le processus de mise en œuvre, ouvrez le fichier demo/lattice_icestick/icecube2_proj/uart_regs_sbt.project file dans le logiciel de conception Lattice iCEcube2.
Après avoir chargé le projet dans l'interface graphique d'iCEcube2, cliquez sur Outils → Exécuter tout pour générer le bitmap de programmation. file.

Vous pouvez utiliser l'outil autonome Lattice Diamond Programmer pour configurer le FPGA avec le bitmap généré. file. Lorsque Diamond Programmer s'ouvre, cliquez sur Ouvrir un projet de programmeur existant dans la boîte de dialogue de bienvenue.
Sélectionnez un projet file trouvé dans le Zip : demo/lattice_icestick/diamond_programmer_project.xcf et cliquez sur OK.
Une fois le projet chargé, cliquez sur les trois points dans le File Colonne Nom, comme indiqué ci-dessus. Parcourez pour sélectionner le bitmap file que vous avez généré dans iCEcube2

demo/lattice_icestick/icecube2_proj/uart_regs_Implmnt/sbt/outputs/bitmap/top_icestick_bitmap.bin
Enfin, avec la carte iCEstick branchée sur un port USB de votre ordinateur, sélectionnez Conception → Programme pour programmer le flash SPI et configurer le FPGA.
Vous pouvez maintenant procéder à la lecture et à l'écriture des registres en utilisant le script demo/lattice_icestick/uart_regs.py comme décrit dans la section uart_regs.py.

Xilinx Digilent Arty A7-35T

Vous pouvez trouver l'implémentation de démonstration du kit d'évaluation Arty FPGA Artix-7 35T dans le dossier demo/arty_a7_35.
Ouvrez Vivado et accédez au fichier extrait files en utilisant la console Tcl située en bas de l'interface graphique. Tapez cette commande pour accéder au dossier du projet de démonstration :

CD /demo/arty_a7_35/vivado_proj/
Exécutez le script Tcl create_vivado_proj.tcl pour régénérer le projet Vivado :
source ./create_vivado_proj.tcl

Cliquez sur Générer un flux binaire dans la barre latérale pour parcourir toutes les étapes de mise en œuvre et générer le flux binaire de programmation. file.
Enfin, cliquez sur Open Hardware Manager et programmez le FPGA via l'interface graphique.
Vous pouvez maintenant procéder à la lecture et à l'écriture des registres en utilisant le script demo/arty_a7_35/uart_regs.py comme décrit dans la section uart_regs.py.

Xilinx Digilent Arty S7-50

Vous pouvez trouver l'implémentation de démonstration pour la carte de développement FPGA Arty S7 : Spartan-7 dans le dossier demo/arty_s7_50.
Ouvrez Vivado et accédez au fichier extrait files en utilisant la console Tcl située en bas de l'interface graphique. Tapez cette commande pour accéder au dossier du projet de démonstration :

CD /demo/arty_s7_50/vivado_proj/
Exécutez le script Tcl create_vivado_proj.tcl pour régénérer le projet Vivado :
source ./create_vivado_proj.tcl

Cliquez sur Générer un flux binaire dans la barre latérale pour parcourir toutes les étapes de mise en œuvre et générer le flux binaire de programmation. file.
Enfin, cliquez sur Open Hardware Manager et programmez le FPGA via l'interface graphique.
Vous pouvez maintenant procéder à la lecture et à l'écriture des registres en utilisant le script demo/arty_s7_50/uart_regs.py comme décrit dans la section uart_regs.py.

Mise en œuvre

Il n’y a pas d’exigences spécifiques de mise en œuvre.

Contraintes

Aucune contrainte de synchronisation spécifique n'est nécessaire pour cette conception car l'interface UART est lente et traitée comme une interface asynchrone.

L'entrée uart_rx du module uart_regs est synchronisée dans le module uart_rx. Ainsi, il n'est pas nécessaire de le synchroniser dans le module de niveau supérieur.

Problèmes connus

Vous devrez peut-être réinitialiser le module avant de pouvoir l'utiliser, selon que votre architecture FPGA prend en charge ou non les valeurs de registre par défaut.

Plus d'infos

Droits d'auteur VHDLwhiz.com

FAQ

Q : Quel est le but du générateur d’interface de test UART ?

R : Le générateur d'interface de test UART permet la création d'interfaces personnalisées pour interagir avec les valeurs de registre FPGA à l'aide de la communication UART.

Q : Comment installer le package Pyserial ?

R : Vous pouvez installer Pyserial via Pip en utilisant la commande : pip install pyserial

Documents / Ressources

Générateur d'interface de test UART VHDLwhiz [pdf] Manuel de l'utilisateur
Générateur d'interface de test UART, Générateur d'interface de test, Générateur d'interface, Générateur

Références

Manuel d'utilisation

Générateur d'interface de test UART VHDLwhiz

Informations sur le produit