Geekly articles weekly

Exécution de .Net Micro Framework 4.4 sur STM32F4Discovery


.Net Micro Framework est une technologie qui vous permet d'écrire des applications pour microcontrôleurs en utilisant toute la puissance du code managé et de Visual Studio. Elle existe depuis longtemps et connaît actuellement une renaissance. Un projet open source a été formé autour de lui, qui a récemment migré vers GitHub. Cependant, ce n'est pas encore un produit "en boîte". Travailler avec .Net Micro Framework nécessite certaines compétences. La dernière fois que j'ai écrit sur la façon de créer et d'exécuter une simple application "Hello world" sur l'émulateur pour Windows. Nous allons maintenant parler de la façon de travailler avec .Net Micro Framework sur le vrai matériel - la carte de débogage STM32F4Discovery.

Les frais sont assez courants et peuvent être achetés, par exemple, ici . Depuis la version 4.4, le port de cette carte est inclus dans la distribution netmf-interpreter. Auparavant, il existait en tant que projet distinct .

Sur Internet et, en particulier, sur le hub, vous pouvez trouver des documents sur le lancement du .Net Micro Framework sur cette carte, mais d'une part ils parlent de la version 4.3, et d'autre part, ils utilisent déjà l'assemblage fini. Je vais vous expliquer en détail comment compiler et exécuter sur STM32F4Discovery .Net Micro Framework version 4.4. L'article sera long, car il faudra corriger plusieurs erreurs dans le kit de distribution et télécharger et installer plusieurs utilitaires et pilotes.

Préparation de la compilation



Distribution


Tout d'abord, vous devez avoir la distribution elle-même.

Le référentiel est ici . Vous pouvez le télécharger sous forme d'archive zip, ou vous pouvez l'obtenir en utilisant git. Des instructions en anglais sur la façon d'obtenir le référentiel et de collecter les fichiers d'installation à partir de celui-ci peuvent être trouvées ici . Sur la base de ces instructions, un article a été écrit. Les versions du référentiel associées à des versions spécifiques peuvent être téléchargées à partir des archives zip ici .

Pour obtenir le référentiel à l'aide de git, vous devez procéder comme suit:
  1. Créez une copie publique sur votre compte sur les serveurs GitHub par fork . Toutes les demandes d' extraction doivent provenir du référentiel public GitHub.
  2. , clone. , :
    git clone github.com/<your GitHub ID>/netmf-interpreter.git
    : . , D:\NETMF\repo, repo — . .
  3. , Upstream. pull pull. Upstream :
    git remote add upstream https://github.com/NETMF/netmf-interpreter.git


Important : Les exigences pour le chemin local (il doit y avoir au moins un dossier parent - voir la section 2 de l'utilisation de git) sont également pertinentes lors du déballage du référentiel de l'archive.

Malheureusement, la version de .NET Micro Framework v4.4 Release To Web (RTW) contient des erreurs qui ne vous permettent pas de collecter immédiatement les fichiers d'installation à partir du référentiel. Cependant, ces erreurs peuvent être corrigées, puis je vous dirai comment le faire.
Une fois que le référentiel a été copié dans un dossier local d'une manière ou d'une autre, vous devez procéder comme suit:

  1. Téléchargez le fichier zip des outils binaires . Ce fichier contient les utilitaires nécessaires pour créer à la fois des fichiers d'installation et des «ports» pour les périphériques. À l'avenir, il est prévu d'abandonner ces services publics, mais jusqu'à présent, ils sont nécessaires.
  2. binary tools zip- . D:\NETMF\repo, repo — , bin tools D:\NETMF.
  3. :
    <repo folder>\Framework\Tools\BuildTasksInternal\BuildSigner\BuildSignerSpotBuild.csproj
    37
    <HintPath>$(MSBuildProgramFiles32)\Microsoft Internal\Codesign.Submitter\CODESIGN.Submitter.dll</HintPath>

    <HintPath>$(SPOROOT)\tools\x86\CODESIGN\CODESIGN.Submitter.dll</HintPath>

    . . , .Net Micro Framework open source , , , . .NET Micro Framework v4.4 Release To Web (RTW). . .
  4. CMSIS <repo folder>\MSIS. , <repo folder>\MSIS\ReadMe.md.

    CMSIS Cortex Microcontroller Software Interface Standart. Cortex-M, — ARM. “” .

    .Net Micro Framework 4.4 CMSIS 4.3. zip- (CMSIS-SP-00300-r4p3-00rel0.zip). ARM. <repo folder>\MSIS.
  5. .Net Micro Framework Cryptographic Libraries. , . . , , , .

    msi . ( <crypto install folder>), , D:\NETMF\repo D:\NETMF\repo_master.


La distribution est une structure complexe avec un grand nombre de références croisées. Combiné tout cela avec un projet pour MSBuild . Les fichiers de projet ressemblent aux fichiers sln et proj familiers pour Visual Studio, mais à l'intérieur, ils ont une structure plus complexe. C'est pourquoi l'utilisation de Visual Studio pour l'assembly échouera.

Je vais vous en dire plus sur les composants et les relations au sein de la distribution dans les articles suivants, mais maintenant vous devez savoir que le port pour STM3F4Discovery se trouve dans le dossier
<repo folder>\Solutions\STM32F4DISCOVERY
et que les fichiers binaires et hexadécimaux collectés apparaîtront dans le dossier
<repo folder>\BuildOutput


Visual Studio


MSBuild fait partie de Visual Studio. La documentation de l'interpréteur .netmf 4.4 indique que les éditions Visual Studio 2015 Community, Pro et Ultimate sont prises en charge, vous devez donc en installer une pour réussir la création du port.

Compilateur ARM


Ensuite, vous avez besoin d'un compilateur pour ARM . Le travail avec deux compilateurs est fourni:


Le compilateur RealView fait partie de l'outil de développement Keil MDK . La version gratuite a une limite de 32 ko de code, mais le port a un plus grand volume, vous avez donc certainement besoin d'une licence, par exemple, une licence d' essai MDK-Professional de 7 jours . Vous pouvez en savoir plus sur l'installation de Keil MDK 5 ici .
Il doit être installé par défaut dans le dossier C:\Keil_v5.

GCC est gratuit, mais le firmware qu'il génère est 10% plus grand que celui généré par le compilateur RealView. GCC ARM Embedded peut être téléchargé en tant qu'archive et décompressé à n'importe quel emplacement. Le dossier avec le contenu décompressé de l'archive que j'appellerai plus loin <gcc folder>.

Compilation avec les outils de compilation ARM RealView



Le kit de distribution a déjà défini les paramètres de compilation pour les versions MDK 3.1, 3.80a, 4.12, 4.13, 4.54, 5.04, 5.05. Si vous devez utiliser une version différente, vous pouvez ajouter plusieurs lignes au fichier.
<repo folder>\tools\Targets\Microsoft.Spot.system.mdk.targets

J'ai utilisé la version 5.06. Pour ce faire, après les lignes

<CC      Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.05'">"$(MDK_TOOL_PATH)\ARMCC\bin\armcc.exe"</CC>
<CPP     Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.05'">"$(MDK_TOOL_PATH)\ARMCC\bin\armcc.exe"</CPP>
<AS      Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.05'">"$(MDK_TOOL_PATH)\ARMCC\bin\armasm.exe"</AS>
<LINK    Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.05'">"$(MDK_TOOL_PATH)\ARMCC\bin\armlink.exe"</LINK>
<AR      Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.05'">"$(MDK_TOOL_PATH)\ARMCC\bin\armar.exe"</AR>
<FROMELF Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.05'">"$(MDK_TOOL_PATH)\ARMCC\bin\fromelf.exe"</FROMELF>
 <MdkCrtLibLinkSwitch Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.05'">$(MdkCrtLibLinkSwitch) $(SWTC)libpath $(MDK_TOOL_PATH)\ARMCC\LIB</MdkCrtLibLinkSwitch>


J'ai ajouté les lignes

<CC      Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.06'">"$(MDK_TOOL_PATH)\ARMCC\bin\armcc.exe"</CC>
<CPP     Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.06'">"$(MDK_TOOL_PATH)\ARMCC\bin\armcc.exe"</CPP>
<AS      Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.06'">"$(MDK_TOOL_PATH)\ARMCC\bin\armasm.exe"</AS>
<LINK    Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.06'">"$(MDK_TOOL_PATH)\ARMCC\bin\armlink.exe"</LINK>
<AR      Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.06'">"$(MDK_TOOL_PATH)\ARMCC\bin\armar.exe"</AR>
<FROMELF Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.06'">"$(MDK_TOOL_PATH)\ARMCC\bin\fromelf.exe"</FROMELF>
<MdkCrtLibLinkSwitch Condition="'$(COMPILER_TOOL_VERSION)'=='MDK5.06'">$(MdkCrtLibLinkSwitch) $(SWTC)libpath $(MDK_TOOL_PATH)\ARMCC\LIB</MdkCrtLibLinkSwitch>


Vous pouvez maintenant commencer la compilation. Vous devez ouvrir la ligne de commande et aller dans le dossier avec le référentiel, par exemple comme ceci:
cd /d D:\WORKDIR\NetMf\NetMFRepo\repo

alors vous devez définir les variables d'environnement en faisant:
setenv_mdk 5.06



Ensuite, allez dans le dossier avec le port ( <repo folder>\Solutions\STM32F4DISCOVERY). Par exemple, comme ceci:
cd /d D:\WORKDIR\NetMf\NetMFRepo\repo\Solutions\STM32F4DISCOVERY

vous pouvez maintenant démarrer la compilation en utilisant, par exemple, la commande suivante:

msbuild dotnetmf.proj /p:flavor=release /fl

où

msbuild- appeler pour démarrer l'assembly

dotnetmf.proj- projet de port pour STM32F4DISCOVERY

/p:flavor=release- type d'assembly (debug / release / rtm)

/fl- écrire le journal d'assembly dans un fichier.

le fichier journal sera dans le dossier actuel (dans l'exemple ci-dessous D:\WORKDIR\NetMf\NetMFRepo\repo\Solutions\STM32F4DISCOVERY). Si le journal n'est pas nécessaire, /flvous pouvez le supprimer.

Pour voir toutes les options de compilation, vous devez exécuter. La
msbuild /t:help



compilation prend beaucoup de temps et cela me prend 10 minutes:


Le résultat sera un grand nombre de fichiers dont vous aurez besoin:
<repo folder>\BuildOutput\THUMB2FP\MDK5.06\le\FLASH\release\STM32F4DISCOVERY\bin\Tinybooter.hex\
<repo folder>\BuildOutput\THUMB2FP\MDK5.06\le\FLASH\release\STM32F4DISCOVERY\bin\tinyclr.hex\ER_CONFIG
<repo folder>\BuildOutput\THUMB2FP\MDK5.06\le\FLASH\release\STM32F4DISCOVERY\bin\tinyclr.hex\ER_FLASH


Pour une version propre, avant d'exécuter une commande,
msbuild dotnetmf.proj /p:flavor=release /fl
vous devez exécuter la commande
msbuild /t:clean
ou supprimer le dossier
<repo folder>\BuildOutput



Compilation avec GCC ARM Embedded



L'utilisation de GCC peut nécessiter une autre révision. Dans le fichier: vous devez ajouter
<repo folder>\Solutions\STM32F4DISCOVERY\STM32F4DISCOVERY.settings
après la ligne, ce qui corrige l'erreur «NNNN.a utilise des arguments de registre VFP» . En savoir plus ici . Toutefois, cette erreur peut ne pas se produire si vous utilisez une version «propre». Pour une construction propre, avant d'exécuter la commande, vous devez exécuter la commande ou supprimer le dossier. Donc, pour collecter le port, ouvrez la ligne de commande et accédez au dossier avec le référentiel, par exemple comme ceci: alors vous devez définir les variables d'environnement en faisant: où est la version gcc est le chemin où se trouve GCC ARM Embarqué La commande peut ressembler à ceci:
<NO_BOOTLOADER_COMPRESSION>true</NO_BOOTLOADER_COMPRESSION>

<PLATFORM_EMULATED_FLOATINGPOINT Condition="'$(COMPILER_TOOL)'=='GCC'">true</PLATFORM_EMULATED_FLOATINGPOINT>




msbuild dotnetmf.proj /p:flavor=release /fl

msbuild /t:clean

<repo folder>\BuildOutput




cd /d D:\WORKDIR\NetMf\NetMFRepo\repo


setenv_gcc <gcc ver> <gcc folder>

<gcc ver>
<gcc folder>


setenv_gcc 4.9.3 D:\WORKDIR\NetMf\gcc_4_9_3



Allez ensuite dans le dossier avec le port ( <repo folder>\Solutions\STM32F4DISCOVERY). Par exemple, comme ceci: La

cd /d D:\WORKDIR\NetMf\NetMFRepo\repo\Solutions\STM32F4DISCOVERY

compilation peut être démarrée en utilisant, par exemple, la commande suivante:

msbuild dotnetmf.proj /p:flavor=release /fl

où
  • msbuild - appel pour démarrer l'assemblage
  • dotnetmf.proj - conception de port pour STM32F4DISCOVERY
  • /p:flavor=release - type de build (debug / release / rtm)
  • /fl - écrire le journal d'assemblage dans un fichier.


le fichier journal sera dans le dossier actuel (dans l'exemple ci-dessous D:\WORKDIR\NetMf\NetMFRepo\repo\Solutions\STM32F4DISCOVERY). Si le journal n'est pas nécessaire, /flvous pouvez le supprimer.

Pour voir toutes les options de compilation, vous devez le faire. La
msbuild /t:help



compilation prend beaucoup de temps et prend 10 minutes:


Le résultat sera un grand nombre de fichiers dont vous aurez besoin:
<repo folder>\BuildOutput\THUMB2FP\GCC4.9\le\FLASH\release\STM32F4DISCOVERY\bin\Tinybooter.hex
<repo folder>\BuildOutput\THUMB2FP\GCC4.9\le\FLASH\release\STM32F4DISCOVERY\bin\tinyclr.hex\ER_CONFIG
<repo folder>\BuildOutput\THUMB2FP\GCC4.9\le\FLASH\release\STM32F4DISCOVERY\bin\tinyclr.hex\ER_FLASH


Micrologiciel de la carte



Ainsi, il y a 3 fichiers:
Tinybooter.hex, ER_CONFIG ER_FLASH.

TinybooterEst un chargeur de démarrage. Ils sont utilisés pour le firmware CLR. ER_CONFIGet ER_FLASHc'est le CLR lui-même.

Pour flasher la carte, nous avons besoin d'un logiciel supplémentaire:
  1. STM32 ST-LINK Utility - un programmeur pour flasher TinyBooter.
  2. Installé MicroFraimworkSDK.MSI et NetMFVS14.vsix - la première contient les bibliothèques et les services nécessaires, le second - projets de modèle .Net Micro Fraimwork pour Visual Studio.
  3. Pilote USB requis pour les utilitaires de MicroFraimworkSDK pour voir la carte (non requis pour Windows 10).


Pour flasher la carte, procédez comme suit:

  1. Connectez la carte à l'ordinateur via un câble miniUSB:


  2. Lancez l'utilitaire STM32 ST-LINK et sélectionnez le menu Cible-> Connecter:


    Après la connexion à la carte STM32, l'utilitaire ST-LINK ressemblera à ceci:


  3. Target->Erase Sectors...:


    Select All Apply:


    flash :


    STM32 ST-LINK Utility :


  4. TinyBooter.hex Target-> Program & Verify...:


    tinybooter.hex Start:


    STM32 ST-LINK Utility :


  5. miniUsb Reset

  6. microUSB :


    STM32 ST-LINK Utility . miniUsb .
  7. Windows 10 , USB :

  8. .NET Micro Framework Deployment Tool.
    MicroFrameworkSDK:
    C:\Program Files (x86)\Microsoft .NET Micro Framework\v4.4\Tools\MFDeploy.exe

    Serial USB:


    . TinyBooter Ping. Pinigng… TinyBooter



  9. .NET Micro Framework Deployment Tool 2 ER_CONFIG ER_FLASH. Browse…


    Deploy:


    Ping CLR :


    , .


Visual Studio



Vous pouvez maintenant créer et exécuter le projet dans Visual Studio. Faisons un projet simple et clignotant, des LED clignotantes.

Nous démarrons Visual Studio et créons un nouveau projet:


si l'installation du SDK et de vsix s'est terminée correctement, un nouveau modèle de projet Micro Framework apparaîtra. Sélectionnez l'application console:


après avoir créé la solution, vous pouvez accéder aux propriétés du projet:


dans les paramètres du projet sous l'onglet .NET Micro Framework, dans le champ Transport, sélectionnez USB. Après cela, le nom de la carte devrait apparaître dans le champ Appareil:


Enregistrez et fermez les paramètres.

Ensuite, ajoutez Réfrence à l'assembly à:
C:\Program Files (x86)\Microsoft .NET Micro Framework\v4.4\Assemblies\le\Microsoft.SPOT.Hardware.dll



Et la dernière étape consiste à remplacer le code program.cspar ceci:

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;

namespace STM32F4DISC_Test
{
    public class Program
    {
        public static void Main()
        {
            OutputPort ledGreen = new OutputPort((Cpu.Pin)60, false);
            OutputPort ledYellow = new OutputPort((Cpu.Pin)61, false);
            OutputPort ledRed = new OutputPort((Cpu.Pin)62, false);
            OutputPort ledBlue = new OutputPort((Cpu.Pin)63, false);

            while (true)
            {
                ledGreen.Write(true);
                Thread.Sleep(500);
                ledYellow.Write(true);
                Thread.Sleep(500);
                ledRed.Write(true);
                Thread.Sleep(500);
                ledBlue.Write(true);
                Thread.Sleep(500);
                ledGreen.Write(false);
                ledYellow.Write(false);
                ledRed.Write(false);
                ledBlue.Write(false);
                Thread.Sleep(500);
            }
        }
    }
}


Nous commençons le projet:


Et après quelques secondes, les LED sur la carte commencent à clignoter.

Conclusion



.NET Micro Fraimwork est un projet assez compliqué. À l'heure actuelle, cela nécessite encore certaines compétences et connaissances, en particulier lorsque vous travaillez avec le référentiel. Dans cet article, j'ai spécifiquement parlé le plus précisément possible de ce que vous devez gérer lors de la compilation des ports, car ces informations vous seront utiles lors du développement de solutions pour vos propres cartes.
Cependant, l'exécution de .NET Micro Fraimwork sur STM32F4Discovery peut être plus simple et plus rapide en prenant des fichiers Tinybooter.hex, ER_CONFIG et ER_FLASH prêts à l'emploi. Vous pouvez les télécharger ici .

Source: https://habr.com/ru/post/fr387333/

More articles:


All Articles