MiniCore Rabbit RCM5700 : premiers pas

Nous avons reçu de la société MATLOG le kit de développement pour carte embarquée MiniCore RCM5700 de la société Rabbit (rachetée par DIGI qui produit aussi les XBee).

Lien vers le catalogue Matlog (contactez-les de notre part pour vos projets)

Nous allons présenter dans cet article les différentes étapes qui permettent de réaliser notre premier programme en Dynamic C : le clignotage de led, le B-A BA de l’électronique, le "Hello World" du roboticien.

 Découverte

Je vous passe le déballage du colis.

Le kit de développement est fourni dans un boitier plastique genre "double CD-ROM".

Boitier du kit de développement

Il est suffisamment haut pour accueillir le module RCM5700, une documentation de démarrage (en anglais), un câble USB et les deux cartes électroniques dont une carte simple de prototypage (en arrière-plan sur la photo ci-dessous).

Contenu du boitier

Description du RCM5700

Il s’agit d’un module de très petite dimension (30 mm x 51 mm), fonctionnant avec un microprocesseur puissant (le Rabbit 5000) à 50 Mhz, offrant 32 entrées sorties dont certains ont des fonctionnalités avancées : PWM, décodeur en quadrature, ports série, etc. ainsi qu’un port Ethernet 10/100 base T.

Module RCM5700

Par rapport aux cartes que nous utilisons habituellement (basées sur microcontrôleur AVR principalement), il y a bien sûr l’avantage de la puissance de calcul (128k de mémoire vive, horloge de 50 Mhz) mais il y a aussi les routines du langage Dynamic C qui sont adaptées au temps réel.

Assemblage du kit

Le module RCM5700 est au format mini pci express avec un connecteur spécial qui s’insère dans un socket particulier de 52 pattes.

C’est vrai que c’est petit :

Comparaison de l’échelle

On va insérer le module dans la carte de développement qui comporte tous les connecteurs pratiques (Ethernet, alimentation, USB, connecteurs au pas standard).

Pour cela, il faut présenter le module incliné par rapport au connecteur socket Mini PCI Express.

Mise en place de la carte

Prenez-garde lors de l’installation, il vous faudra appuyer sur la carte. Evitez de renouveller l’opération trop souvent.

La carte est finalement mise en place et vous voilà prêt à connecter la carte à un ordinateur. La programmation se fait par USB, à la manière d’un bootloader, et comme tous les kits modernes, auto-alimenté pour les montages ne nécessitant pas d’ampérage trop important (comptez 70 mA pour la carte à 50 MHz seule).

Connecteurs du kit de développement

 Le logiciel

Sur le CD-ROM livré avec le kit, une version 10.44 de l’environnement de développement Dynamic C incluant l’éditeur de projets + compilo + bootloader. Une suite intégrant tout ce qu’il faut pour écrire des programmes pour le RCM5700 et capable d’être étendu avec des modules disponibles sur le site web de Rabbit.

L’installation se lance automatiquement.

Démarrage de l’installeur

Par défaut, toutes les options sont sélectionnées, c’est le plus pratique.

Choix des options

On vous demandera de sélectionner un port série. Si comme moi vous n’avez pas encore connecté la carte (par prudence, généralement on branche après l’installation du soft), vous n’avez que le port série. Il faudra penser à le changer dans les options par la suite.

L’installation est terminée (j’ai sauté les étapes classiques), et vous pouvez connecter votre carte Rabbit (installation du driver USB/série la première fois) et lancer le logiciel.

 Premier programme

Lancez le logiciel : il y a un raccourci vers Dynamic C 10.44 sur votre bureau. Vous aurez peut être ce message, n’en tenez pas compte et validez :

Il y a un projet ouvert par défault. Vous n’avez pas besoin d’en créer un autre mais il faut paramétrer le port série qui est apparu dans votre système quand vous avez connecté votre carte Rabbit.

Dans le menu "Options", choisissez "Project options"

Puis dans cette nouvelle fenêtre, sur le premier onglet "Communications", choisissez le nouveau port série et laissez les autres options à l’identique.

Créez un nouveau fichier que vous enregistrez en test.c et vous êtes prêt à écrire un programme de test.

Le cahier des charges

Nous allons utiliser une led et un bouton switch présents sur la carte d’interface, et on va reproduire le bon vieux clignotement de led.

Voici la partie concernée (il existe un autre bouton de contact, pour le reset, près du port Ethernet). Notez les cavaliers sur la gauche : il faut shunter les jumpers 3 et 4 pour avoir accès à la led (DS1) et au switch (S1).

Tests sur la carte d’interface du RCM

Si vous êtes novices en programmation de microcontrôleurs, reportez-vous aux articles dédiés aux µC AVR, ils sont adaptés aux débutants.

La configuration des ports

La led est connectée sur le PORT D, patte 0. Il faut la configurer en sortie.
Il y a deux registres à paramétrer :
 registre DDR du port D comme sur tout microcontrôleur pour indiquer la direction du port (DDR = Data Direction Registrer). Il s’appelle PDDDR dans le cas de Dynamic C et du processeur Rabbit 5000.
 registre FR : Function Register qui indique si le port est utilisé en tant qu’entrée/sortie (niveau à 0) ou sortie alternative (niveau à 1, pas ce que nous cherchons ici).

// la led est en sortie (port D, registre DDR à niveau 1 sur la patte 0)
BitWrPortI(PDDDR, &PDDDRShadow, 1, 0) ;
// pas de sortie alternative (port D, registre FR à niveau 0 sur la patte 0)
BitWrPortI(PDFR, &PDFRShadow, 0, 0) ;

Les fonctions changent un peu, il y a des prototypes plus complexes que sur AVR (le pointeur vers le Shadow notamment) mais les principes sont les mêmes : configurer des registres par octet (WrPortI) ou bit par bit (BitWrPortI).

La boucle active

Venons-en à ce qui fait la différence avec nos programmes classiques.
Rappel de la trame de ce genre de programme :

// déclarations

main()

// initialisations

while (1)

// boucle infinie
// allumer la led
// attendre 50 ms
// éteindre la led
// attendre 50 ms

Ici, pas de déclarations, l’environnement de développement a des options permettant de sélectionner la cible, donc pas la peine de rappeler quel est le microcontrôleur, sa fréquence et tout ce qu’on mettait dans un fichier header sous GCC pour nos Atmels.

La boucle aussi va rester, mais on va utiliser un nouveau mot clé : costate pour encapsuler l’action dans une tâche indépendante du reste de notre boucle. C’est obligatoire, si vous ne la mettez pas le programme refuse de compiler.

Voici le code final (vous noterez que la led est allumée sur niveau bas, c’est courant) :

// déclarations (aucune)

main()

// initialisations
BitWrPortI(PDDDR, &PDDDRShadow, 1, 0) ;
BitWrPortI(PDFR, &PDFRShadow, 0, 0) ;

while (1)

// boucle infinie
costate
// allumer la led
WrPortI(PDDR, NULL, 0) ;
// attendre 50 ms
waitfor(DelayMs(50)) ;
// éteindre la led
WrPortI(PDDR, NULL, 1) ;
// attendre 50 ms
waitfor(DelayMs(50)) ;

Dans la série, je ne crois que ce que je vois, regardons ce qui se passe si on crée une autre tâche qui va durer plus longtemps que la durée totale d’une itération de la tâche de clignotement :

costate
// je clignote en 100 ms

costate
waitfor(DelayMs(500)) ;
printf("je lis le journal\r\n") ;

Et bien ça marche, la led va clignoter sans discontinuer tandis que la phrase ne s’affichera que toutes les demi-secondes (au passage, on profite de la console de l’IDE Dynamic C).

Bien entendu, on peut faire bien des choses dans ces tâches qui s’exécutent en parallèle, comme regarder ce qui se passe sur le bouton (qu’il faudra également paramétrer) et on va toucher du doigt toute l’essence de la programmation temps réel : accéder aux mêmes ressources depuis des tâches différentes, par exemple un flag qui va activer ou désactiver le clignotement.

main()

int flag ;
// compilo un peu capricieux, on ne peut pas déclarer et initialiser en même temps
flag = 0 ;

// mettre l’interrupteur (patte 1) à 0
BitWrPortI(PDDR, &PDDDRShadow, 0, 1) ;

// déclarer les directions : sortie pour la led, entrée pour le switch
BitWrPortI(PDDDR, &PDDDRShadow, 1, 0) ;
BitWrPortI(PDDDR, &PDDDRShadow, 0, 1) ;

// désactiver les fonctions
BitWrPortI(PDFR, &PDFRShadow, 0, 0) ;
BitWrPortI(PDFR, &PDFRShadow, 0, 1) ;

while (1)

costate
// clignotement uniquement sur flag à 1
if (flag)

WrPortI(PDDR, NULL, 0) ;
waitfor(DelayMs(50)) ;
WrPortI(PDDR, NULL, 1) ;
waitfor(DelayMs(50)) ;

costate
// on attend un niveau haut (doigt posé)
waitfor(BitRdPortI(PDDR, 1)) ;
// une petite attente raisonnable
waitfor(DelayMs(50)) ;
// et on teste s’il y a relachement
if (!BitRdPortI(PDDR, 1))

// on inverse le flag
flag = !flag ;

C’est vraiment pratique : pas besoin d’interruption, il suffit d’utiliser l’instruction waitfor avec le test du switch et on n’a pas le souci de bloquer le reste des instructions.

Voilà, on a terminé avec la découverte du kit, on est prêt à dévorer l’ensemble des instructions disponibles, et les fonctionnalités temps réel qui nous seraient si pratiques... cela promet des discussions pour savoir qui aura la garde du module :)

Et on finit par un petit cadeau : un poster géant avec tous les registres du microprocesseur Rabbit 5000 pour ceux qui ont lu l’article jusqu’ici :)

Pour continuer : Programmation multi-threads