Comment commencer ARM Programmation Cortex utilisant C intégré?

Question

Je connais bien la programmation C 8051. Maintenant, je veux apprendre la programmation M3 du cortex ARM. J'ai la carte de développement STM32F103C8T6 avec le processeur ARM Cortex M3, son programmeur et son compilateur Keil.Je veux faire de petits projets avec, par exemple, des voyants clignotants, la programmation SPI et I2C, etc. Beaucoup de gens sur les blogs disent commencer directement à programmer au lieu de lire une architecture ou de lire une fiche technique de cent pages ARM. Je ne comprends pas comment c'est possible.

Alors, quel devrait être mon premier pas?

Dois-je lire la fiche technique du manuel d'utilisation STM32F103C8T6 ou ARM Cortex M3?
La programmation 8051 et ARM a beaucoup de différence. En 8051, il n'est pas nécessaire d'ajouter des fichiers de bibliothèque/en-tête. Dans ARM, nous devons ajouter de nombreux fichiers bibliothèque/en-tête . Supposons que je veuille faire un programme clignotant ou apprendre la communication SPI/I2C. Dans KEIL Compiler ou STM CubeMX, ces fichiers d’en-tête sont déjà présents. Mais si je souhaite tout faire (écrire les codes des fichiers d’en-tête pour les périphériques, les ports d’entrée/sortie, les codes de protocole SPI/I2C), est-ce vraiment possible? Si oui, que dois-je faire pour cela?

Je suis très confus et frustré car je n'ai pas encore trouvé la personne appropriée pour me guider à ce sujet

enter image description here

Clifford · Accepted Answer

Il est possible (c’est-à-dire de démarrer sans une connaissance détaillée des feuilles de données et des manuels de référence) si vous utilisez le code de la bibliothèque existante pour traiter les problèmes d’architecture, de démarrage et de pilote de périphérique. Pour ARM Cortex-M et STM32, en particulier ceux qui pourraient inclure (à différents niveaux d’abstraction et de portée):

Souvent, les fournisseurs d’outils commerciaux (tels que Keil, IAR, Rowley, Green Hills) fournissent des exemples de projets, ainsi que des bibliothèques de pilotes et des middlewares pour vous aider à démarrer - souvent pour des cartes de développement spécifiques.

C’est peut-être là que vous pensez que pour ARM vous programmer

"besoin d'ajouter plusieurs fichiers de bibliothèque/en-tête."

Vous n'avez pas besoin de le faire du tout, mais ce sont des pièces plus complexes que 8051 avec des jeux de périphériques vastes et complexes qui diffèrent entre les pièces et les fournisseurs, et vous pouvez économiser beaucoup de temps et d'efforts en utilisant de telles bibliothèques.

Notez que le noyau ARM Cortex-M n’inclut pas les périphériques du microcontrôleur, ni l’unité externe, ni le processeur, ni le contrôleur d’interruptions NVIC. fournisseurs - c’est la raison pour laquelle vous devez comprendre la documentation du fournisseur ou utiliser les bibliothèques de fournisseurs ou de bibliothèques fournies par la communauté ou la puce.

Si vous souhaitez bien comprendre le Cortex-M ou le STM32 et en tirer le meilleur parti, rien ne remplace la lecture du document de référence, mais il n’est en aucun cas nécessaire de commencer.

Si vous voulez un système in à Cortex-M plus facile que le matériel de référence ARM, Joseph Yiu's Le guide absolu des processeurs ARM® Cortex®-M3 et Cortex®-M4 est une bonne source, mais à moins que vous n'écriviez un code de démarrage de niveau faible RTOS ou nu-Metal ou un autre code de niveau système, vous n'aurez peut-être pas besoin de tant de matériel. La précédente édition de ce livre, uniquement en version M3, est disponible en tant que PDF dans à certains endroits .

Le manuel de référence du fournisseur de la puce, qui décrira les caractéristiques spécifiques du fournisseur, telles que les interfaces de mémoire, la mappe de mémoire, les fonctions de gestion de l'alimentation, la programmation de la mémoire flash, le mappage des interruptions et les périphériques matériels sera peut-être le matériau le plus utile.

Pour le STM32, il existe un guide assez large de Trevor Martin de Hitex: Le guide de l'initié du microcontrôleur STM32 ARM Based , parmi d'autres publications de Trevor pouvant être utile.

Ankit Kumar Ojha · Answer

J'y suis allé. Après un certain temps, j'ai réalisé qu'il est toujours préférable de commencer par la fiche technique, même si c'est votre premier tableau.

La fiche technique fournit un fonctionnement complet du tableau, des broches et de la communication de base. Cela peut être fastidieux mais cela en vaut la peine et vous vous en rendrez compte lorsque vous commencerez à programmer.

Après cela, vous pourrez directement accéder aux fichiers d'en-tête et voir la mise en œuvre des fonctionnalités de base. Cela vous donnera de nombreuses informations sur la technique d'optimisation, le style de programmation et les meilleures pratiques.

Si possible, trouvez plus de code écrit pour ce forum (j'échoue toujours ici, c'est difficile si votre forum est rare).

Avec cela, vous devriez être prêt à écrire presque n'importe quel code. Commencez avec le blinky (le monde des planches)

Aussi, avec mon expérience, je tiens à vous dire que ce n'est pas grave si cela prend du temps. Ayez de la patience et de la persistance.

Lundin · Answer

En tant que programmeur C, vous n’avez pas besoin de connaître l’architecture du cœur de la CPU, bien que je recommande une brève lecture du manuel de la CPU. Savoir quels sont les registres et les ressources, cache de données, cache d'instruction, etc., signifie que vous pouvez écrire du code C de meilleure qualité. Ceci est toutefois beaucoup plus important avec des noyaux horriblement mauvais comme 8051.

En ce qui concerne le matériel périphérique et la mémoire de la MCU, vous devez lire chaque ligne du manuel pour les parties que vous souhaitez utiliser. Cela inclut les principes fondamentaux tels que chien de garde, configuration de l'horloge, MMU, traitement des interruptions, etc.

Cependant, la plupart des chaînes d’outils pour MCU sont livrées avec une sorte de bibliothèque de revêtement de sucre. Ils vous donneront un projet de travail avec la plupart des choses définies. Cela signifie que vous n'avez pas à tout apprendre en même temps, mais que vous pouvez le faire petit à petit, au fur et à mesure de l'avancement du projet. Pour faire clignoter des voyants, par exemple, vous devriez pouvoir le faire sans lire autre chose que la partie GPIO du manuel.

Il se peut que vous deviez éventuellement remplacer les bibliothèques préconfigurées quick & dirty par un code de qualité. Cela est dû au fait que les fabricants de silicium qui fournissent ces bibliothèques ont une mauvaise réputation en matière d’écriture de logiciels. Dans certains cas, ils parviennent à vous donner le code de configuration MCU approprié, mais le plus souvent, ils vous donnent un code de mauvaise qualité.

Ceci est à peu près ce à quoi une configuration MCU devrait ressembler. Vous pouvez utiliser la liste pour vérifier si ce que vous avez obtenu du fabricant est vraiment utile ou s'il doit être réécrit par un programmeur professionnel intégré. ARM CMSIS par exemple, peut être ou ne pas être assez bon, en fonction des exigences de l'application. Il existe aussi différentes saveurs, en fonction de la chaîne d'outils.

old_timer · Answer

Voici quelques exemples de travail et des conseils, si ce que vous cherchez n’est pas ce que vous cherchez, alors TL; DR ne vous embêtez pas ...

Je vous recommande de suivre les différents chemins et de le répéter périodiquement. Profesonally, vous voulez pouvoir couvrir la gamme allant des simples feuilles de données/schémas aux bibliothèques en boîte des fournisseurs et jusqu'aux solutions freeros ou autres. Mes préférences personnelles sont les feuilles de données/schémas. Je trouve que cela prend moins de temps et est plus propre, plus rapide, plus fiable, etc. YMMV. La première règle est que la documentation est boguée, ensuite les bibliothèques sont boguées (et effrayantes si vous regardez à l'intérieur). Certains vendeurs font du bon travail, d'autres ont tendance à ne pas trop en faire. Avec le temps, vous découvrirez vous-même quels sont les vendeurs que vous aimez, non que vous seriez en mesure de dicter professionnellement les uns sur les autres jusqu'à la fin, mais pour le plaisir comme un passe-temps peut certainement le faire. Jusqu'à présent, je ne parle pas de bras vs 8051 vs autres, ils ont tous cette fiche technique vs bibliothèque, docs buggy, etc. De toute façon, il est parfois nécessaire de creuser dans la bibliothèque ou divers exemples open source en ligne pour trouver le manquant Activez bit non documenté n'importe où, découvrez qu'il peut exister un ordre dans lequel certains registres doivent être programmés, que quelqu'un d'autre ait peut-être eu une connaissance approfondie ou juste une chance stupide.

So Ill suffit de poster un exemple assez minimal qui devrait fonctionner avec n'importe quelle version de arm-any-gcc/as/ld. (arm-linux-gnueabi bras-aucun-eabi, etc.). Et/ou vous pouvez simplement construire vos outils GNU à partir de sources comme je le fais périodiquement. Il est préférable de commencer avec certains problèmes prédéfinis mais préoccupés par un problème à la fois.

Le tableau que vous avez montré dans votre photo a également un nom de type de communauté particulier, c’est la "pilule bleue" ou "pilule bleue stm32". Et contrairement à certains autres conseils peu coûteux que vous pouvez trouver sur ebay ou un autre, celui-ci a fait l'objet d'un travail communautaire pour s'intégrer dans le bac à sable ardunio, un autre moyen de poursuivre vos connaissances et votre expérience, en empruntant ce chemin arduino dont vous n'avez pas besoin de lire beaucoup d'autres choses. que la pilule bleue google stm32, prenez quelques lignes très génériques de code et amenez-les à leur bac à sable et vous avez une led clignotante.

Vous allez avoir besoin d’Openocd avec le support stlink, alors trouvez un fichier binaire ou construisez à partir de sources, c’est assez facile. Ma préférence est de prendre les fichiers de configuration du répertoire tcl et de les transporter avec mon projet et de les modifier au besoin plutôt que d’espérer qu’ils soient là et qu’ils n’ont pas changé d’une version d’openocd à une autre ou d’une machine à une autre. YMMV, c’est une question de préférence personnelle. Par exemple, j'utilise un clone jlink el-cheapo, quelques dollars sur eBay (tableau violet). Et avoir un jlink.cfg

interface jlink transport select swd

Le tableau de votre image est l’un des types stlink que vous pouvez comprendre par essais et erreurs ou par lsusb ou d’autres moyens. Ce pourrait être ceci par exemple:

interface hla hla_layout stlink hla_device_desc "ST-LINK/V2" hla_vid_pid 0x0483 0x3748

Dans mon cas

openocd -f jlink.cfg -f target.cfg

où target.cfg est un fichier unique contenant les différents fichiers de configuration stm32f1xxx d'Openocd.

La pilule bleue a une led sur le PC13, la broche 13 du port C dans ce port.

Les exemples ici ne sont pas simplement du métal nu, ils incluent le code d'amorçage, vous n'avez pas besoin d'autres codes ou en-têtes, mais uniquement de ces fichiers et d'un compilateur GNU ou croisé, selon que vous l'exécutez sur une machine de développement autonome (ordinateur Raspberry Pi). , etc.) ou autre chose (basé sur x86, etc.). Le code est conçu pour la portabilité et d'autres éléments, pas tellement comme une approche de bibliothèque, un moyen de vous aider à démarrer de manière "je peux le faire", puis vous passez à vos préférences personnelles en examinant des solutions plus complexes.

sram.s

@.cpu cortex-m0 @.cpu cortex-m3 .thumb .thumb_func .global _start _start: ldr r0,=0x20001000 mov sp,r0 bl notmain b hang .thumb_func hang: b . .thumb_func .globl PUT32 PUT32: str r1,[r0] bx lr .thumb_func .globl GET32 GET32: ldr r0,[r0] bx lr .thumb_func .globl dummy dummy: bx lr

le stm32f103 ... est basé sur cortex-m3 et vous devez le savoir maintenant car vous disposez de la documentation STM32F103C8T6 fournie avec la fiche technique avec les pinouts et autres informations sur l’emballage et le numéro de pièce (vous indique combien de mémoire vive et vive vous avez entre autres) et le manuel de référence en termes simples (certains fournisseurs de la fiche technique possède également tous les registres et toutes les descriptions) qui contient tous les registres, l’espace adresse et ces détails. Entre ceux-ci, vous découvrez qu'il contient un cortex-m3 de bras. Vous accédez donc au site Web d'Armes pour obtenir le manuel de référence technique du cortex-m3 dans lequel vous trouvez qu'il est basé sur l'architecture armv7-m. Procurez-vous le manuel de référence sur l’architecture armv7-m, il s’agit de votre documentation de base pour cette puce, vous pouvez alors essayer de trouver un schéma ou un autre moyen de déterminer que PC13 est le lieu où se trouve le voyant ...

Ainsi, alors que armv7-m prend en charge la gamme beaucoup plus étendue d’extensions thumb2 du jeu d’instructions de pouce, je préfère généralement commencer par les instructions classiques pour commencer à partir d’un cadre générique, comme vous le verrez ci-dessous si nécessaire (pour des performances optimales). généralement) changez les outils de construction ou le code pour autoriser les extensions armv7-m thumb2, YMMV ...blinker01.c.

void PUT32 ( unsigned int, unsigned int ); unsigned int GET32 ( unsigned int ); void dummy ( unsigned int ); #define GPIOCBASE 0x40011000 #define RCCBASE 0x40021000 int notmain ( void ) { unsigned int ra; unsigned int rx; ra=GET32(RCCBASE+0x18); ra|=1<<4; //enable port c PUT32(RCCBASE+0x18,ra); //config ra=GET32(GPIOCBASE+0x04); ra&=~(3<<20); //PC13 ra|=1<<20; //PC13 ra&=~(3<<22); //PC13 ra|=0<<22; //PC13 PUT32(GPIOCBASE+0x04,ra); for(rx=0;;rx++) { PUT32(GPIOCBASE+0x10,1<<(13+0)); for(ra=0;ra<400000;ra++) dummy(ra); PUT32(GPIOCBASE+0x10,1<<(13+16)); for(ra=0;ra<400000;ra++) dummy(ra); } return(0); }

for(x=0;x<0x80000;x++) continue;

MEMORY { ram : Origin = 0x20000000, LENGTH = 0x1000 } SECTIONS { .text : { *(.text*) } > ram .rodata : { *(.rodata*) } > ram .bss : { *(.bss*) } > ram } .

arm-none-eabi-as --warn --fatal-warnings -mcpu=cortex-m0 sram.s -o sram.o arm-none-eabi-gcc -Wall -Werror -O2 -nostdlib -nostartfiles -ffreestanding -mcpu=cortex-m0 -march=armv6-m -mthumb -c blinker01.c -o blinker01.o arm-none-eabi-ld -o blinker01.elf -T sram.ld sram.o blinker01.o arm-none-eabi-objdump -D blinker01.elf > blinker01.list arm-none-eabi-objcopy blinker01.elf blinker01.bin -O binary

20000000 <_start>: 20000000: 4805 ldr r0, [pc, #20] ; (20000018 <dummy+0x4>) 20000002: 4685 mov sp, r0 20000004: f000 f80a bl 2000001c <notmain> 20000008: e7ff b.n 2000000a <hang> 2000000a <hang>: 2000000a: e7fe b.n 2000000a <hang> 2000000c <PUT32>:

openocd -f jlink.cfg -f target.cfg Open On-Chip Debugger 0.10.0-dev-00325-g12e4a2a (2016-07-05-23:15) Licensed under GNU GPL v2 For bug reports, read http://openocd.org/doc/doxygen/bugs.html swd adapter speed: 1000 kHz adapter_nsrst_delay: 100 none separate cortex_m reset_config sysresetreq Info : No device selected, using first device. Info : J-Link ARM-OB STM32 compiled Jun 30 2009 11:14:15 Info : Hardware version: 7.00 Info : VTarget = 3.300 V Info : clock speed 1000 kHz Info : SWD DPIDR 0x1ba01477 Info : stm32f1x.cpu: hardware has 6 breakpoints, 4 watchpoints

telnet localhost 4444 Trying 127.0.0.1... Connected to localhost. Escape character is '^]'. Open On-Chip Debugger > .

ensuite

> halt stm32f1x.cpu: target state: halted target halted due to debug-request, current mode: Thread xPSR: 0x01000000 pc: 0x08000042 msp: 0x20001000 >

Si vous vous arrêtez à nouveau après l’arrêt, vous n’obtenez pas ce résultat. J'ai en flash une boucle infinie (prenez l'exemple ci-dessous et commentez le bl notmain) pour me démontrer que cet exemple sram fonctionnera pour vous, rien d'autre sur Flash que le pointeur de pile n'est requis pour que l'exemple sram fonctionne.

> load_image sram/blinker01.elf 144 bytes written at address 0x20000000 downloaded 144 bytes in 0.008081s (17.402 KiB/s) > resume 0x20000000 > .

Et la led devrait commencer à clignoter lentement. On pourrait argumenter qu'il faut reprendre 0x20000001, mais l'outil se trouve qu'il fonctionne avec 0x20000000.

@.cpu cortex-m0 @.cpu cortex-m3 .thumb .thumb_func .global _start _start: stacktop: .Word 0x20001000 .Word reset .Word hang .Word hang .Word hang .Word hang .Word hang .Word hang .Word hang .Word hang .Word hang .Word hang .Word hang .Word hang .Word hang .Word hang .thumb_func reset: bl notmain b hang .thumb_func hang: b . .thumb_func .globl PUT32 PUT32: str r1,[r0] bx lr .thumb_func .globl GET32 GET32: ldr r0,[r0] bx lr .thumb_func .globl dummy dummy: bx lr

la façon dont un processeur démarre est très spécifique à ce processeur, il suffit de lire la documentation, dans ce cas, il s’agit d’un tableau vectoriel et non simplement d’une adresse que vous venez de commencer à exécuter. Les détails de cet ARE dans les documents arm, recherchez des mots tels que reset, exception, et vector et interrupt et vous trouverez le tableau. Notez que ces cortex-mcus peuvent avoir jusqu’à 128 ou 256 vecteurs possibles, cela dépend du cœur et du fournisseur de la puce, vous n'avez PAS à spécifier plus que ce que vous utilisez, vous pouvez vous échapper avec quelque chose à utiliser le pointeur de pile Word ( éventuellement le pointeur de pile que vous voulez) et que vous devez avoir le vecteur de réinitialisation; au-delà, cela ne dépend que de vous, vous ne fournissez pas de chemin d'accès non défini ni d'erreur, . En même temps, en configurant des vecteurs d’interruption (gravure d’un espace flash précieux), vous ne pourrez jamais activer votre appel, votre débogage.

MEMORY { rom : Origin = 0x08000000, LENGTH = 0x1000 ram : Origin = 0x20000000, LENGTH = 0x1000 } SECTIONS { .text : { *(.text*) } > rom .rodata : { *(.rodata*) } > rom .bss : { *(.bss*) } > ram } .

(Je recycle mes exemples génériques/point de départ afin que la quantité de mémoire flash/RAM ne reflète probablement pas cette partie réelle, ajustez si nécessaire).

for(rx=0;;rx++) { PUT32(GPIOCBASE+0x10,1<<(13+0)); for(ra=0;ra<200000;ra++) dummy(ra); PUT32(GPIOCBASE+0x10,1<<(13+16)); for(ra=0;ra<200000;ra++) dummy(ra); } .

construire.

arm-none-eabi-as --warn --fatal-warnings -mcpu=cortex-m0 flash.s -o flash.o arm-none-eabi-gcc -Wall -Werror -O2 -nostdlib -nostartfiles -ffreestanding -mcpu=cortex-m0 -march=armv6-m -mthumb -c blinker01.c -o blinker01.o arm-none-eabi-ld -o blinker01.elf -T flash.ld flash.o blinker01.o arm-none-eabi-objdump -D blinker01.elf > blinker01.list arm-none-eabi-objcopy blinker01.elf blinker01.bin -O binary

et beaucoup besoin d'inspecter le point d'entrée

Disassembly of section .text: 08000000 <_start>: 8000000: 20001000 andcs r1, r0, r0 8000004: 08000041 stmdaeq r0, {r0, r6} 8000008: 08000047 stmdaeq r0, {r0, r1, r2, r6} 800000c: 08000047 stmdaeq r0, {r0, r1, r2, r6} 8000010: 08000047 stmdaeq r0, {r0, r1, r2, r6} 8000014: 08000047 stmdaeq r0, {r0, r1, r2, r6} 8000018: 08000047 stmdaeq r0, {r0, r1, r2, r6} 800001c: 08000047 stmdaeq r0, {r0, r1, r2, r6} 8000020: 08000047 stmdaeq r0, {r0, r1, r2, r6} 8000024: 08000047 stmdaeq r0, {r0, r1, r2, r6} 8000028: 08000047 stmdaeq r0, {r0, r1, r2, r6} 800002c: 08000047 stmdaeq r0, {r0, r1, r2, r6} 8000030: 08000047 stmdaeq r0, {r0, r1, r2, r6} 8000034: 08000047 stmdaeq r0, {r0, r1, r2, r6} 8000038: 08000047 stmdaeq r0, {r0, r1, r2, r6} 800003c: 08000047 stmdaeq r0, {r0, r1, r2, r6} 08000040 <reset>: 8000040: f000 f808 bl 8000054 <notmain> 8000044: e7ff b.n 8000046 <hang> 08000046 <hang>: 8000046: e7fe b.n 8000046 <hang>

La valeur initiale du pointeur de pile (le désassemblage de la table des vecteurs est fausse, le désassembleur essayant de donner un sens à ces mots, les valeurs sont ce dont nous nous soucions d'ignorer le désassemblage), puis les vecteurs, le vecteur de réinitialisation est l'adresse du réinitialiser le gestionnaire ORRED avec un 0x08000040 | 1 = 0x08000041, ne vous attendez pas à un démarrage sinon, il essaiera d'entrer dans un gestionnaire d'erreur et y échouera probablement. Vous ne devez PAS BESOIN de désigner celui qui vous correspond dans ce code. Si vous utilisez un chargeur de démarrage en sautant vers une autre adresse, vous devez être sûr que vous en avez besoin. Je déconseille fortement d’en ajouter un, si l’outil s’arrangeait bien et que vous en ajoutiez un, vous fouilliez l’adresse et cela ne fonctionnerait pas si l’outil s’arrangeait bien et si vous en mettiez un, vous ne le feriez pas gâcher.

> halt stm32f1x.cpu: target state: halted target halted due to debug-request, current mode: Thread xPSR: 0x01000000 pc: 0x20000014 msp: 0x20000ff0 > flash write_image erase blinker01.elf auto erase enabled device id = 0x20036410 flash size = 64kbytes wrote 1024 bytes from file blinker01.elf in 0.437904s (2.284 KiB/s) > .

Si vous obtenez plutôt.

stm32x device protected failed erasing sectors 0 to 0

Votre partie est protégée en écriture et vous devez comprendre cela. Si je le trouve, je le posterai ici, mais je ne peux pas le tester parce que la partie que j’ai sous la main n’est pas protégée. Et je ne veux pas vraiment acheter une poignée de pièces supplémentaires dans l’espoir qu’elles soient protégées simplement pour montrer ce que vous pouvez trouver en achetant ces pilules bleues auprès de quelqu'un. En même temps, je ne vois pas beaucoup d’exemples de ce conseil s’occuper de cela, alors c’était peut-être juste un lot et/ou un fabricant qui l’avait fait et moi-même et un autre gars en ligne avions malchanceux.À ce stade, vous pouvez

> reset

Ou.

Appuyez sur le bouton de réinitialisation avec les cavaliers déplacés vers le côté 0. Ce qui indique que boot0 et boot1 sont attachés à 0 (en réalité, il suffit que boot0 soit un 0). Dans votre image, vos cavaliers sont réglés sur 1, vous devez déplacer au moins celui qui ne se trouve pas à côté du bouton de réinitialisation, celui qui se trouve à côté du bouton de réinitialisation est supposé être boot1.

Et la led devrait clignoter deux fois plus vite que l'exemple sram. Et lorsque vous mettez la carte hors tension, puis de nouveau sous tension, avec boot0 = 0, il lance le programme à partir de Flash.

Pure Assembly aurait été encore plus simple d'un exemple, l'astuce du pointeur volatile étant légèrement plus simple. Mais si vous ne pouvez pas faire fonctionner ce code, vous n'allez probablement pas obtenir quelque chose de plus compliqué. C'est presque aussi simple que cela devient.

Notez encore une fois que ces exemples ne prennent pas en charge .data et ne supposent pas que .bss vaut zéro; il faudra un peu plus de code et de connaissances pour permettre ces hypothèses. Personnellement, je ne m'appuie pas sur celles-ci et je n'ai pas à compliquer le bootstrap ni le script de l'éditeur de liens. (qui sont spécifiques à une chaîne d’outils et qui ne sont pas portés), mais c’est une préférence personnelle.

Google stm32 blue pill et trouvez les pages sur STM32duino ou quelque chose du genre, essayez ces exemples. Il y a probablement un support pour un autre bac à sable, celui-ci étant soutenu ou supporté par ARM, ainsi que st a au moins deux types de bibliothèques cmsis et un hérité. Notez que les vendeurs de puces en activité ont souvent un ensemble de bibliothèques et que, pour des raisons de marketing ou autres, continuent à les utiliser, alors que la couche HAL, le CMSIS, etc., s’attendent à ce qu’ils soient même sur CMSIS, en partie parce que c’est un peu le bordel, pas de vrai propriétaire central. Le CMSIS accordé peut évoluer, mais ne vous attendez pas à ce qu'il reste sous sa forme exacte. Dans le même temps, dans l’industrie, vous achetez idéalement une pièce relativement nouvelle pour votre produit et/ou qui sera en production aussi longtemps que votre produit espère être en production, vous écrivez/déboguez/construisez le firmware et Si tout va bien, ne jamais avoir à le toucher, vous pouvez donc utiliser ce que la bibliothèque populaire/FAD du jour est, idéalement enregistrer une machine de construction d'aujourd'hui pour l'utiliser dans le futur, mais espérons que vous n'aurez jamais à le toucher et que la bibliothèque préférée d'aujourd'hui fonctionnera Assez longtemps pour vous rendre à la production. l’approche à faire soi-même est beaucoup plus facile à maintenir; pour des choses simples comme gpio, spi, uart, etc. sont plus faciles à l’OMI que pour la bibliothèque, des choses comme USB, Ethernet, etc. pourraient être plus difficiles non pas l’interface avec les périphériques, mais la bibliothèque du fournisseur. aura inclus une pile usb, une pile ethernet ip, un support de système de fichiers probablement fortement intégré dans le support de leur bibliothèque périphérique et ne méritant pas forcément d'être séparé pour éviter le code de leur bibliothèque périphérique.

À la fin de la journée, professionnellement, vous devriez supposer que vous possédez tout le code que vous utilisez, y compris les bibliothèques. Votre patron ne constatera que la gamme de produits a échoué, sans vous soucier du fait que ce soit une bibliothèque tierce que vous avez choisie et qui était en cause.

Note again these examples do not support .data nor assume .bss is zero, it will take a bit more code and knowledge for you to allow for those assumptions, personally I dont rely on those and dont have to complicate the bootstrap nor the linker script (which are toolchain specific and wont port), but that is personal preference.

google stm32 blue pill and find the pages on STM32duino or something like that, try those examples. There is probably mbed support another sandbox, this one backed buy or supported by ARM, as well as st has at least two flavors of libraries cmsis and a legacy one. Note that chip vendors to be in business often have a library set, and for marketing and other reasons, continue to churn on those, so while the HAL and CMSIS and cube and whatever are present today, expect one and eventually all of those to be gone down the road, even CMSIS, in part because it is a bit of a mess, no real central owner. Granted CMSIS may evolve, but dont expect it to remain in its exact form. At the same time the way this industry works is you ideally buy a part for your product that is relatively new and/or will be in production about as long as your product hopes to be in production, you write/debug/build the firmware and hopefully never have to touch it, so you can use whatever the popular/FAD library of the day is, ideally save a build machine from today to use in the future, but hope that you never have to touch it and todays favorite library will work long enough to get you to production. the do it yourself approach is far easier to maintain, for simple things like gpio, spi, uart, etc are IMO easier than the library, things like USB, ethernet, etc might be harder not the interface with the peripherals, but the vendor library will have included a usb stack, an ethernet ip stack, filesystem support which are likely heavily integrated into their peripheral library support and not necessarily worth separating to avoid their peripheral library code.

At the end of the day, professionally, you should assume you own all the code you use, including the libraries. Your boss will only see that the product line failed, and not care that it was a third party library that you chose that was at fault.

Anjan Rao · Answer

Si vous avez déjà acheté le kit de développement, je commencerai par lire le manuel de l’utilisateur. Ils y auraient expliqué comment utiliser un exemple d’application. Suivez les étapes, commencez avec l'application de base. Comprendre le code Sur la base du code, lisez la fiche technique pour comprendre le fonctionnement de IO et des autres internes. Vous ne comprendrez peut-être pas tout au début, puisque vous connaissez bien le 8051, vous obtiendrez un résumé de la façon dont les choses fonctionnent. La prochaine étape consisterait à lire des tutoriels/livres sur Nice Arm, au fur et à mesure que vous lisiez ceux-ci, essayez de les exécuter ou de les pratiquer sur votre carte de développement. Il n'y a rien de mieux à apprendre et à les mettre en pratique. Bonne chance.