Maîtriser la conception embarquée FPGA : guide d'implémentation pratique

La disponibilité de FPGA plus puissants et d'environnements de programmation plus efficaces a rendu l'implémentation FPGA largement accessible, mais l'utilisation de FPGA peut sembler intimidante.

Note de l'éditeur : Alors que des algorithmes avancés continuent d'émerger pour les designs de produits intelligents, les développeurs se retrouvent souvent en difficulté pour implémenter des systèmes embarqués capables de répondre aux demandes de traitement associées à ces algorithmes. Les FPGA peuvent fournir la performance requise, mais la conception avec des FPGA a longtemps été considérée comme limitée au domaine des experts en programmation FPGA. Aujourd'hui, cependant, la disponibilité de FPGA plus puissants et d'environnements de développement plus efficaces a rendu le développement FPGA largement accessible. Dans cet extrait, le Chapitre 4 du livre Architecting High-Performance Embedded Systems, l'auteur offre une revue complète des dispositifs FPGA, langages d'implémentation et du processus de développement FPGA ainsi qu'une marche à pas détaillée pour commencer à implémenter des FPGA dans votre propre design. L'extrait complet est présenté dans la série d'installations suivante : 1: Ressources matérielles
2: Langages d'implémentation
3: Processus de développement
4: Construction d'un projet
5: Implémentation (cet article)

Adapté de Architecting High-Performance Embedded Systems, par Jim Ledin.

---

Test du comportement logique

Il est important de tester le comportement de la logique en utilisant la simulation avant d'essayer de l'exécuter dans le FPGA. C'est parce qu'il est beaucoup plus facile de détecter et corriger les problèmes dans l'environnement de simulation qu'avec la logique s'exécutant à l'intérieur du FPGA. Les outils de simulation Vivado font un très bon travail de représentation du comportement du circuit :

1. Dans le sous-fenêtre Sources , clic droit sur Sources de simulation et sélectionnez Ajouter des sources… :

Figure 4.18 – Sélection du menu Ajouter des sources… pour Sources de simulation

2. Dans la boîte de dialogue Ajouter des sources , assurez-vous que Ajouter ou créer des sources de simulation est sélectionné, puis cliquez Suivant.
3. Dans la boîte de dialogue Ajouter ou Créer des Sources de Simulation , cliquez Créer un fichier.
4. Entrez le nom de fichier vhdl et cliquez OK.
5. Cliquez Terminer pour fermer la boîte de dialogue Ajouter ou Créer des Sources de Simulation , puis cliquez OK dans la boîte de dialogue Définir le Module et cliquez Oui quand on vous demande si vous êtes sûr de vouloir les utiliser
6. Double-cliquez sur Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) sous Sources de Simulation. Supprimez le contenu automatiquement rempli de la fenêtre d'édition vhdl et entrez le code suivant dans l'éditeur Adder4TestBench.vhdl :

library IEEE;   use IEEE.STD_LOGIC_1164.ALL;   use IEEE.NUMERIC_STD.ALL; entity ADDER4_TESTBENCH is end entity ADDER4_TESTBENCH; architecture BEHAVIORAL of ADDER4_TESTBENCH is   component ADDER4 is     port (       A4       : in    std_logic_vector(3 downto 0);       B4       : in    std_logic_vector(3 downto 0);       SUM4     : out   std_logic_vector(3 downto 0);       C_OUT4   : out   std_logic     );   end component;   signal a            : std_logic_vector(3 downto 0);   signal b            : std_logic_vector(3 downto 0);   signal s            : std_logic_vector(3 downto 0);   signal c_out        : std_logic;   signal expected_sum5: unsigned(4 downto 0);   signal expected_sum4: unsigned(3 downto 0);   signal expected_c    : std_logic;   signal error        : std_logic; begin   TESTED_DEVICE: ADDER4     port map (       A4     => a,       B4     => b,       SUM4   => s,       C_OUT4 => c_out     );   TEST: process   begin     -- Tester toutes les combinaisons de deux addends 4-bit (256 tests totaux)     for a_val in 0 to 15 loop       for b_val in 0 to 15 loop         -- Définir les entrées du composant ADDER4         a <= std_logic_vector(to_unsigned(a_val, a'length));         b <= std_logic_vector(to_unsigned(b_val, b'length));         wait for 1 ns;         -- Calculer la somme 5-bit des deux valeurs 4-bit         expected_sum5 <= unsigned('0' & a) + unsigned('0' & b);         wait for 1 ns;         -- Séparer la somme en une sortie 4-bit et un bit de retenue         expected_sum4 <= expected_sum5(3 downto 0);         expected_c     <= expected_sum5(4);         wait for 1 ns;         -- Le signal 'error' ne passera à 1 que si une erreur se produit         if ((unsigned(s) = unsigned(expected_sum4)) and             (c_out = expected_c)) then           error <= '0';         else           error <= '1';         end if;         -- Chaque passage dans la boucle interne prend 10 ns         wait for 7 ns;       end loop;     end loop;     wait;   end process TEST; end architecture BEHAVIORAL;

Ce code exerce la fonctionnalité de l'additionneur 4 bits en présentant toutes les combinaisons de nombres 4 bits à chacune des entrées A4 et B4 du composant Adder4. Il compare les sorties SUM4 et C_OUT4 du composant Adder4 à des valeurs calculées indépendamment pour les mêmes entrées. Après chaque opération d'addition, le signal error est mis à 0 si les sorties Adder4 correspondent aux valeurs attendues, ou il est mis à 1 s'il y a un désaccord.

Le code dans Adder4TestBench.vhdl ressemble au code logiciel traditionnel dans la façon dont il utilise des boucles for imbriquées pour appliquer toutes les combinaisons d'entrées de test au composant Adder4 sous test. Le code qui s'exécute en mode simulation est non-synthétisable, ce qui signifie qu'il ne représente pas purement un circuit logique matériel et est capable d'opérations logicielles traditionnelles, telles que l'exécution itérative de boucles for.

Cependant, comme dans les circuits physiques, les signaux se voyant assigner des valeurs dans le code du test bench en utilisant l'opérateur <= ne peuvent pas être utilisés au même instant dans des expressions subséquentes. C'est parce que l'environnement de simulation représente les effets réels du délai de propagation, qui est significatif même dans de minuscules dispositifs FPGA. Les trois instructions wait for 1 ns; dans le code du test bench mettent en pause les opérations du circuit pour permettre le délai de propagation. Ces délais de 1 ns donnent le temps aux valeurs de signaux calculées juste avant l'instruction wait de se propager pour pouvoir être utilisées dans l'instruction suivante. La dernière instruction wait for 7 ns; dans la boucle interne est une pause qui permet de voir clairement les résultats de chaque itération des boucles de simulation dans l'affichage de trace de signal.

7. Clic droit sur Adder4 TestBench (Behavioral) (Adder4TestBench.vhdl) sous Sources de Simulation et sélectionnez Mise à jour automatique et Ordre de compilation. Cela définit ADDER4_TESTBENCH comme objet de niveau supérieur pour l'exécution de la simulation :

Figure 4.19 – Sélection de menu pour définir Mise à jour automatique et Ordre de compilation

8. Cliquez Exécuter la simulation, puis Exécuter la simulation comportementale dans la fenêtre Navigateur de flux pour entrer en mode simulation. Si vous n'avez pas encore sauvegardé les fichiers d'édition, vous serez invité à le faire. Cliquez Sauvegarder. La simulation s'exécutera alors :

Figure 4.20 – Sélection de menu Exécuter la simulation comportementale

9. Quand la fenêtre SIMULATION s'ouvre, cliquez sur le bouton maximiser dans la fenêtre de sortie de simulation avec le titre Sans titre 1 :

Figure 4.21 – Fenêtre de résultats de simulation

Le temps simulé total de chaque passage dans la boucle interne est de 10 ns. Comme il y a 256 passages dans la boucle dans Adder4TestBench.vhdl, le temps pour exécuter la simulation est de 2560 ns.

10. Définissez le temps d'exécution de la simulation à 2560 ns dans la barre d'outils supérieure (étape 1 dans la figure suivante), appuyez sur le bouton de redémarrage pointant à gauche (étape 2), puis appuyez sur le bouton pointant à droite pour exécuter la simulation pendant 2560 ns (étape 3), et enfin appuyez sur le bouton Zoom Fit (étape 4) pour mettre à l'échelle la plage de données de sortie de simulation pour qu'elle tienne dans la fenêtre :

Figure 4.22 – Résultats de simulation du début à la fin de l'exécution

Vous pouvez utiliser les icônes de loupe pour zoomer sur n'importe quel point de la trace et observer les résultats de chaque opération d'addition effectuée pendant les tests. Par exemple, la figure suivante montre que les valeurs décimales 6 et 2 ont été ajoutées pour produire le résultat 8 avec une retenue de 0. Ces valeurs correspondent aux valeurs attendues, ce qui a causé error à être mis à 0. Le signal error est 0 pour tous les 256 cas de test, indiquant que notre circuit logique a passé tous les tests :

Figure 4.23 – Vue zoomée des résultats de simulation

11. Fermez le mode simulation en cliquant sur le X dans la barre bleue SIMULATION au-dessus de la trace de données. Cliquez OK quand on vous demande si vous voulez fermer la simulation.

Après avoir passé les tests comportementaux, nous allons définir les signaux E/S utilisés dans le design.

Définition des signaux E/S

Notre prochaine étape est de connecter les entrées et sorties de notre circuit aux dispositifs matériels sur la carte Arty. Les entrées seront les interrupteurs et boutons-poussoirs de la carte, et les sorties seront les LEDs.

Les étapes suivantes créeront un fichier de contraintes décrivant les broches E/S que nous utiliserons sur le dispositif FPGA et les fonctions connectées à ces broches sur la carte Arty. Les fichiers de contraintes ont l'extension xdc :

1. Dans le sous-fenêtre Sources , clic droit sur Contraintes et sélectionnez Ajouter des sources….
2. Dans la boîte de dialogue Ajouter des sources , assurez-vous que Ajouter ou créer des contraintes est sélectionné, puis cliquez Suivant.
3. Dans la boîte de dialogue Ajouter ou Créer des Contraintes , cliquez Créer un fichier.
4. Entrez le nom de fichier Arty-A7-100.xdc (ou Arty-A7-35.xdc si approprié pour votre dispositif) et cliquez OK.
5. Cliquez Terminer pour fermer la boîte de dialogue Ajouter ou Créer des Contraintes
6. Développez l'arborescence source Contraintes et double-cliquez sur Arty-A7-35.xdc.
7. Digilent fournit des fichiers de contraintes pré-remplis pour les cartes Arty A7. Visitez https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-35-Master.xdc et copiez tout le contenu de la fenêtre du navigateur dans la fenêtre d'édition Arty-A7-35.xdc dans Vivado. Si approprié pour votre dispositif, utilisez le fichier à https://raw.githubusercontent.com/Digilent/digilent-xdc/master/Arty-A7-100-Master.xdc à la place.
8. Toutes les broches E/S sont commentées dans le fichier de contraintes par. Décommentez les lignes appropriées dans le fichier en supprimant le caractère # au début de chaque ligne. Nous utiliserons les broches listées dans les sections suivantes dans le fichier Arty- A7-100.xdc : Switches, RGB LEDs (mais seulement led0_g, la première LED verte), LEDs, et Buttons. La figure suivante montre ces lignes après qu'elles ont été décommentées :

Figure 4.24 – Fenêtre d'édition des contraintes

Dans la section suivante, nous créerons un fichier VHDL de niveau supérieur qui interface le code de l'additionneur avec les dispositifs E/S.

Création d'un fichier VHDL de niveau supérieur

Nous allons ensuite créer un fichier VHDL de niveau supérieur qui connecte notre additionneur 4 bits aux signaux E/S correspondants de la carte :

1. Dans le sous-fenêtre Sources, clic droit sur Sources de conception et sélectionnez Ajouter des sources….
2. Dans la boîte de dialogue Ajouter des sources , assurez-vous que Ajouter ou créer des sources de conception est sélectionné, puis cliquez Suivant.
3. Dans la boîte de dialogue Ajouter ou Créer des Sources de Conception , cliquez Créer un fichier.
4. Entrez le nom de fichier vhdl et cliquez OK.
5. Cliquez Terminer pour fermer la boîte de dialogue Ajouter ou Créer des Sources de Conception , puis cliquez OK dans la boîte de dialogue Définir le Module et cliquez Oui quand on vous demande si vous êtes sûr de vouloir les utiliser
6. Double-cliquez sur vhdl sous Sources de Conception. Supprimez le contenu automatiquement rempli de la fenêtre d'édition ArtyAdder.vhdl et entrez le code suivant dans l'éditeur ArtyAdder.vhdl :

-- Charger les bibliothèques standard library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity ARTY_ADDER is    port (        sw         : in STD_LOGIC_VECTOR (3 downto 0);        btn        : in STD_LOGIC_VECTOR (3 downto 0);        led        : out STD_LOGIC_VECTOR (3 downto 0);        led0_g     : out STD_LOGIC    ); end entity ARTY_ADDER; architecture BEHAVIORAL of ARTY_ADDER is -- Référencer la définition précédente du composant additionneur 4 bits ADDER4 is port (    A4       : in   std_logic_vector(3 downto 0);    B4       : in   std_logic_vector(3 downto 0);    SUM4     : out  std_logic_vector(3 downto 0);    C_OUT4   : out  std_logic ); end component; begin ADDER : ADDER4    port map (      A4        => sw,      B4        => btn,      SUM4      => led,      C_OUT4     => led0_g    ); end architecture BEHAVIORAL;

Ce code associe les noms de signaux pour les dispositifs E/S nommés dans Arty-A7-100.xdc comme sw (4 interrupteurs), btn (4 boutons-poussoirs), led (4 LEDs monochrome), et led0_g (le canal vert de la première LED multicolore) aux entrées et sorties du ADDER4.

Bien que VHDL ne soit pas sensible à la casse, le traitement des fichiers de contraintes xdc dans Vivado est sensible à la casse. La casse utilisée dans les noms de dispositifs E/S définis dans le fichier xdc doit être identique quand elle est référencée dans un fichier VHDL. Spécifiquement, les noms de signaux E/S dans VHDL doivent être en minuscules dans ce fichier parce qu'ils sont en minuscules dans le fichier de contraintes.

Nous sommes maintenant prêts à synthétiser, implémenter et programmer notre design pour la carte Arty. 

Synthèse et implémentation du bitstream FPGA

Alternativement, vous pouvez sélectionner Générer le Bitstream et Vivado effectuera toutes les étapes requises, y compris la synthèse, l'implémentation et la génération du bitstream sans intervention supplémentaire de l'utilisateur. Si une erreur fatale se produit, le processus s'arrêtera et les messages d'erreur seront affichés. Effectuez les étapes suivantes pour générer le bitstream :

1. Cliquez Générer le Bitstream pour démarrer la construction. On peut vous demander si vous voulez sauvegarder les éditeurs de texte. Cliquez Sauvegarder. On peut vous informer qu'il n'y a pas de résultats d'implémentation disponibles et demander si c'est OK de lancer la synthèse et l'implémentation. Cliquez Oui :

Figure 4.25 – Sélection de menu Générer le Bitstream

2. La boîte de dialogue Lancer les exécutions apparaîtra alors. Vous pouvez sélectionner une valeur pour Nombre de tâches jusqu'au nombre de cœurs de processeur dans votre ordinateur. Utiliser plus de cœurs accélère le processus, mais peut ralentir votre machine si vous voulez continuer à l'utiliser pendant une longue construction. Cliquez OK pour démarrer la construction :

Figure 4.26 – Boîte de dialogue Lancer les exécutions

3. Pendant le processus de construction, Vivado affichera le statut dans le coin supérieur droit de la fenêtre principale. Si nécessaire, vous pouvez annuler le processus de construction en cliquant Annuler à côté de l'affichage de statut :

Figure 4.27 – Affichage du statut de compilation

4. Quand le processus de construction se termine, en supposant qu'il n'y a pas eu d'erreurs fatales, une boîte de dialogue Génération du Bitstream Terminée apparaîtra. Bien que d'autres options soient offertes, nous procéderons directement au téléchargement du bitstream sur la carte Arty. Sélectionnez Ouvrir le Gestionnaire Matériel et cliquez OK :

Figure 4.28 – Boîte de dialogue Génération du Bitstream Terminée

Ensuite, nous téléchargerons le bitstream dans le FPGA.

Téléchargement du bitstream sur la carte

Effectuez les étapes suivantes pour télécharger le bitstream sur une carte Arty A7 :

1. La boîte de dialogue GESTIONNAIRE MATÉRIEL apparaîtra et indiquera Aucune cible matérielle n'est ouverte.
2. Connectez votre carte Arty A7-35 ou A7-100 à l'ordinateur avec un câble USB. Attendez quelques secondes que la carte soit reconnue, puis cliquez Ouvrir la cible, puis Connexion automatique :

Figure 4.29 – Sélections Ouvrir la cible et Connexion automatique

3. Après quelques secondes, Vivado devrait indiquer que la carte est connectée. Cliquez Programmer le dispositif pour télécharger le bitstream FPGA sur la carte Arty. Vous serez invité à sélectionner un fichier bitstream. Si vous avez utilisé la même structure de répertoire que cet exemple, le fichier sera situé à C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bit :

Figure 4.30 – Boîte de dialogue Programmer le dispositif

4. Cliquez Programmer pour télécharger le programme sur le dispositif FPGA et le démarrer
5. Vous pouvez maintenant tester le fonctionnement du programme avec les E/S de la carte Arty. Placez les quatre interrupteurs en position off (déplacez les interrupteurs vers le bord de carte adjacent) et n'appuyez sur aucun des quatre boutons-poussoirs. Les quatre LEDs vertes devraient être éteintes.
6. Si vous allumez n'importe quel interrupteur individuel ou appuyez sur n'importe quel bouton-poussoir, la LED verte correspondante devrait s'allumer. Allumer n'importe quelle combinaison d'interrupteurs tout en appuyant sur n'importe quel nombre de boutons-poussoirs additionnera les nombres 4 bits correspondants et allumera les LEDs avec le. S'il y a une retenue (par exemple, allumez SW3 et appuyez sur BTN3 simultanément), la LED de retenue verte s'allumera.

Le processus de programmation effectué ici a stocké le programme dans la RAM du FPGA. Si vous coupez l'alimentation de la carte FPGA, vous devrez répéter le processus de programmation pour recharger le programme. Alternativement, vous pouvez stocker le fichier de configuration FPGA dans la mémoire flash embarquée comme décrit dans la section suivante.

Programmation du bitstream dans la mémoire flash embarquée

Pour configurer le FPGA chaque fois que l'alimentation est appliquée à la carte Arty, le fichier de configuration FPGA doit être stocké dans la mémoire flash sur la carte. Si le cavalier MODE est installé, le FPGA tentera de télécharger un fichier de configuration depuis la mémoire flash embarquée à la mise sous tension. Cette mémoire est située dans une puce séparée adjacente au FPGA Artix-7. Suivez ces étapes pour programmer le fichier de configuration dans la mémoire flash :

1. Installez le cavalier MODE sur la carte Arty s'il n'est pas déjà en place
2. Clic droit sur Générer le Bitstream et sélectionnez Paramètres du Bitstream….
3. Dans la boîte de dialogue Paramètres , cochez la case à côté de -bin_file et cliquez OK :

Figure 4.31 – Boîte de dialogue Paramètres du Bitstream

4. Dans la boîte de dialogue principale Vivado, cliquez Générer le Bitstream et répétez le processus de génération du bitstream. Cliquez Annuler quand la boîte de dialogue Génération du Bitstream Terminée apparaît

5. Dans la boîte de dialogue Matériel, clic droit sur le numéro de pièce FPGA (xc7a100t_0) et sélectionnez Ajouter un Dispositif de Mémoire de Configuration… :

Figure 4.32 – Sélection de menu Ajouter un Dispositif de Mémoire de Configuration…

6. Tapez s25fl127 dans la Recherche . Cela devrait faire apparaître un numéro de pièce correspondant. Sélectionnez la pièce et cliquez OK :

Figure 4.33 – Boîte de dialogue Ajouter un Dispositif de Mémoire de Configuration

7. Une boîte de dialogue vous demandera Voulez-vous programmer le dispositif de mémoire de configuration maintenant ? Cliquez OK.
8. Cela fera apparaître une boîte de dialogue Programmer le Dispositif de Mémoire de Configuration demandant le nom de fichier de configuration. Cliquez sur le bouton … à droite de Fichier de configuration et sélectionnez C:/Projects/ArtyAdder/ArtyAdder.runs/impl_1/ARTY_ADDER.bin. Cliquez OK :

Figure 4.34 – Boîte de dialogue Programmer le Dispositif de Mémoire de Configuration

9. Le processus de programmation prendra plusieurs secondes. Vous devriez recevoir un message indiquant le succès après que le fichier a été programmé dans la mémoire flash de la carte :

Figure 4.35 – Boîte de dialogue Programmation Flash terminée

Après cela, chaque fois que vous cyclez l'alimentation de la carte, le programme d'additionneur 4 bits se chargera et s'exécutera. Il faudra beaucoup de temps pour que le programme se charge avec les paramètres que nous avons utilisés pour le chargement du fichier de configuration. Pour éviter d'attendre que le FPGA charge le programme, vous pouvez améliorer la vitesse de chargement du fichier de configuration en effectuant les étapes suivantes :

1. Sélectionnez Ouvrir le Design Synthétisé dans Navigateur de Flux.
2. Dans le menu principal Vivado, sélectionnez Outils/Éditer les Propriétés du Dispositif….
3. Dans l'onglet Général , définissez Activer la Compression du Bitstream sur TRUE.
4. Dans l'onglet Configuration , définissez Taux de Configuration (MHz) à 33, puis cliquez OK.
5. Générez à nouveau le bitstream, et programmez la mémoire flash comme décrit. Vous devrez supprimer le dispositif de mémoire de configuration et l'ajouter à nouveau pour afficher l'option de reprogrammation.
6. Fermez Gestionnaire Matériel.
7. Débranchez le câble USB de la carte Arty et rebranchez-le. Le programme devrait commencer à s'exécuter virtuellement instantanément à la mise sous tension.

Cette section a présenté un exemple de logique combinatoire simple interagissant avec les signaux sur les broches E/S du FPGA. L'intention ici a été de vous familiariser avec la suite d'outils Vivado

et de démontrer comment les outils sont utilisés pour effectuer un cycle de développement FPGA complet.

Résumé

Ce chapitre a commencé par une discussion sur l'utilisation efficace des FPGA dans les architectures de systèmes embarqués temps réel et s'est poursuivi avec une description des dispositifs FPGA standard et des composants de bas niveau qu'ils contiennent. La gamme de langages de conception FPGA, incluant les HDL, les méthodes de diagramme de blocs, et les langages de programmation logicielle populaires tels que C/C++, a été introduite. Un aperçu du processus de développement FPGA a été présenté. Le chapitre s'est conclu par un exemple complet d'un cycle de développement FPGA, commençant par une déclaration d'exigences et se terminant par un système fonctionnel implémenté sur une carte de développement FPGA à faible coût.

Après avoir complété ce chapitre, vous devriez savoir comment les FPGA peuvent être appliqués efficacement dans les architectures de systèmes embarqués temps réel et comprendre les composants à l'intérieur d'un circuit intégré FPGA. Vous avez appris les langages de programmation utilisés dans la conception d'algorithmes FPGA, les étapes du cycle de développement FPGA, et comprenez la séquence des étapes dans le processus de développement FPGA.

Le prochain chapitre étendra le processus de développement FPGA pour fournir une approche complète d'architecture de systèmes embarqués temps réel contenant des FPGA. Il commencera également le développement d'un système embarqué haute performance prototype, un oscilloscope numérique, qui servira d'exemple pour les chapitres suivants.

Réimprimé avec la permission de Packt Publishing. Copyright © 2021 Packt Publishing

---

Jim Ledin est le PDG de Ledin Engineering, Inc. Jim est un expert en conception logicielle et matérielle embarquée, développement et test. Il est également accompli en évaluation de cybersécurité des systèmes embarqués et tests de pénétration. Il a un B.S. en ingénierie aérospatiale de Iowa State University et un M.S. en ingénierie électrique et informatique de Georgia Institute of Technology. Jim est un ingénieur électrique professionnel enregistré en Californie, un Certified Information System Security Professional (CISSP), un Certified Ethical Hacker (CEH), et un Certified Penetration Tester (CPT).

---

Contenus connexes :

• Conception embarquée avec FPGA : Ressources matérielles
• Conception embarquée avec FPGA : Langages d'implémentation
• Conception embarquée avec FPGA : Processus de développement
• Outils open-source aident à simplifier la programmation FPGA
• Implémentation d'algorithmes à virgule flottante dans FPGA ou ASIC
• Exploiter les FPGA pour l'apprentissage profond
• Outils logiciels migrent le code GPU vers FPGA pour applications IA

Pour plus d'Embedded, abonnez-vous à la newsletter hebdomadaire d'Embedded.