Arduino MKR Vidor 4000 – Présentation et mise en route
Mise à jour du 23/08/18 : Les librairies sont maintenant directement accessibles via le gestionnaire de librairies. J’ai donc modifié l’article en conséquence.
Mon premier article sera consacré à la carte ARDUINO™ MKR Vidor 4000.
Elle est maintenant disponible à l’achat au prix de €49,90 HT (Il faut compter €70 avec 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’étaient jusqu’alors pas possible avec un simple microcontrôleur.
La carte Vidor se compose :
- d’un microcontrôleur ATSAMD21G18A embarquant 256ko de Flash et 32ko de RAM.
- d’un FPGA Cyclone 10CL016 avec 15408 éléments logiques, 504kbits de RAM et 56 multiplicateur 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é à 48Mhz, le module Wifi (complètement reprogrammable), et le FPGA (supportant un grand nombre de standard 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é.
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.
Pour le moment, les fichiers sources de cette configuration ne sont pas publiés. Il faudra sans doute attendre le mois d’octobre.
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 2 configurations (Factory + user), ainsi que les données utilisateurs.
- 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 2 configurations :
VidorGraphics qui permet :
- de dessiner sur la sortie HDMI,
- d’afficher ce que voit une caméra connecté en MIPI et d’y reconnaître des QR codes.
VidorPeripherals qui donne l’accès à un plus grand nombre d’interface via le port MKR (liaisons séries UART/SPI/I2C, quadrature encodeurs,…)
La mauvaise nouvelle est qu’il n’est pas prévu que l’utilisateur puisse directement programmer le FPGA en passant par l’interface ARDUINO™. Il serait question d’ici la fin de l’année d’offrir la possibilité de paramétrer la connexion entre différents blocs logiques.
Nous verrons par contre dans un prochain article, comment les utilisateurs ayant l’expérience des outils d’ALTERA (Quartus), peuvent facilement créer et charger leur propre configuration.
Mais voyons maintenant comment programmer cette nouvelle carte.
Mise en route de la carte
Vous trouverez sur le site d’ARDUINO™ un guide de mise en route.
Les librairies étant encore en version bêta, vous devrez effectuer quelques opérations supplémentaires.
J’ai choisi pour ma part d’utiliser l’ « ARDUINO™ Desktop IDE » qui est téléchargeable ici.
Lors de l’installation le logiciel vous demandera d’entrer les options.
Sélectionnez les toutes et appuyez sur Next.
Choisissez le répertoire où vous souhaitez installer le programme et cliquez sur Install :
Cliquez Installer lorsque Windows vous demande l’autorisation d’installer des pilotes de périphérique :
Et si cela n’a pas été fait précédemment vous devrez également autoriser (ou pas?) JAVA à accéder à internet :
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 » :
Puis sélectionnez l’environnement correspondant :
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.
En cas de problème avec le port COM, appuyez 2 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 toute les secondes.
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 »
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)
// 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 miliseconds
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(200); // wait for 200 miliseconds
}
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 :
Si tout c’est bien passé (comptez moins d’une minute), vous allez voir s’afficher dans la fenêtre du bas les lignes suivantes :
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 :
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écharger votre programme dans la mémoire du microcontrôleur SAMD21, sans modifier par contre la configuration du FPGA :
Pour installer les librairies spécifiques de la carte, allez dans le gestionnaire de librairies ARDUINO.
Puis installez les librairies de la carte (saisir “vidor”) dans la barre de recherche.
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 :
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 :
[=============== ] 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 tutorial.
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ée 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.
A 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.
Exécution du programme
A 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 :
// 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és et la réponse reçue par l’intermédiaire de ce même port JTAG.
Dans une deuxième partie, je vous présenterai comment créer votre propre configuration en utilisant le logiciel QUARTUS.