SDK Sphero – Part 3 – Les macros

Après avoir appris à piloter sphero et utiliser ses capteurs, je vais clore cette série en vous parlant de son système de macro.

Qu’est-ce qu’une macro?

Présentes dans beaucoup de logiciels, elles proposent le plus souvent de réaliser automatiquement des actions utilisateurs, successives et préalablement enregistrées, en un clic. En d’autres termes c’est un programme capable de lancer plusieurs commande à la suite.

Sphero possède un système de macro. On va donc pouvoir pré-enregistrer des ordres à lui envoyer, pour ensuite lui demander en un seule fois de les exécuter tous successivement.

Les macros avec sphero

Avant de commencer, même si je vais reprendre beaucoup d’informations de la documentation d’orbotix sur les macros, je vous suggère d’aller la lire, car elle est très complète. Vous la trouverez ici.

Sphero est capable de comprendre 3 types de macros différentes :

• Permanent : Ce type de macro est stockée et gardée en mémoire grâce à un identifiant (compris entre 32 et 253)
• Temporary : Contrairement à la macro permanente, elle est stockée en RAM, et est donc faite pour être appelée juste après l’avoir stockée
• Stream : Les deux premiers types de macros sont limités en taille. Ils ne peuvent dépasser 254 octets. Si vous avez besoin de plus, ce type permet d’envoyer un nombre infini de commande. Cette macro devra se terminée par la commande StreamEndMacroCommand

Il est également possible de changer le comportement des macros grâce aux “Flags”. Ces derniers sont bien détaillés dans la documentation.

La macro sera donc constituée d’un type, de “Flags”, et bien entendu, le plus important : de commandes.

Voici la liste des commandes disponibles :

BranchOnCollisionMacroCommand	CommentMacroCommand	ConfigureCollisionDetectionMacroCommand
DelayMacroCommand	EmitMarkerMacroCommand	EndMacroCommand
FadeToLEDOverTimeMacroCommand	GosubMacroCommand	GotoMacroCommand
GoToSleepNowMacroCommand	LoopEndMacroCommand	LoopStartMacroCommand
LoopStartSystemMacroCommand	MacroCommand	Roll2MacroCommand
RollAtSPD1WithSD1MacroCommand	RollAtSPD2WithSD1MacroCommand	RollMacroCommand
RollWithSD1MacroCommand	RotateOverSD1MacroCommand	RotateOverSD2MacroCommand
RotateOverTimeMacroCommand	SendRawMotorMacroCommand	SetBackLEDMacroCommand
SetHeadingMacroCommand	SetRGBLEDMacroCommand	SetRGBLEDWithSD2MacroCommand
SetRotationRateMacroCommand	SetSD1MacroCommand	SetSD2MacroCommand
SetSPD1MacroCommand	SetSPD2MacroCommand	SetSpeedMacroCommand
SetStabilizationMacroCommand	StreamEndMacroCommand	WaitUntilStoppedMacroCommand

Je ne vais pas toutes les détailler ici, mais je vous renvoie une nouvelle fois vers la documentation pour avoir la description de chacune.

Exemples

Passons au code maintenant, je vais vous montrer deux exemples différents de macros :

• Une macro arc-en-ciel temporaire
• Une macro permanente qui fait réaliser un flip à sphero

Macro arc-en-ciel temporaire

Commençons par instancier notre macro :

using Sphero.Macros;

//
//...
//

Macro rainbowMacro = new Macro(MacroType.Temporary, 255);

Nous avons ici créé une macro de type temporaire avec l’identifiant 255 (obligatoire pour une macro temporaire).

Ajoutons maintenant la liste de commande que nous allons vouloir exécuter :

using Sphero.Macros.Commands;

//
//...
//
rainbowMacro.Commands.Add(new LoopStartMacroCommand() { Count = 5 });
rainbowMacro.Commands.Add(new FadeToLEDOverTimeMacroCommand()
{
    Red = 0xFF,
    Green = 0,
    Blue = 0,
    Time = 200
});
rainbowMacro.Commands.Add(new DelayMacroCommand { Time = 200 });
rainbowMacro.Commands.Add(new FadeToLEDOverTimeMacroCommand()
{
    Red = 0xFF,
    Green = 0x7E,
    Blue = 0x6D,
    Time = 200
});
rainbowMacro.Commands.Add(new DelayMacroCommand { Time = 200 });
rainbowMacro.Commands.Add(new FadeToLEDOverTimeMacroCommand()
{
    Red = 0x7F,
    Green = 0xFF,
    Blue = 0x00,
    Time = 200
});
rainbowMacro.Commands.Add(new DelayMacroCommand { Time = 200 });
rainbowMacro.Commands.Add(new FadeToLEDOverTimeMacroCommand()
{
    Red = 0x00,
    Green = 0xFF,
    Blue = 0x00,
    Time = 200
});
rainbowMacro.Commands.Add(new DelayMacroCommand { Time = 200 });
rainbowMacro.Commands.Add(new FadeToLEDOverTimeMacroCommand()
{
    Red = 0xDE,
    Green = 0x00,
    Blue = 0xFF,
    Time = 200
});
rainbowMacro.Commands.Add(new DelayMacroCommand { Time = 200 });
rainbowMacro.Commands.Add(new LoopEndMacroCommand());

Il y a beaucoup de ligne mais finalement pas beaucoup de commandes différentes :

• LoopStartMacroCommand et LoopEndMacroCommand, permettent de boucler Count fois sur les commandes qui se trouvent entre les deux
• FadeToLEDOverTimeMacroCommand permet de faire un effet de Fade entre la couleur actuelle de la LED RGB et la couleur demandée
• DelayMacroCommand temporise avant la commande suivante

Maintenant que nous avons définit notre macro, nous pouvons la stockée dans la RAM et l’exécuter immédiatement comme ceci :

_spheroDevice.SaveTemporaryMacro(rainbowMacro, response =>
{
    if(response == Sphero.Communication.MessageResponseCode.ORBOTIX_RSP_CODE_OK)
    {
        _spheroDevice.RunTemporaryMacro(null);
    }
});

Macro flip permanente

Passons maintenant à la macro flip permanente. L’instanciation se fait de la manière suivante :

Macro flipMacro = new Macro(MacroType.Permanent, 102);

Il faut surtout remarquer le changement du premier paramètre et de l’identifiant, qui peut être compris entre 32 et 253.

La définition de la macro est la suivante :

flipMacro.Commands.Add(new SendRawMotorMacroCommand
{
    LeftMode = MotorMode.Forward,
    LeftPower = 255,
    RightMode = MotorMode.Forward,
    RightPower = 255,
    PCD = 255
});
flipMacro.Commands.Add(new DelayMacroCommand { Time = 150 });
flipMacro.Commands.Add(new SendRawMotorMacroCommand
{
    LeftMode = MotorMode.Off,
    LeftPower = 0,
    RightMode = MotorMode.Off,
    RightPower = 0,
    PCD = 255
});
flipMacro.Commands.Add(new SetStabilizationMacroCommand
{
    Flag = StabilizationStatus.OnWithoutReset,
    PCD = 255
});

La première SendRawMotorMacroCommand permet de demander aux moteurs de mettre plein gaz vers l’avant. Cette commande va créer une inertie et vers pivoter la boule sur elle même.

Après un court délai, donné par la DelayMacroCommand, la deuxième SendRawMotorMacroCommand va permettre de stopper les moteurs (sinon ils continueraient à fond après la fin de l’exécution de la macro).

Et enfin on réactive la stabilisation avec SetStabilizationMacroCommand. Cette dernière étape est nécessaire si on veut reprendre la conduite de sphero après. SendRawMotorMacroCommand désactive implicitement la stabilisation.

Maintenant que l’on a définit la macro on peut la stocker :

_spheroDevice.SaveMacro(flipMacro, null);

Plus loin dans notre programme nous pourrons l’exécuter de cette manière :

// 102 correspond à l'identifiant que l'on avait donné
// à notre macro lors de sa définition
 _spheroDevice.RunMacro(102, null);

Maintenant votre sphero faire un petit bond.

Un projet reprenant ces deux exemples est disponible ici.

Cette série sur le sdk sphero est maintenant terminée. Pour rappel le SDK est disponible à cette adresse. J’espère que cette série vous aura été utile, et que le sdk vous permettra de réaliser toutes vos idées.

A bientôt !