Les outils pour la programmation de microcontrôleurs

Bonjour à toutes et à tous.

Certain(e)s d’entre vous ont sûrement connu ce site par l’intermédiaire de mon tutoriel sur la configuration de Code::Blocks pour programmer des PIC. Mais comme il s’agit d’un article très spécifique, avec un matériel et des logiciels adaptés, le but du présent article sera donc d’introduire des bases plus générales de la programmation de systèmes embarqués, à commencer par la présentation des outils nécessaires à la programmation de microcontrôleurs.

Le microcontrôleur

À la base, nous avons un microcontrôleur, qui est un composant électronique jouant le rôle d’un ordinateur à une échelle très réduite. Pour chaque microcontrôleur, son fabricant propose généralement un kit de développement permettant de relier ce microcontrôleur à l’ordinateur servant à le programmer.

En effet, contrairement au développement informatique en général, le développement ne se fait pas directement sur le microcontrôleur, ses ressources étant trop limitées pour y implémenter à la fois le programme et tous les outils logiciels pour le développer, comme le compilateur ou l’éditeur de code. Nous devons donc déporter ce développement sur une plate-forme possédant les ressources nécessaires pour accomplir cette tâche. On parle alors de compilation croisée, puisqu’on écrit et compile du code pour une autre plate-forme que celle sur laquelle on développe.

Pour ce qui est du choix du microcontrôleur, il se fait en fonction des besoins du projet à réaliser. Le budget peut également être un facteur déterminant.

Les fabricants ne manquent pas et il existe des microcontrôleurs pour toutes sortes d’usage. Microchip propose des microcontrôleurs assez généralistes, les fameux microcontrôleurs PIC. Ils sont peu chers mais assez chaotiques dans leur fonctionnement. On les utilise généralement pour l’apprentissage de la programmation de microcontrôleurs ou des questions de budget.

Ensuite, on trouve Atmel et ses microcontrôleurs 8 bits AVR. Ils sont généralement de meilleure qualité que les PIC pour un coût à peu près équivalent. Ils sont d’ailleurs à la base des fameuses cartes Arduino, utilisées essentiellement pour l’apprentissage de l’embarqué et pour le développement de nombreux projets amateurs. À noter qu’il existe une version PIC d’Arduino, moins connue, nommée Pinguino.

Il existe une autre architecture de microcontrôleurs, très courante mais non spécifique à un seul fabricant, qui est le 8051. Initialement créé par Intel en 1980, cette architecture a été beaucoup reprise par de nombreux constructeurs et est encore très utilisée aujourd’hui.

On peut également trouver d’autres architectures de microcontrôleurs comme les MSP430 de Texas instruments, les PSoC de Cypress, les 6800 et 68000 de Freescale (anciennement Motorola et appartenant désormais à NXP), les STM8 de STMicroelectronics ou les Z80 de Zilog (que l’on trouvait notamment, sous forme dérivée, dans la fameuse console portable GameBoy).

Enfin, il existe l’architecture ARM. À l’instar de 8051, cette architecture est intégrée par la plupart des fabricants de circuits intégrés et est présente dans bons nombre de produits technologiques du grand public (dans les smartphones et les tablettes, entre beaucoup d’autres). À ce jour, c’est certainement l’architecture la plus utilisée dans les systèmes embarqués, mais sa prise en main n’est pas adaptée à des débutants dans le domaine de l’embarqué.

Read The F***ing Manual

Le développement embarqué c’est également pas mal de temps à se documenter, au moins pour comprendre le fonctionnement du matériel que l’on utilise. C’est pour cela que je vous encourage à lire la documentation du matériel et des outils que vous utiliserez. Pour cela, l’anglais est indispensable puisque la grande majorité des documents sont en anglais.

Cela dit, n’hésitez pas non plus à demander de l’aide sur des forums comme Developpez.net. ;-)

Le langage de programmation

Hormis avec quelques rares exceptions comme les compilateurs mikroBasic ou mikroPascal de MikroElektronika, si vous voulez vous lancer à corps perdu dans le domaine de l’embarqué tout en espérant y trouver suffisamment d’informations pour progresser facilement, il vous faudra passer par l’apprentissage du C, si vous ne maîtrisez pas déjà ce langage.

Pour acquérir les bases du langage C rapidement, je ne peux que vous conseiller de trouver des cours sur internet comme Le C en 20 heures. Vous pouvez également chercher du côté d’OpenClassrooms ou de Developpez.com.

Même si ce n’est pas obligatoire, il est également préférable d’acquérir au moins quelques bases en assembleur.

L’éditeur de code

Les outils pour l’écriture de code restent généralement les mêmes que pour du développement logiciel général, allant du simple bloc-notes à l’environnement de développement intégré. Mais, lors de l’écriture, on tiendra compte des limites de la cible de programmation. En bref, la programmation embarquée exige beaucoup plus de rigueur concernant la gestion des ressources, de la taille mémoire, de la pile, du tas, des exceptions, etc. Mais cela fera l’objet d’autres tutoriels.

Pour en revenir aux éditeurs, on pourra utiliser des outils conventionnels disposant d’extensions spécialisées pour le développement de la cible choisie, voire proposant des outils supplémentaires pour mieux répondre aux contraintes des microcontrôleurs. Je pense notamment à Code::Blocks ou Eclipse.

Mais, de manière générale, chaque fabricant de microcontrôleurs proposera un outil spécifique à son matériel, voire un outil fait maison. C’est le cas par exemple de Microchip avec MPLAB, Atmel avec Atmel Studio, ARM avec MDK-ARM, etc. Pour chaque matériel, on trouvera au moins un outil de développement qui sera soit directement développé par le constructeur, soit développé par des sociétés externes. Ce dernier cas est valable, par exemple, pour la société IAR Systems qui propose des outils de développement ciblant plusieurs architectures d’autres constructeurs – techniquement c’est le même outil mais avec une version spécifique pour chaque architecture.

Il s’agit généralement d’outils propriétaires et/ou payants. Les amateurs de logiciels gratuits et/ou libres seront facilement rebutés et préféreront s’orienter vers d’autres alternatives, dont le monde du logiciel libre ne manque pas. Par exemple, pour les PIC, il existe l’outil Piklab dédié à cette famille de microcontrôleurs ou encore MCU 8051 IDE dédié aux microcontrôleurs à base de 8051.

Le compilateur

Une fois le programme écrit, il nous faut le compiler. Le fabricant du microcontrôleur utilisé proposera un compilateur spécifique à son matériel, allant généralement de pair avec l’outil de développement. C’est le cas, par exemple, pour le compilateur XC qui accompagne l’outil MPLAB X, le compilateur Keil pour MDK-ARM ou le compilateur IAR pour l’outil du même nom.

Côté logiciel libre, on trouvera un bon nombre de compilateurs, généralement dérivés du compilateur GCC. On peut par exemple citer AVR-GCC pour les microcontrôleurs AVR, GNU ARM pour les architectures ARM ou MSP430 GCC pour les microcontrôleurs MSP430 de Texas Instruments.

Il existe aussi le compilateur SDCC, dont j’ai déjà parlé dans un précédent tutoriel, qui a la particularité de cibler plusieurs plate-formes. Parmi ces cibles supportées, on peut compter plusieurs microcontrôleurs 8051, le Z80 de Zilog, des HC08 de Freescale ou encore les fameux PIC de Microchip (extension non libre). Je vous invite à vous référer au site du compilateur pour connaître les architectures supportées.

Le programmateur et le débogueur

Une fois le programme compilé, il faut pouvoir l’inscrire dans la mémoire du microcontrôleur ciblé. Pour cela, il faut un outil matériel communément appelé un programmateur.

Là encore, on trouvera différents programmateurs pour chaque cible, les premiers étant fournis par les fabricants du microcontrôleur, les autres étant souvent le fait de passionnés d’électronique proposant une alternative moins chère aux programmateurs commerciaux, qui peuvent souvent se révéler assez chers.

Pour les PIC, la référence est le PICKit, actuellement dans sa version 3. Pour les microcontrôleurs AVR, ce sera plutôt le AVRISP mkII.

Ces programmateurs sont proposés par le constructeur, mais il existe des alternatives intéressantes, comme le usbpicprog pour les cibles PIC. Il est libre, compact (54 x 28 x 14 mm) et il est assez simple à utiliser. Normalement vous pouvez le construire vous-même mais il est possible d’en commander sur le site pour pas cher (20€  pièce, plus les frais de port qui sont raisonnables).

Côté AVR on se tournera plutôt du côté de l’USBtinyISP, créé par Adafruit (auquel je vous recommande chaudement de vous intéresser, leur travaux sont tout à fait remarquables). Initialement vendu en kit, il est possible de le commander déjà monté, et son coût est à peu près équivalent au usbpicprog.

Attention ! Il est important de faire la distinction entre un programmateur et un débogueur. On retiendra que le programmateur permet de manipuler les données de la mémoire du microcontrôleur, tandis que le débogueur permet d’exécuter le programme et de superviser son fonctionnement en temps réel depuis un ordinateur. Si les deux peuvent être intégrés dans le même outil, ce n’est pas toujours le cas, donc faites attention à vérifier si l’outil que vous choisissez correspond à vos besoins.

Le simulateur

Il peut arriver que l’on ne dispose pas du matériel requis pour travailler directement sur la cible de programmation, ou que l’on préfère simuler le fonctionnement du programme pour éviter d’endommager le microcontrôleur. Dans ces cas-là, on peut utiliser un programme qui va simuler l’exécution du programme que l’on souhaite tester.

Microchip et Atmel ont intégré un simulateur dans leur outil de développement. Les alternatives libres ne manquent pas non plus et on pourra trouver GPSim pour PIC et Simulavr pour AVR. Le compilateur SDCC comprend également un simulateur, nommé µCsim, qui gère essentiellement les cibles 8051.

Retenez cependant qu’un programme qui fonctionne sans problème avec un simulateur n’implique pas forcément que le programme fonctionnera aussi bien sur un microcontrôleur.

Conclusion

J’espère avoir apporté assez d’éléments pour vous permettre d’appréhender les bases du développement sur microcontrôleurs. Bien entendu tout cela est valable surtout si vous souhaitez partir du plus bas niveau, en sélectionnant vous-même le microcontrôleur et les outils associés.

Mais, si tout cela vous rebute, vous pouvez aussi bien vous orienter vers une solution comme Arduino, parfaitement adaptée aux débutants en embarqué. D’autant qu’une communauté très forte s’est bâtie autour de ce système et vous n’aurez donc aucun mal à trouver de l’aide pour progresser.

Cependant, le côté simpliste de la plate-forme risque de vous imposer de passer à quelque chose de plus ardu à un moment donné. Auquel cas, ou si vous souhaitez essayer d’autres architectures par pure curiosité, je vous invite à choisir parmi les cibles évoqués dans cet article. Si vous voulez rester sur du matériel AVR, sachez qu’il est également possible de programmer directement le microcontrôleur de la carte Arduino via les broches ISP prévues à cet effet. Il vous faudra cependant utiliser un programmateur comme un de ceux évoqués plus haut.

N’hésitez pas à poser des questions en commentaires si certains points ne sont pas clairs ou si vous souhaitez obtenir davantage d’informations.

Sur ce, je vous laisse et vous dis à bientôt.

Nicolas SAN AGUSTIN

Dissection de lapin

Bonjour à toutes et à tous !

Certain(e)s d’entre vous connaissent peut-être le lapin connecté Karotz, ou son prédécesseur Nabaztag. Pour faire simple, il s’agi(ssai)t d’un lapin robot, destiné au grand public, bardé de composants pour la communication sans fil et le multimédia afin d’en faire avant tout un objet de loisirs avec lequel on pourrait interagir de diverses façons. Parmi les fonctionnalités notables, je pourrais citer la commande vocale, la synthèse vocale, le WiFi, la RFID, une webcam, et j’en passe.

La première version, Nabaztag fonctionnait essentiellement en accès distant. Toutes les applications étaient stockées sur des serveurs (que l’utilisateur, avec un compte, pouvait sélectionner). L’arrêt des serveurs Nabaztag a signé l’arrêt de mort de ces lapins connectés.

Plus tard, le lapin connecté est revenu sous un nouveau nom : Karotz. Version plus moderne, avec des applications installées directement dans le lapin. On aurait pu penser qu’on était ainsi débarrassé des contraintes de l’accès distant. Il n’en fut rien. En effet, le lapin nécessitait toujours d’être connecté aux serveurs pour fonctionner, au moins pour garantir le fonctionnement des commandes et synthèse vocales – traitement fastidieux pour une si petite cible, on retrouve d’ailleurs le même fonctionnement pour la reconnaissance vocale des smartphones.

Comme pour son prédécesseur, l’arrêt des serveurs (annoncé il y a quelques mois et survenu il y a une semaine) a mis fin au règne de Karotz. Et malgré une éventualité, prometteuse mais à l’avenir incertain, de résurrection dans le milieu Open Source (ex: OpenKarotz), j’ai choisi de démonter mon Karotz pour en récupérer les composants.

C’est donc ce que j’ai fait dimanche dernier, et j’ai décidé de consacrer mon article du mois de Février à ce démontage qui s’est avéré aussi intéressant que je l’espérais.

Extérieur du lapin

Boîte extérieure  Boîtes intérieure et extérieure  Contenu de la boîte

D’abord, voici la boîte du lapin et son contenu : le lapin, ses oreilles, un cordon d’alimentation avec différents adaptateurs, et le manuel d’utilisation.

Cordon d'alimentation et adaptateurs  Dessous du Karotz  Dessous du Karotz, sans batterie  Connecteur batterie

Petit coup d’œil sur la partie alimentation. Le cordon est livré avec différents adaptateurs, pour assurer son branchement sur tous types de prises (pour ceux qui l’ignorent encore, les prises électriques peuvent être différentes selon les pays). Ce cordon se branche sous le Karotz. En dessous de l’orifice, une fois le cache enlevé on trouve un petit bloc amovible en plastique. Ce n’est pas une batterie, vu que le Karotz ne fonctionne pas lorsque le câble n’est pas branché, et c’est étonnamment léger. M’est avis qu’il s’agit d’un simple adaptateur du cordon d’alimentation vers le connecteur multi-broches situé au fond du compartiment d’alimentation. Ce compartiment sert en fait à accueillir une batterie – optionnelle et avec une autonomie de 2 heures…

karotz sans oreilles, de face  Karotz sans oreilles, de dos  Karotz entier de face

Et enfin, le lapin en lui-même. Les oreilles sont amovibles et mobiles. Pour les bouger, le Karotz est équipé de deux moteurs dont la sortie de chacun donne sur un aimant auquel on peut fixer très simplement une oreille. L’intérêt était de pouvoir personnaliser le Karotz en lui changeant ses oreilles blanches par d’autres d’une autre couleur.

À l’arrière on peut apercevoir le haut parleur, avec en dessous le bouton d’allumage et enfin un port USB pour brancher une clé (pour l’usage de certaines fonctions comme la configuration du WiFi ou la lecture de fichiers audio). À noter que le Karotz bénéficie aussi d’un port mini-USB pour le brancher à un ordinateur via un câble mini-USB<=>USB

À l’avant, au niveau du nez, est caché un lecteur RFID pour le déclenchement programmé de certaines applications à l’aide de tags en forme de petits Karotz, et tout en bas la webcam, d’une qualité médiocre (une webcam bon marché d’il y a 7 ou 8 ans n’a rien à lui envier).

Pour procéder à l’ouverture, il m’a fallu m’équiper d’un tournevis à tête triangulaire (TA 20). Il suffit de retirer toutes les vis extérieures. La coque est alors prête à être retirée. Il faut insister, en essayant divers angles pour faire en sorte que la coque du dessus se retire facilement.

À l’intérieur de la bête

Une fois ouvert, le Karotz dévoile les parties les plus intéressantes de son anatomie (pas celles-là, pervers(es) !). Pour dévisser le reste, on peut repasser sur un bon vieux tournevis cruciforme (pas nécessairement de précision mais de préférence adapté à l’électronique).

Karotz ouvert  Karotz intérieur, de face

Module RFID  Module RFID, déconnecté  LED RVB avec amplificateur  Caméra

De face, nous avons, en haut, le module RFID, dont le composant central est un RC523 signé NXP (une référence en la matière !). Juste en dessous, la LED RVB, c’est-à-dire une LED dont on peut faire varier la couleur en changeant ses valeurs de rouge, vert et bleu (on parle de synthèse dite additive). La LED est surmontée d’un amplificateur en forme de cône pour qu’en usage normal le lapin affiche un grand cercle lumineux et coloré sur son ventre. Et enfin, tout en bas, la fameuse webcam.

Module WiFi  2015-02-22 16.45.45

Sur le côté gauche se trouve la carte WiFi du Karotz, basée sur un RT2571WF de Ralink. Une rapide recherche sur Google ne m’indique pas de documentation particulière. En revanche, les photos de cet article me laissent penser que le module WiFi de Karotz n’est en fait que l’équivalent du dongle WiFi qui y est présenté. Il ne manque que le connecteur USB, qu’on peut facilement se procurer et souder à l’emplacement prévu à cet effet pour reconvertir ce module en un dongle WiFi.

Karotz intérieur, de dos  Haut parleur  2015-02-22 17.18.01  2015-02-22 17.18.09

Le haut parleur d’une taille ma foi satisfaisante. Pour avoir utilisé le Karotz pour écouter de la musique, je dois dire que la qualité du son était convenable. Ça casse pas des briques, c’est un haut parleur comme on peut en trouver dans tout bon magasin d’électronique.

Bouton supérieur  2015-02-22 17.21.40  Micro  2015-02-22 17.22.59

Enfin, en haut nous trouvons le bouton poussoir, utilisé surtout pour l’activation de la commande vocale. À l’arrière de la tête se trouve d’ailleurs le microphone prévu à cet effet.

2015-02-22 12.20.32  2015-02-22 17.01.01

La molette pour allumer le Karotz et régler le volume sonore. J’ai enlevé la partie plastique pour garder le composant essentiel : un potentiomètre avec position arrêt.

2015-02-22 17.10.16  2015-02-22 17.02.45

Les deux connecteurs femelles, mini-USB type A et USB type A. Intéressant pour moi. Je pourrai en mettre un sur une carte de développement personnelle (à base de PIC18F2550, en l’occurrence), vu que je n’en dispose pas pour l’instant.

2015-02-22 17.19.53  2015-02-22 17.24.35

La partie motrice, pour l’animation des oreilles du lapin. Il s’agit de deux moteurs à courant continu, terminés par des petits réducteurs pour augmenter leur couple (le terme « réducteur » s’applique à la vitesse de rotation : celle-ci diminue tandis que le couple, c’est-à-dire l’effort fourni en rotation, augmente). On peut aisément désolidariser le moteur de son réducteur, et c’est ce que je compte faire pour tester ces réducteurs avec les mini-moteurs que j’ai en stock pour voir si je parviens à obtenir un couple suffisant pour que leur usage soit intéressant. C’est surtout à titre expérimental, en attendant de pouvoir fabriquer des réducteurs à partir d’engrenages et d’axes.

Carte Contrôleur (Architecture ARM)

Et enfin, le cœur du Karotz, la carte principale pilotée par un cœur ARM S3C2440 de Samsung. La doc fait presque 600 pages (595 pour être exact) et j’espère ne pas avoir à la lire en intégralité. Le bon côté c’est qu’elle semble bien construite parce qu’une doc qui, en plus d’être longue, serait indigeste me dissuaderait définitivement de me pencher dessus (j’ai déjà donné, et ce fut une belle perte de temps).

Heureusement, ce micro semble avoir été déjà bien étudié, notamment ici ou . La question est de savoir s’il est possible de convertir cette carte, initialement développée pour le Karotz, en kit de développement basique (mais qui pour le coup pourrait s’interfacer avec les composants du Karotz). Ce serait pour moi une bonne initiation au développement sur cible ARM. Bon, j’exagère, j’ai aussi sous la main un Raspberry Pi, ainsi qu’un vieux netbook qu’on m’a refilé (basé sur un WonderMedia 8650, et qui aurait bien besoin d’un OS digne de ce nom). Je ne me suis pas encore penché davantage sur les autres composants de cette carte, je le ferai sûrement au moment de l’étudier pour l’utiliser.

Conclusion

C’est ainsi que s’achève ce compte rendu du démontage du Karotz. J’ai passé de bons moments avec ce lapin, qui n’a malheureusement pas eu le succès escompté. Il m’aura notamment permis de surveiller grossièrement mon petit studio avec une application de surveillance vidéo avec détection des mouvements, qui ne fonctionnait pas parfaitement bien mais ça me rassurait un peu de savoir que je pouvais garder un œil chez moi. Le catalogue de Karotz proposait des applications sympathiques et d’autres qui étaient carrément inutiles, le plus souvent parce qu’elles ne fonctionnaient tout simplement pas. Vers la fin, je n’en avais plus vraiment l’utilité. Il a d’ailleurs passé plusieurs mois bien rangé dans son emballage.

À mon humble avis, le système n’était pas bien conçu, ou en tout cas pas pour le bon public. Je pense que les gens qui ne s’y connaissent pas en programmation achetaient un Karotz pour ses usages et non pour le programmer, tandis que les vrais bricoleurs comme moi étaient frustrés par les limitations du système.

Je pense que rien que le choix du Javascript était une erreur. C’est un langage à l’origine prévu pour le web, pas pour le développement d’applications et encore moins pour la programmation système. Et c’est ce qui, pour moi, a conduit le Karotz à n’avoir droit qu’à des applications mal conçues, qui ne fonctionnent pas ou qui n’ont aucune utilité.

Plutôt qu’un langage aussi simpliste que le JavaScript, il aurait plutôt fallu développer un outil RAD ou un langage proche du Scratch pour la création d’applications tant par des débutants que par des entreprises. Cela aurait, je pense, grandement contribué à lui apporter un catalogue d’applications acceptables.

Je ne le cache pas : bien qu’attrayant, le Karotz fut pour moi une déception, et le recycler c’est ma façon de lui donner enfin l’usage qu’il aurait pu/du avoir.

Sur ce, je vous laisse, et je vous dis à bientôt.

Nicolas SAN AGUSTIN

Comment programmer un PIC avec SDCC et Code::Blocks

Bonjour à toutes et à tous !

En attendant de pouvoir récupérer mon matériel pour la suite du projet de programmateur de PIC – et parce que je ne tiens plus en place tellement je suis impatient – j’ai décidé d’ouvrir une rubrique Tutoriels pour expliquer certaines choses pour lesquelles il est difficile de trouver des informations sur internet. Je commence donc cette rubrique avec un tutoriel pour expliquer comment programmer sur des microcontrôleurs PIC – de Microchip – avec le compilateur SDCC et l’environnement de développement Code::Blocks.

Pour commencer, je vais vous présenter un petit peu ce qu’est SDCC. C’est un compilateur libre développé pour programmer en C sur différents microcontrôleurs – on parle alors de compilateur multi-cibles. Il gère différentes familles de microcontrôleurs dont une courte liste est disponible en page d’accueil du site : SDCC – Small Device C Compiler.

Concernant la programmation sur cible PIC, celle-ci n’est pas totalement intégrée bien qu’il soit tout à fait possible de programmer des PIC avec. Il faut cependant, en plus du compilateur SDCC, utiliser une autre chaine de compilation – en assembleur cette fois – qui se nomme GPUTILS, pour GNU PIC Utilities. Rassurez-vous, vous ne serez pas obligés d’apprendre l’assembleur pour programmer sur des PIC. SDCC utilise simplement GPUTILS comme outil pour transformer son code compilé en un fichier HEX exécutable par le PIC.

Notez que SDCC, en complément de GPUTILS, est très certainement l’un des meilleurs compilateurs pour microcontrôleurs qui existent dans le domaine du logiciel libre.

Passons désormais à la problématique, où je vous explique le pourquoi de ce tutoriel. Code::Blocks intègre bien la notion de systèmes embarqués, et comprend même SDCC dans sa liste de compilateurs. Néanmoins, parmi les templates de projet disponibles, il n’en existe pas pour le développement sur PIC. Il existe bien quelques tutoriels sur internet pour utiliser SDCC avec Code::Blocks mais ceux-ci sont soit obsolètes soit erronés – c’est bien connu que ce qui se trouve sur internet ne fonctionne jamais comme on le souhaite. ;)

J’ai passé un long moment à chercher comment paramétrer Code::Blocks pour créer un template personnalisé de projet PIC et il s’est finalement avéré que la solution était assez simple.

Pour commencer, si ce n’est déjà fait, téléchargez et installez Code::Blocks, GPUTILS et SDCC sur leurs sites respectifs. Le site de SDCC recommande de télécharger une version snapshot si la dernière version stable disponible date de plus de deux mois. À l’heure où j’écris ces lignes, la dernière version date de Juillet 2012, mais pensez à vérifier régulièrement la sortie d’une nouvelle mise à jour – sachez qu’il sort quasiment un snapshot par jour pour SDCC voire plus.

Configuration de SDCC

Une fois que tout est installé, ouvrez le programme Code::Blocks et dès que celui-ci est démarré, allez dans « Settings » > « Compiler… ». La fenêtre de configuration des compilateurs s’affiche. En haut, sélectionnez dans la liste « SDCC Compiler ». Sélectionnez ensuite l’onglet « Toolchain executables » et appuyez sur le bouton « Auto-detect » pour que Code::Blocks détecte automatiquement l’emplacement du compilateur SDCC.

configsdcc01

Il nous reste une dernière chose à configurer avant la création d’un projet. Il faut que l’extension pour les fichiers sources compilés soit « .o » et non « .rel ». Faites défiler les onglets avec les flèches à droite jusqu’à voir apparaître l’onglet « Other Settings ». Là, cliquez sur le bouton « Advanced options… ».

configsdcc02

Une autre fenêtre s’ouvre alors. Sélectionnez l’onglet « Others » et vérifiez que la valeur pour « Object file extension » est bien une lettre ‘o’. Si ce n’est pas le cas, modifiez la valeur qui s’y trouve – « rel » – par la lettre ‘o’. Cliquez sur « OK » pour quitter la fenêtre des options avancées et encore sur « OK » pour quitter la configuration du compilateur.

configsdcc03

Créer un projet PIC

Maintenant que SDCC est bien configuré, passons à la création d’un projet. Pour cela, cliquez sur le bouton de la barre des tâches en haut à gauche et sélectionnez « Project… » dans la liste qui apparait. Dans la fenêtre de sélection du type de projet, choisissez « Empty Project » et cliquez sur « Go ».

newprj01

Saisissez le nom de votre projet et son emplacement sur votre disque, puis faites « Next ».

newprj02

Sélectionnez le compilateur « SDCC Compiler » et vérifiez que la case « Create Release configuration » est bien cochée – personnellement je n’utilise plus « Debug » – puis cliquez sur « Finish ».

newprj03

Votre projet est maintenant créé, mais avant de programmer, il reste encore quelques petites choses à régler.

Configurer le projet

Première chose, nous allons configurer le compilateur pour ce projet. Faites un clic-droit sur le projet dans la partie « Management » à gauche, et sélectionnez « Build options » dans la liste. Une fenêtre s’ouvre, sélectionnez le nom du projet dans la partie gauche de cette fenêtre. Dans la partie droite, sélectionnez l’onglet « Compiler settings » puis l’onglet « Compiler Flags ». Dans la liste des options de compilation, toutes les cases doivent être décochées, à l’exception de :

Be verbose [--verbose],

Output Intel Hex (default) [--out-fmt-ihx],

[CPU] Microchip PIC 14-bit[-mpic14] si vous utilisez un PIC10, PIC12, un PIC14 ou un PIC16,

OU

[CPU] PIC 16-bit[-mpic16] si vous utilisez un PIC18.

configprjbuild01

Sélectionnez maintenant l’onglet « Other options » et écrivez-y --use-non-free pour indiquer au compilateur qu’il doit chercher les entêtes correspondant aux PIC dans ses dossiers d’entêtes non libres, et -pxxxxxxx pour le microcontrôleur que vous utilisez – pour moi qui utilise un PIC18F2550, je saisis -p18f2550.

configprjbuild02

Cliquez maintenant sur « OK » pour valider les changements. Si une fenêtre vous demande de confirmer que vous voulez appliquer les changements, acceptez.

Il reste une dernière étape. Faites à nouveau un clic droit sur le nom du projet et sélectionnez cette fois « Properties… ». Dans la nouvelle fenêtre, sélectionnez l’onglet « Build targets ». Dans la partie droite, pour l’attribut « Type », sélectionnez « Native ». Plus bas, pour « Output filename », remplacez le « .sys » par « .hex », puis décochez les cases « Auto-generate filename prefix » et « Auto-generate filename extension ». Enfin, cliquez sur « OK » pour quitter la fenêtre.

configprjproperties

Créer un fichier

Votre projet est désormais prêt pour la programmation. Ce dernier aspect sera abordé plus en détails dans un autre tutoriel. En attendant, voici un petit programme basique pour vous donner un aperçu d’un fichier source en C pour microcontrôleur.

</p>

<blockquote><span style="color: #008000;">#define __18F2550</span>
<span style="color: #008000;"> #include &lt;pic18f2550.h&gt;</span>

<span style="color: #008000;">#pragma stack 0x200 100</span>

<span style="color: #ff00ff;">void</span> main(<span style="color: #ff00ff;">void</span>)
{
<p style="padding-left: 30px;"><span style="color: #ff00ff;">unsigned</span> <span style="color: #ff00ff;">int</span> i;</p>
<p style="padding-left: 30px;">TRISB = <span style="color: #ff00ff;">0</span>;</p>
<p style="padding-left: 30px;"><span style="color: #ff00ff;">while</span>(<span style="color: #ff00ff;">1</span>)
{</p>
<p style="padding-left: 60px;">PORTBbits.RB7 = <span style="color: #ff00ff;">1</span>;
<span style="color: #ff00ff;">for</span> (i = <span style="color: #ff00ff;">1</span>; i &lt; <span style="color: #ff00ff;">1000</span>; i++);
PORTBbits.RB7 = 0;
<span style="color: #ff00ff;">for</span> (i = <span style="color: #ff00ff;">1</span>; i &lt; <span style="color: #ff00ff;">1000</span>; i++);</p>
<p style="padding-left: 30px;">}</p>
}

Il faut bien évidemment adapter __18F2550 et pic18f2550 selon le modèle de PIC que vous utilisez. Ce programme se contente en fait de faire clignoter en boucle la LED qui se trouve en sortie de PORTBbits.RB7 – qui est l’adresse d’un port d’entrée/sortie du microcontrôleur vous l’aurez compris. Ça fait rêver, n’est-ce pas ? ;)

EDIT : En essayant de faire fonctionner ce programme avec un PIC16F690, j’ai eu la désagréable surprise de constater que PORTBbits.RB7 n’est pas reconnu. Pas de panique, il suffit d’enlever « PORTBbits. » avant RB7. En effet, avec SDCC, les entrées/sorties sont définies différemment des cibles PIC18F. Nous reviendrons sur la portabilité dans une leçon ultérieure.

Vous pouvez enregistrer ce projet comme template personnalisé pour ne plus avoir à tout reconfigurer. Pour cela, Allez dans le menu « File » et sélectionnez « Save project as template… ». Il ne vous reste plus qu’à nommer ce template et à cliquer sur « OK ». Désormais, lors de la création d’un projet, il vous suffira d’aller dans la catégorie « User templates » et de choisir le template pour pouvoir créer un projet sur le modèle de celui que vous venez de créer et de configurer.

Pour le reste, je vous encourage à lire la documentation du compilateur SDCC et celle du microcontrôleur que vous utilisez. Nul besoin de les connaître sur le bout des doigts, mais cela vous permettra de vous familiariser avec la structure des programmes que vous devrez écrire. C’est d’ailleurs comme ça pour tous les outils de développement que vous serez amenés à utiliser. ;)

Sur ce, je vous laisse et vous dis à bientôt.

Nicolas SAN AGUSTIN

Copyright Nicolas SAN AGUSTIN 2018
Tech Nerd theme designed by Siteturner