Arduino MKR Vidor 4000 – Présentation et mise en route

La première carte Arduino avec un FPGA

Ce premier article sera consacré à la carte ARDUINO™ MKR Vidor 4000.

Elle est disponible à l’achat au prix de €62,90 HT (montant auquel il faudra ajouter la TVA et le port).

La Vidor 4000 se démarque des autres cartes ARDUINO™ par la présence d’un FPGA. Celui-ci devrait permettre des traitements audio/vidéo, ce qui n’était jusqu’alors pas possible avec un simple microcontrôleur.

7 commentaires Donner une note  l'article (5)

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Présentation

La carte Vidor se compose :

  • d’un microcontrôleur ATSAMD21G18A embarquant 256 ko de Flash et 32 ko de RAM ;
  • d’un FPGA Cyclone 10CL016 avec 15 408 éléments logiques, 504 kbits de RAM et 56 multiplicateurs 18×18 ;
  • d’une FLASH SPI de 16 Mbits ;
  • d’une SDRAM de 64 Mbits (4M x 16 bits) ;
  • d’un module WiFi/BLE NINA W102 intégrant un microcontrôleur double cœur ESP32 ;
  • d’une puce cryptographique ATECC508A améliorant la vitesse de traitement pour les connexions sécurisées ;
  • de connecteurs MiniPCIe, USB, batterie, I2C, MKR, MIPI pour une caméra, HDMI pour la sortie vidéo.

Autant dire qu’entre le microcontrôleur SAMD21 cadencé à 48 MHz, le module WiFi (complètement reprogrammable), et le FPGA (supportant un grand nombre de standards d’E/S), ARDUINO™ nous livre ici une carte polyvalente qui devrait contenter le plus grand nombre.

Le schéma électronique de la carte est disponible ici.

Je l’ai repris en partie dans le tableau synoptique ci-dessous pour plus de clarté.

Image non disponible

On constate qu’ARDUINO™ a souhaité mettre le FPGA au centre du système puisque celui-ci a accès à la quasi-totalité des ressources. Libre à l’utilisateur de gérer les ressources dans le FPGA lui-même ou bien de rerouter celles-ci vers le processeur SAMD21 ou même encore l’ESP32 du module WiFi.

Si le microcontrôleur et le module WiFi possèdent leur propre mémoire non volatile pour l’exécution de leur programme, la configuration initiale du FPGA est chargée quant à elle à chaque mise sous tension depuis le début de la mémoire FLASH.

Image non disponible

Les fichiers source de cette configuration ne sont, il me semble, toujours pas publiés.

On peut néanmoins dire que celle-ci permet :

  • d’afficher le logo ARDUINO™ sur la sortie HDMI ;
  • de lire et écrire la FLASH afin de mettre à jour les deux configurations (Factory + user), ainsi que les données utilisateur ;
  • de basculer sur la configuration utilisateur.

C’est donc par l’intermédiaire de cette configuration chargée à la mise sous tension qu’il nous sera possible de mettre à jour plusieurs types de configuration utilisateur.

Arduino a pour l’instant mis à disposition deux configurations :

VidorGraphics qui permet :

  • de dessiner sur la sortie HDMI ;
  • d’afficher ce que voit une caméra connectée en MIPI et d’y reconnaître des QR codes.

VidorPeripherals qui donne l’accès à un plus grand nombre d’interfaces via le port MKR (liaisons séries UART/SPI/I2C, quadrature encodeurs…)

La bonne nouvelle est que les sources de ces deux configurations sont maintenant disponibles ici. La mauvaise nouvelle est qu’il n’est pas prévu que l’utilisateur puisse directement et simplement programmer le FPGA en passant par l’interface ARDUINO™.

Il vous faudra donc, si vous souhaitez franchir le pas de la programmation du FPGA, apprendre les bases de l'outil Quartus™ d'ALTERA™.
Avant que ne vous fuyiez directement, j'aimerais vous rassurer. Même si Quartus™ est un outil professionnel extrêmement puissant et assez complexe, on peut facilement lui demander de réaliser des choses simples.
Avec les deux articles que j'ai écris sur mon blog à ce sujet, j'espère pouvoir vous emmener au minimum jusqu'à écrire votre première configuration FPGA.

Mais voyons maintenant comment programmer cette nouvelle carte.

II. Mise en route de la carte

Vous trouverez sur le site d’ARDUINO™ un Image non disponibleguide de mise en route.

J’ai choisi pour ma part d’utiliser l’« ARDUINO™ Desktop IDE » qui est téléchargeable Image non disponibleici.

Lors de l’installation, le logiciel vous demandera d’entrer les options.

Sélectionnez-les toutes et appuyez sur Next.

Image non disponible

Choisissez le répertoire où vous souhaitez installer le programme et cliquez sur Install :

Image non disponible

Cliquez sur Installer lorsque Windows vous demande l’autorisation d’installer des pilotes de périphérique :

Image non disponible

Et, si cela n’a pas été fait précédemment, vous devrez également autoriser (ou pas ?) Java à accéder à Internet :

Image non disponible

Une fois le logiciel ARDUINO™ lancé, il vous faudra installer l’environnement correspondant à votre carte. Pour cela, allez dans « Outils / Type de carte… / Gestionnaire de carte » :

Image non disponible

Puis sélectionnez l’environnement correspondant :

Image non disponible

Enfin, retournez dans « Outils / Type de carte… » pour sélectionner l’Arduino MKR Vidor 4000 :

Vous pouvez maintenant connecter votre carte au PC et configurer le port COM.

Le code contenu dans le bootloader ou dans l’application chargée par défaut dans le SAMD21 devrait permettre à votre PC de reconnaître un port COM.

Image non disponible

En cas de problème avec le port COM, appuyez deux fois rapidement sur le petit bouton bleu de la carte. Cela permettra de revenir en mode bootloader. La LED rouge devrait s’allumer et s’éteindre progressivement toutes les secondes.

Image non disponible

Nous allons maintenant ouvrir et téléverser un sketch de base d’ARDUINO™ afin de vérifier que tout fonctionne correctement.

Allez dans « Fichier → Exemples → 01. Basics → Blink » :

Image non disponible

Comme la LED rouge de la carte clignote déjà au rythme d’une fois par seconde, nous allons légèrement modifier le code pour remplacer delay(1000) par delay(200).

 
Sélectionnez
// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
  delay(200); // wait for 200 milliseconds
  digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
  delay(200); // wait for 200 milliseconds
}

Il nous reste maintenant à compiler et téléverser le code dans le microcontrôleur de la carte.

Il suffit pour cela de cliquer sur l’icône suivant :

Image non disponible

Si tout s’est bien passé (comptez moins d’une minute), vous allez voir s’afficher dans la fenêtre du bas les lignes suivantes :

 
Sélectionnez
Le croquis utilise 10740 octets (4%) de l’espace de stockage de programmes. Le maximum est de 262144 octets.
Atmel SMART device 0x10010005 found
Device : ATSAMD21G18A
Chip ID : 10010005

……
……
[==============================] 100% (171/171 pages)
done in 0.070 seconds

Verify 10884 bytes of flash with checksum.
Verify successful
done in 0.011 seconds
CPU reset.

La LED rouge de la carte devrait maintenant clignoter plus vite.

Si au bout d’une minute l’écran reste bloqué sur :

 
Sélectionnez
Le croquis utilise 10740 octets (4%) de l’espace de stockage de programmes. Le maximum est de 262144 octets.

appuyez deux fois sur le bouton reset (bleu) de la carte, reconfigurez au besoin le port COM « Outils → Port. » et recommencez.

Si tout fonctionne correctement à ce stade, vous avez réussi à téléverser votre programme dans la mémoire du microcontrôleur SAMD21, sans modifier par contre la configuration du FPGA :

Image non disponible

Pour installer les librairies spécifiques de la carte, allez dans le gestionnaire de librairies ARDUINO.

Image non disponible

Puis installez les librairies de la carte (saisir « vidor ») dans la barre de recherche.

Image non disponible

Comme précédemment, nous allons ouvrir et téléverser un sketch d’exemple : « VidorTestSketch ».
Allez dans « Fichier→ Exemples → VidorPeripherals → VidorTestSketch ».

Si le téléversement s’est bien déroulé, vous devriez pouvoir observer en ouvrant un terminal sur le port COM de la carte, les lignes suivantes :

 
Sélectionnez
Vidor bitstream version: 1020107
number of devices 9
1 01000000 MB_DEV_SF
1 02000000 MB_DEV_GPIO
4 04000000 MB_DEV_I2C
6 05000000 MB_DEV_SPI
8 06000000 MB_DEV_UART
1 08000000 MB_DEV_SDRAM
4 09000000 MB_DEV_NP
11 0A000000 MB_DEV_ENC
0 0B000000 MB_DEV_REG
Pin A0 is HIGH
Pin A0 is LOW

Il arrive que le téléversement reste bloqué en plein milieu avec un message du type :

 
Sélectionnez
[===============                             ] 37% (…/171 pages)

Dans ce cas, vérifiez qu’aucun autre logiciel ne tente de se connecter à un des deux ports COM utilisés par la carte, débranchez et rebranchez-la, appuyez deux fois sur reset et recommencez.

Si cela ne fonctionne toujours pas, il vous faudra sans doute remettre la carte dans sa configuration d’origine.

Pour cela, téléchargez les outils disponibles ici, décompressez le fichier et suivez le tutoriel.

III. Programmation d’une configuration dans le FPGA

Nous avons, dans le dernier exemple, non seulement programmé la FLASH du SAMD21, mais également reconfiguré le FPGA avec la configuration VidorPeripherals.

Voyons plus en détail comment s’est déroulée la programmation cette configuration.

Il existe entre le microcontrôleur et le FPGA une liaison de type JTAG. Le JTAG était à l’origine destiné aux tests de cartes électroniques puis à la programmation de composant comme le FPGA.

Dans ce cas, nous l’utilisons pour faire communiquer le bootloader avec un bloc logique implémenté dans la configuration initiale du FPGA.

Le bootloader va ainsi pouvoir demander au FPGA de lire et écrire des données dans la mémoire FLASH SPI.

Image non disponible

À la compilation du sketch, le compilateur va inclure dans le fichier généré, la configuration (app.ttf) qui devra être écrite dans le FPGA.

Cette configuration étant positionnée à une adresse bien déterminée, le bootloader sera en mesure de la transférer au FPGA. Ce dernier se chargera ensuite de l’écriture en FLASH SPI.

Je terminerai ce premier article en vous expliquant comment le microcontrôleur va maintenant pouvoir utiliser la nouvelle configuration du FPGA.

IV. Exécution du programme

À la mise sous tension, c’est la configuration initiale du FPGA qui est chargée.

Le microcontrôleur va alors exécuter les instructions suivantes :

 
Sélectionnez
// Let’s start by initializing the FPGA
if (!FPGA.begin()) {
  Serial.println("Initialization failed!");
  while (1) {}
}

La fonction FPGA.begin() va d’abord fournir au FPGA un signal d’horloge afin que celui-ci puisse démarrer : enableFpgaClock()

Elle va ensuite initialiser le port JTAG pour communiquer avec le FPGA : jtagInit().

Enfin, elle va envoyer au FPGA via le port JTAG la commande (0x00000003), en lui demandant de charger la configuration utilisateur (le app.ttf que nous avons précédemment écrit en FLASH).

Toutes les autres instructions à destination du FPGA (dessiner un cercle, configurer un port COM…) seront ensuite envoyées et la réponse reçue par l’intermédiaire de ce même port JTAG.

Pour aller plus loin, vous trouverez sur mon blog (et bientôt peut être sur developpez.net) des articles sur la façon de réaliser vos propres configurations pour le FPGA de cette carte.

V. Note de la rédaction Developpez

Cet article est une mise à jour par l'auteur lui-même d'un article initialement posté sur son blog https://www.systemes-embarques.fr/.

Merci à f-leb et à naute pour la mise en page et les corrections.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2019 Philippe. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.