Comment faire ressortir les signaux internes d'un module inférieur vers un module supérieur en VHDL?

Comment puis-je faire ressortir les signaux internes de mon code source VHDL sur mon banc de test afin de pouvoir les visualiser comme des formes d'onde? J'utilise Active HDL. Je voudrais savoir s'il existe une méthode indépendante de l'outil pour atteindre mon objectif. Toute aide est appréciée.

Je reçois cette erreur maintenant.

Mon code source est

entity SPI_DAC is
    Port ( 
    -- inputs and oututs
    )
end SPI_DAC;

architecture Behavioral of SPI_DAC is 
    --These are my internal signals 
    signal ch1_byte_data_sent       : STD_LOGIC_VECTOR(23 downto 0)     := x"000000"; 
    signal ch1_byte_cmd_sent        : STD_LOGIC_VECTOR(23 downto 0)     := x"000000";
    --and a few other signals
begin 
    --functionality 
end Behavioral;

Mon code de banc d'essai est

entity tb_spi_dac is
end tb_spi_dac;

architecture behavioral of tb_spi_dac is
    component spi_dac
    port(
    --declaration, inputs and outputs
    );
    end component;
begin
    uut: spi_dac port map(
    --map ports
    );
    --stimulus process
end;

Ce que vous recherchez s'appelle des noms externes (ou noms hiérarchiques) en VHDL. Ils peuvent être utilisés pour contourner la visibilité de la portée / hiérarchie. La syntaxe est similaire à l'exemple ci-dessous.

<<signal path_name : std_logic_vector(7 downto 0)>>

Vous pouvez également accéder aux constantes et aux variables avec des noms externes. Vous devez cependant changer le type dans le type externe. Vous pouvez utiliser des noms externes directement pour un accès en lecture / écriture. Cependant, vous devez utiliser des alias pour améliorer la lisibilité.

alias signal_name is 
    <<signal path_name : std_logic_vector(7 downto 0)>>;

Le nom externe doit contenir le chemin d'accès à l'élément auquel vous souhaitez accéder. Le chemin peut être absolu ou relatif. Les éléments individuels de votre chemin sont séparés par des points. Notez que vous devez fournir les étiquettes de l'instance / processus / entité / ... et non le nom. Le chemin absolu commence par un .suivi du nom de votre niveau supérieur. Pour les chemins relatifs, vous pouvez utiliser ^pour monter dans la hiérarchie. Lorsque vous utilisez des constantes / signaux d'un paquet, vous pouvez également utiliser @pour passer à une bibliothèque.

Un exemple de chemin absolu est

.tb_name.instance_label.sub_instance_label.signal_name

Pour accéder au même élément à partir du banc de test avec des noms relatifs, vous pouvez utiliser

instance_label.sub_instance_label.signal_name

Lorsque vous souhaitez accéder à un signal / constante de banc d'essai à partir de la sous_instance, vous pouvez utiliser

^.^.constant_name

Pour accéder à une autre constante dans un package de configuration situé dans la bibliothèque de configuration, vous pouvez utiliser

@config.pkg_name.other_constant_name

Vous pouvez utiliser le navigateur de conception / bibliothèque de vos simulateurs comme l'a souligné David pour trouver le nom de chemin correct.

Cette fonctionnalité a été ajoutée dans VHDL-2008, elle devrait donc être prise en charge par tous les outils qui prennent déjà en charge VHDL-2008 (y compris ActiveHDL, je pense). La plupart des simulateurs n'utilisent pas VHDL-2008 par défaut mais fournissent un argument de ligne de commande ou une option de configuration pour l'activer.

Comment puis-je faire ressortir les signaux internes de mon code source VHDL sur mon banc de test afin de pouvoir les visualiser comme des formes d'onde?

Un banc d'essai implique une simulation - une entité sans ports n'est généralement pas éligible à la synthèse.

Bien que je n'aie jamais utilisé Active-HDL, je comprends qu'il a un navigateur de conception qui devrait vous permettre de sélectionner les signaux dans votre hiérarchie pour les afficher dans votre forme d'onde.Voir la vidéo de compilation et de simulation d' Aldec (5:02, min: sec).

Et maintenant, j'ai l'impression que la vidéo peut être source de confusion, peut-être dans ce cas particulier.

À 2:22 de la fin, la vidéo montre un fichier do (macro) qui contrôle la simulation:

Où nous voyons chaque signal dans le niveau supérieur de la conception a été ajouté à l'affichage de la forme d'onde avec la commande d'onde. Il devrait également être possible de spécifier un signal n'importe où dans la hiérarchie de conception.

L'idée de base est que de nombreux simulateurs vous permettent de planifier des signaux (et certains autorisent des variables) à collecter pour l'affichage de la forme d'onde.

Cette courte vidéo ne montre tout simplement pas de signaux pour les niveaux de hiérarchie subsidiaire. (Il y a beaucoup de choses dans une courte présentation vidéo).

Je voudrais savoir s'il existe une méthode indépendante de l'outil pour atteindre mon objectif.

Comme indiqué ci-dessus, votre objectif semble être de voir les signaux internes comme des formes d'onde.

Maintenant pour la mauvaise nouvelle - il n'y a pas de standardisation pour les fonctionnalités ou interfaces du simulateur, la planification des signaux pour le vidage de forme d'onde, etc.

Il est à peu près garanti que vous pouvez transférer des signaux n'importe où dans une hiérarchie de conception vers un visualiseur de forme d'onde ou un fichier de vidage de forme d'onde avec n'importe quelle implémentation qui simule, la méthode pour le faire est définie par l'implémentation.

La bonne nouvelle est qu'ils ont tendance à copier les concepts les uns des autres, tels que les fichiers, que vous pouvez générer par programmation pour la portabilité, en utilisant une base de données commune décrivant la vérification fonctionnelle sur plusieurs plates-formes d'implémentation, surmontant les différences de syntaxe et de sémantique. Il y aurait probablement également des différences dans la syntaxe de l'interface de ligne de commande pour appeler les outils par programme.

L'idée de la portabilité n'embrassant pas plusieurs GUI gracieusement.

Des outils comme xilinx ont la possibilité de visualiser les signaux internes.

Une méthode simple et indépendante de l'outil consiste à déclarer des lignes de sortie séparées et à connecter les signaux internes à ces lignes.

Si vous avez déclaré les signaux dans le banc de test mais ne pouvez voir aucune sortie, vous pouvez avoir un problème dans l'instruction d'instanciation où vous instanciez l'entité à tester. Vérifiez si vous l'avez instancié correctement à l'aide d'une instruction d'instanciation d'entité ou d'une instanciation de composant. Assurez-vous que les signaux de votre banc de test sont connectés à l'entité testée. Si cela ne résout pas le problème, publiez le code du banc de test afin que nous puissions vous aider.