Développement

Suite a la mise a disposition par Violet de spécifications, deux types de développement sont aujourd'hui possibles pour le Nabaztag.

API HTTP

Le développement le plus immédiat a mettre en œuvre repose sur l'API HTTP, qui permet a tout client Web d'interagir avec les serveurs Violet. Le client web peut être un navigateur, mais aussi et surtout un programme.

Les commandes existantes permettent:

• le retrait de la position actuelle des oreilles
• un changement de position des oreilles
• l'envoi au lapin d'un message de la bibliothèque Violet ou d'un MP3 personnel
• l'envoi d'un message en synthèse vocale
• l'envoi vers les nabcast
• l'envoi d'une chorégraphie, ou animation visuelle du lapin

L'API HTTP est largement mise en œuvre sur plusieurs sites Web qui mettent a disposition une interface de saisie et d'envoi des commandes. Elle est principalement discutée sur le forum forumactif dans la rubrique API, sa documentation est disponible sur le site Violet.

NabazLab ne repose pas sur cette API, mais certaines de ses fonctions constituent des outils utiles pour son usage. En particulier, l'éditeur de chorégraphie intégré au Studio permet d'exporter au format de l'API HTTP et de tester en envoyant la chorégraphie aux serveurs Violet.

Client-serveur

L'essence de NabazLab est d'offrir une alternative au système Violet en fournissant a la fois une outil de développement et un serveur indépendant pour le Nabaztag. Cette combinaison permet la création de services spéciaux non disponibles ailleurs, ou non réalisables depuis un serveur distant.

Ce type d'application est distribué entre le serveur et le lapin:

• Côté lapin

  Le microcode intégré dans le lapin ne peut pas être mis a jour, mais il implémente une machine virtuelle capable elle-même d'exécuter des programmes a la manière d'une machine virtuelle Java ou .NET. Tous les services Violet sont réalisés ainsi.

  Au démarrage, la machine virtuelle est vide et le lapin contacte son serveur pour obtenir le programme a exécuter. Par la suite, le lapin contacte a nouveau le serveur a intervalle régulier pour obtenir les mises à jour du programme et de ses paramètres.

  NabazLab contient un assembleur pour la machine virtuelle. Accessible en ligne de commande, dans le Studio, depuis le Service, ou depuis n'importe quel programme .NET, il transforme le texte du programme en bytecode directement exécutable par la machine virtuelle.

  Le langage assembleur est un langage de très bas niveau. Outre les opérations communes de calcul et de gestion du flot d'exécution, il permet le pilotage des éléments matériels du Nabaztag. La documentation du langage est disponible sur le site Violet, les extensions spécifiques a NabazLab sont documentées sur la page Assembleur.

  NabazLab Studio contient un éditeur de texte et un mini-serveur pour tester le code créé.

• Côté serveur

  Le serveur détermine le comportement du lapin en répondant a ses requêtes récurrentes en fonction de paramètres externes. De tels paramètres peuvent être le nombre de messages dans une boite aux lettres, les messages sonores en attente dans une base de données, un calcul de biorythme, ou a peu près n'importe quoi d'autre.

  Une réponse complète du serveur est une compilation de sons échantillonnés, de fichiers midi, de bytecode exécutable et de paramètres pour le bytecode. Une réponse partielle de mise a jour des paramètres est aussi possible.

  NabazLab Service contient un serveur autonome et modulaire, pilotable par une interface Web. Une bibliothèque permet de créer un module et service minimum en quelques lignes de code C#, VB.NET ou Java (J#).

Ces deux composants sont très étroitement liés, et doivent être développés et mis au point ensemble.

NabazLab vise a fournir un support et un environnement pour les deux aspects du développement.

Cohabitation

Il est à noter que du fait de l'architecture, il est en principe impossible de faire cohabiter les services Violet et des services spécifiques. A un instant donné le bytecode chargé dans le lapin est soit celui de Violet, soit un développement particulier.

Bien qu'il soit possible pour un module ou proxy de modifier au vol les données échangées entre le lapin et le serveur Violet afin d'ajouter ou de modifier un service, cette approche n'est pas recommandée. Le moindre changement du cote Violet risquerait de provoquer un dysfonctionnement.

Si une cohabitation des services est souhaitée l'approche "sûre" consiste a implémenter une bascule automatique au sein du module entre deux modes de fonctionnement :

• Mode proxy, ou Violet

  Les requêtes du lapin sont retransmises a Violet et les réponses retournées au lapin, sans modification. Quand le module souhaite prendre le contrôle du lapin suite a un évènement extérieur ou chronologique, il provoque un rechargement de la VM avec son propre bytecode.

• Mode serveur, ou local

  Quand le contrôle n'est plus nécessaire, la première requête reçue du lapin est modifiée par le module pour contenir des paramètres de réinitialisation, puis transmise a Violet. En retour, Violet retourne une réponse contenant le bytecode original et le module revient au mode proxy.

Studio

NabazLab Studio est un environnement de développement intégré pour le Nabaztag, fonctionnant exclusivement sous Windows.
Il est activé en exécutant NabazLab.Studio.exe.

Editeur de chorégraphie

Cet éditeur permet d'éditer les fichiers chorégraphie (.nzdnc).

Une chorégraphie est une séquence temporisée d'opérations de pilotage du lapin. Elle peut d'ores et déjà être transmise à un lapin par l'intermédiaire de l'API HTTP et il sera bientôt possible de les utiliser dans le serveur NabazLab.

Chaque opération ou étape peut être de trois types:

• Attente
  Pour introduire un délai entre deux opérations
• Moteur
  Pour déclencher un des moteurs d'oreille jusqu'à une position indiquée, en indiquant le sens de rotation
• Lumière
  Pour changer l'intensité d'une des lumières, en spécifiant les composantes rouge, vert et bleu

Une nouvelle chorégraphie est créée par le menu Fichier Nouveau Chorégraphie, l'écran d'édition est décomposé en trois parties:

• A gauche, en haut, une simulation du lapin pour prévisualiser l'animation
• Une panneau de réglage sous le lapin, qui change selon l'opération sélectionnée
• Une liste des opérations de l'animation à droite

La création d'une chorégraphie s'effectue en ajoutant des étapes à l'animation, et pour chaque étape en sélectionnant soit une partie du lapin à animer soit l'horloge pour indiquer un délai. Les sélections s'effectuant avec la souris, le clavier sert à sélectionner l'étape à modifier.

Certaines fonctions disposent d'un raccourci au clavier:

• Espace ou Insér duplique l'opération sélectionnée
• Entrée démarre ou arrête la simulation de l'animation à l'écran
• Suppr supprime l'opération courante
• Maj+Haut déplace l'étape d'une ligne vers le haut de la liste
• Maj+Bas déplace vers le bas

Trucs et astuces:

• La barre d'espace est votre meilleure amie, si vous cliquez le lapin sans dupliquer votre dernière étape l'opération courante est remplacée
• Positionnez une étape inutile à la fin de la chorégraphie, pour que le lapin exécute l'Attente qui la précède
• La palette des lumières sous les réglages de couleur est réglable par le bouton droit de la souris
• Le sens de rotation des moteurs peut être inversé en cliquant le milieu de la roue de positionnement des oreilles
• Les commandes moteur sont asynchrones, c'est à dire que l'étape suivante est exécutée immédiatement sans attendre que l'oreille ait atteint sa position finale
• L'éditeur et sa commande Envoyer amusent généralement les enfants :-)

La commande Copier permet de copier la chorégraphie dans le presse-papier dans le format texte utilisé par l'API HTTP, afin de l'utiliser depuis une autre application ou une page web.

Editeur de code

L'éditeur de code assembleur du Studio est encore très rudimentaire, mais sera bientôt amélioré.

Son intérêt réside dans le fait qu'il assemble le code au fur et à mesure de son édition, et signale d'éventuels problèmes dans la barre d'état.

Quand le serveur embarqué est actif en mode assembleur, une sauvegarde du fichier édité permet sa mise à jour sur le lapin. Il est à noter que le même résultat peut être obtenu avec un éditeur de texte externe.

Serveur Embarqué

Le serveur intégré au Studio est géré depuis la fenêtre ouverte au démarrage.

Il est par défaut inactif, et est simplement activé en cliquant la case a cocher Activé après avoir éventuellement modifié le numéro de port TCP et le mode de fonctionnement.

Le port par défaut est 8080, c'est a dire le même que celui utilisé par NabazLab Service. Par conséquent, sans modification du port les serveurs du Studio et du Service ne peuvent fonctionner simultanément.

Les deux modes de fonctionnement sont les suivants:

• Mode proxy

  Dans ce mode, les requêtes du lapin sont simplement relayées au serveur Violet, et les réponses retournées au lapin. Ceci permet d'une part de remettre le lapin dans sont état d'origine sans le reconfigurer, et d'autre part d'étudier son fonctionnement en capturant le trafic généré.

• Mode assembleur

  Le mode assembleur, au moment de son activation, permet de choisir un fichier assembleur (.nzasm) qui sera assemblé et transmis au lapin pour exécution. Le serveur surveille le fichier source, puis le réassemble et le retransmet en cas de modification du fichier.

Dans les deux modes, il est possible d'activer la capture du trafic réseau entre le lapin et son serveur. La capture au complet ou certains des éléments capturés peuvent être enregistrés par l'intermédiaire du menu Fichier.

Visualisation de captures

Une capture enregistrée par le serveur embarque (.nzcap) peut être consultée à nouveau au travers du menu Fichier Ouvrir.

Comme pendant la capture certains éléments échangés entre le lapin et son serveur peuvent être enregistrés séparément ou copiés vers le presse-papier.

Service

NabazLab Service est un serveur autonome et modulaire pour le Nabaztag.
Il ne fonctionne actuellement que sous Windows mais pourra être porté sur d'autres plateformes.

L'exécution de NabazLab.Service.exe donne accès au menu du Service.

Lorsqu'il est activé, le Service est configurable par une interface web sur le même port que celui utilisé par le lapin (par défaut http://localhost:8080).

Installation (optionnelle)

Depuis ce menu, il est possible de gérer l'installation du Service et son fonctionnement de base.
Une fois installé comme service Windows, le Service démarre dès la mise en route de l'ordinateur et fonctionne en tâche de fond.

Le Service peut aussi fonctionner comme un exécutable normal grâce à l'option "Mode console de débogage" présente dans le menu.

Modules

Un module est un fichier librairie .NET ayant une extension spéciale (.nzmod), qui peut être programmé en n'importe quel langage (Visual C# Express est recommandé, disponible gratuitement). Le Service charge automatiquement au démarrage les modules présents dans son répertoire.

La procédure d'installation d'un module se limite a copier le fichier puis redémarrer le service.
Pour une mise à jour, il est nécessaire de commencer par arrêter le Service pour pouvoir remplacer le fichier.

Seuls les modules "Proxy" et "Serveur d'Assembleur" sont inclus dans le cœur de NabazLab, les autres sont implémentés sous forme de modules ou plug-ins.

Un module d'exemple est fourni, qui permet de télécommander l'état des lumières du lapin (NabazLab.RemoteControl.nzmod).

Architecture

Un module doit référencer la librairie "NabazLab.Core.dll". Il présente un ou plusieurs points d'entrée, des fonctions statiques découvertes dynamiquement grâce a l'attribut [ModuleInitializer].

Ces fonctions sont appelées au démarrage et enregistrent les modules disponibles par appel à DeviceHandler.Register(), en fournissant un delegate vers une ou deux fonctions.

La première fonction, obligatoire, sera chargée de répondre aux requêtes du lapin en s'appuyant sur les aides fournies par "NabazLab.Core.dll".

La deuxième, optionnelle, prendra en charge la page web de configuration du module.

Ce mécanisme sera prochainement modifié pour permettre la création de nouveau modules avec moins de code, mais le principe restera identique et l'adaptation sera aisée.

Compilation

Si vous souhaitez créer votre propre module ou recompiler l'exemple, il devra être renommé après chaque compilation. En effet, un défaut dans le Framework .NET empêche de compiler une librairie en lui donnant une extension spécifique.

Une solution pour corriger ce problème consiste à modifier manuellement la configuration par défaut de l'utilitaire MSBuild ainsi que le fichier projet du module.

Effectuez une copie de sauvegarde du fichier "Microsoft.Common.targets" normalement situé dans "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727", puis ouvrez l'original dans un éditeur de texte. Cherchez "TargetExt", puis remplacez le bloc suivant :

<PropertyGroup>
  <TargetExt Condition="'$(OutputType)'=='exe'">.exe</TargetExt>
  <TargetExt Condition="'$(OutputType)'=='winexe'">.exe</TargetExt>
  <TargetExt Condition="'$(OutputType)'=='library'">.dll</TargetExt>
  <TargetExt Condition="'$(OutputType)'=='module'">.netmodule</TargetExt>
</PropertyGroup>

Par :

<PropertyGroup>
  <TargetExt Condition="'$(OutputType)'=='exe' and '$(TargetExt)' == ''">.exe</TargetExt>
  <TargetExt Condition="'$(OutputType)'=='winexe' and '$(TargetExt)' == ''">.exe</TargetExt>
  <TargetExt Condition="'$(OutputType)'=='library' and '$(TargetExt)' == ''">.dll</TargetExt>
  <TargetExt Condition="'$(OutputType)'=='module' and '$(TargetExt)' == ''">.netmodule</TargetExt>
</PropertyGroup>

Ensuite, ouvrez votre fichier projet (.csproj) dans un éditeur de texte. Dans le premier tag "PropertyGroup" (celui qui contient le tag "OutputType") insérez:

<TargetExt>.nzmod</TargetExt>

Cette solution fonctionne avec le Framework SDK comme avec Visual Studio.

Assembleur

NabazLab Assembleur est un assembleur en ligne de commande pour la machine virtuelle du Nabaztag.

Disponible aujourd'hui sous Windows, il est en cours d'adaptation à d'autres plateformes par le biais de mono.
Mono fonctionnant sous d'autres plateformes que Windows, l'Assembleur devrait bientôt être utilisable sous Linux, Mac OS X, Sun Solaris et les variantes de BSD.

Utilisation

L'Assembleur a pour but de permettre à d'autres projets d'intégrer ou d'exploiter les capacités de l'assembleur de NabazLab. Il permet de transformer un code source (.nzasm) en trois formats binaires différents:

• Bytecode
  Le fichier résultant contient le bytecode pour la machine virtuelle. Il nécessite d'être intégré dans d'autres données avant de pouvoir être transmis au lapin.
• Programme
  Le résultat est une trame programme complète, incluant les sons éventuels et la somme de contrôle.
• Réponse
  Le fichier généré contient une réponse complète aux requêtes du lapin, en ajoutant les identificateurs, la trame de fréquence et les paramètres.

Le fichier résultat a le même nom que le source et l'extension dépendant du format, respectivement ".nzcod", ".nzprg" et ".nzrsp".

La syntaxte exacte est:

NabazLab.Assembler.exe <fichier> [-format:<bytecode|program|response>]

Outre l'Assembleur en ligne de commande, le Service et le Studio sont aussi capables d'assembler du code source.

Langage

Le language assembleur du Nabaztag a été documenté par Violet, le document est disponible sur leur site. NabazLab implémente ce langage, avec quelques additions et interprétations:

• Les commentaires sont introduits par un point-virgule, ce qui suit est ignoré jusqu'à la fin de la ligne (; commentaire).
• Des étiquettes peuvent être posées dans le code, précédées du symbole deux-points (:Etiquette).
• Toutes les instructions de branchement et de tables peuvent référencer ces étiquettes.
• Les constantes hexadécimales sont introduites par un symbole dollar ($F8).
• #constant permet de déclarer une constante (#constant Haut 4)
• #variable permet de déclarer un offset auto-incrémenté dans le bloc de données de 256 octets (#variable DonneeTresUtile)
• Les constantes et variables sont introduites par une arobace (LD R0,@Haut)
• #idata permet de déclarer des données octet par octer (#idata $01,$F8,-3).
• #wdata permet de déclarer des données en mots, y compris des étiquettes et donc des tables de branchement (#wdata $1234,Etiquette,$1256).
• #base est optionnel, permis en début de code seulement, et spécifie l'adresse d'exécution de départ (la valeur par défaut est celle fixée pour l'instant sur le Nabaztag).

En addition au langage à proprement parler, d'autres directives optionnelles permettent d'indiquer au programme exécutant l'assemblage des éléments à communiquer au lapin:

• #transition positionne l'indicateur de transition dans la trame programme (#transition 1)
• #frequency règle la frèquence ultérieure des requêtes exprimée. 1 pour 10 secondes, 2 pour 20 secondes, etc...
  Une fréquence à zéro provoque plusieurs requêtes par seconde (#frequency 0)
• #identifier définit l'identificateur de programme (#identifier 1234)
• #parameters ajoute des octets à la trame de paramètres (#parameters 1,2,3,4)
• #sound inclut un fichier son dans la réponse et définit une constante auto-incrémenté (#sound MonMidi sons\monmidi.mid)

NabazLab considère que les entiers décimaux sont signés, il n'est pas donc pas possible de définir une valeur supérieure à 127 sans utiliser la notation hexadécimale.

Désassembleur

Un désassembleur est aussi présent, utilisé par exemple pendant la visualisation des captures. Ses résultats sont généralement bons, mais sujet à deux problèmes:

• Il ne peut pas toujours discerner correctement les zones de code des zones de données, par exemple a cause des tables de branchement. Dans le doute, il émet des directives #idata.
• Au moins une instruction n'a pas été documentée par Violet (par exemple $A9).

Créer un module

Cette page décrit la création d'un module simple en C# et assembleur pour le Service NabazLab.
La fonction du module sera simplement d'allumer le lapin en bleu si un fichier "C:\Bleu.txt" existe, sinon de l'éteindre.

Outils

Bien que le Framework .NET SDK puisse être suffisant, nous vous recommandons plutôt l'utilisation de Microsoft Visual C# Express. Il nécessite une inscription mais est actuellement téléchargeable gratuitement auprès de Microsoft, en français ou en anglais.

Ce tutoriel est réalisé avec la version française, aucun autre outil n'est nécessaire.

Création du projet

Nous allons créer un nouveau projet, de type bibliothèque (DLL) :

• Utilisez le menu Fichier/Nouveau projet,
• Sélectionnez Bibliothèque de classes,
• Dans le champs Nom entrez MonModule,
• Cliquez Ok.

Le projet est crée, et le document Class1.cs est présenté.

Configuration des dépendences

Cette configuration va lier le projet à la bibliothèque NabazLab.Core :

• Cliquez avec le bouton droit sur les References dans l'Explorateur de solutions,
• Choisissez Ajouter une référence,
• Sélectionnez l'onglet Parcourir,
• Naviguez jusqu'à NabazLab.Core.dll et sélectionnez le fichier,
• Cliquez Ok.

Configuration des ressources

Nous allons créer un fichier assembleur vide et l'ajouter au projet :

• Cliquez avec le bouton droit sur MonModule dans l'Explorateur de solutions,
• Utilisez le menu Ajouter, puis Nouvel élément,
• Choisissez Fichier Texte,
• Dans le champs nom, remplacez par TextFile1.nzasm,
• Cliquez le bouton Ajouter.

Ensuite, nous configurons le projet pour que le fichier soit intégré dans le module :

• Utilisez le menu Fichier/Enregistrer tout,
• Modifiez éventuellement le champs Emplacement, puis cliquez Enregistrer,
• Double-cliquez Properties dans l'Explorateur de solutions,
• Sélectionner l'onglet Ressources,
• Cliquez le lien au milieu du document vide,
• Cliquez la petite flèche à droite de Ajouter une ressource, puis Ajouter un fichier existant,
• Naviguez jusqu'au fichier TextFile1.nzasm, cliquez Ouvrir.

Création du code assembleur

Basculez vers le document TextFile1.nzasm, et entrez le texte suivant:

#frequency 0    ; Ces deux lignes ne sont utiles que pour tester le code dans le Studio
#parameters $FF ; Faites varier cette valeur pour modifier l'intensité lumineuse

:Boucle
LD R0,0         ; Composante rouge toujours à 0
LD R1,0         ; Composante verte toujours à 0

LD R10,0        ; Index paramètre, 0 pour le premier octet
SRC R2,R10      ; Composante bleue chargée depuis les paramètres

LD R12,10       ; Délai de changement progressif des lumières

LD R11,0        ; Index du jeu de LED's, 0 pour le bas du lapin
LED R11,R12     ; Modifier les lumières du nez

LD R11,1        ; 1 pour les LED's à droite
LED R11,R12

LD R11,2        ; 2 au milieu
LED R11,R12

LD R11,3        ; 3 à gauche
LED R11,R12

LD R11,4        ; et enfin 4 pour le nez
LED R11,R12

WAIT 10         ; Attendre un peu...
BRA Boucle      ; et recommencer

Création de la structure C#

Basculez vers le document Class1.cs, puis modifiez l'entête pour inclure toutes les références qui nous seront utiles :

using System;
using System.IO;
using System.Text;
using System.Resources;

using NabazLab.Core.Language;
using NabazLab.Core.Modules;
using NabazLab.Core.Server;
using NabazLab.Core.Protocol;
using NabazLab.Core.Utilities;

Toutes les autres modifications seront des ajouts à la définition de la classe Class1. Ajoutez maintenant un identificateur aléatoire, qui identifiera à la fois notre programme et ses paramètres :

static int m_Identifier = (new Random()).Next();

Ajoutez ensuite une fonction vide, qui sera appelée à chaque requête du lapin et que nous complèterons plus tard :

static ProtocolResponse RepondAuLapin(ProtocolRequest Requete, IConfiguration Configuration)
{
}

Ajoutez finalement le point d'entrée du module qui sera appelé automatiquement par le Service grâce son attribut. Cette fonction enregistre notre fonction précédente comme un module disponible :

[ModuleInitializer]
static void Initialiser()
{
  DeviceHandler.Register("MonModule", "Mon premier module", RepondAuLapin);
}

Codage des réponses au lapin

Le code qui suit doit être ajouté dans la fonction RepondAuLapin(). Tout d'abord un petit bonjour du module :

Logger.Log(string.Format("\nRequete a {0}", DateTime.Now));

Commençons la tâche réelle par la création d'un tableau d'octets qui contiendra les paramètres du programme du lapin. Nous n'avons besoin que d'un octet, pour indiquer l'intensité du bleu.

byte[] Parametres = new byte[1];
Parametres[0] = (byte)(File.Exists("C:\\Bleu.txt") ? 255 : 0);

Puis nous construisons une réponse, en utilisant le support du protocole inclus dans NabazLab. Nous indiquons aussi au lapin de répéter ses requêtes aussi vite que possible :

ProtocolResponse Reponse = new ProtocolResponse();
Reponse.Append(new FrequencyFrame(0));
Reponse.Append(new ParametersFrame(m_Identifier, Parametres));

A ce point, la réponse est complète à condition que le lapin exécute déja notre code assembleur. Si ça n'est pas le cas il faut lui fournir ce code, assemblé en bytecode :

if (Requete.st == "00" || m_Identifier.ToString("X8") != Requete.tc)
{
  Logger.Log("Assemblage du code");
  string Code = Encoding.Default.GetString(Properties.Resources.TextFile1);
  Reponse.Append(new ProgramFrame(m_Identifier, 1, Assembler.Assemble(Code).ByteCode));
}

Et voilà, il suffit maintenant de retourner cette réponse au Service :

Logger.Log(string.Format("Reponse: {0}", Parametres[0]));
return Reponse;

Notre module est complet, prêt à être testé. Pressez maintenant F6 pour générer le fichier du module, MonModule.dll.

Le code C# complet

using System;                  // Indispensable
using System.IO;               // Pour le test d'existence du fichier
using System.Text;             // Pour la conversion des octets de la ressource assembleur en texte
using System.Resources;        // Pour l'accès aux ressources

using NabazLab.Core.Language;  // Pour l'assembleur, conversion du texte source en bytecode
using NabazLab.Core.Modules;   // Pour l'attribut ModuleInitializer
using NabazLab.Core.Server;    // Pour l'enregistrement du module
using NabazLab.Core.Protocol;  // Pour le création de la réponse
using NabazLab.Core.Utilities; // Pour le log

namespace MonModule
{
  public class Class1
  {
    // Ceci sera notre identificateur de programme et paramètres
    static int m_Identifier = (new Random()).Next();

    // Cette méthode sera appelée par le Service à chaque requête du lapin
    static ProtocolResponse RepondAuLapin(ProtocolRequest Requete, IConfiguration Configuration)
    {
      Logger.Log(string.Format("\nRequete a {0}", DateTime.Now));

      // Création des paramètres pour le programme assembleur
      byte[] Parametres = new byte[1];
      Parametres[0] = (byte)(File.Exists("C:\\Bleu.txt") ? 255 : 0);

      // Création de la réponse complète au lapin
      ProtocolResponse Reponse = new ProtocolResponse();
      Reponse.Append(new FrequencyFrame(0));
      Reponse.Append(new ParametersFrame(m_Identifier, Parametres));

      // Si le lapin n'exécute pas notre code, il faut recharger le programme de la machine virtuelle
      if (Requete.st == "00" || m_Identifier.ToString("X8") != Requete.tc)
      {
        Logger.Log("Assemblage du code");
        string Code = Encoding.Default.GetString(Properties.Resources.TextFile1);
        Reponse.Append(new ProgramFrame(m_Identifier, 1, Assembler.Assemble(Code).ByteCode));
      }

      // Tada !
      Logger.Log(string.Format("Reponse: {0}", Parametres[0]));
      return Reponse;
    }

    // Cette méthode est appelée automatiquement par le Service
    [ModuleInitializer]
    static void Initialiser()
    {
      // Nous enregistrons notre module auprès du Service
      DeviceHandler.Register("MonModule", "Mon premier module", RepondAuLapin);
    }
  }
}

Test du module

Le fichier module est prêt, il se trouve normalement dans "Mes Documents\Visual Studio 2005\Projects\MonModule\MonModule\bin\Release". Notez que la version du répertoire Debug n'est généralement pas à jour et ne devrait pas être utilisée.

Votre Nabaztag doit être configuré pour s'adresser à votre PC. Pour tester le module :

• Copiez le fichier MonModule.dll dans le répertoire contenant NabazLab,
• Arrêtez le Service ou le Studio si ils sont en cours d'activité,
• Faites un Drag&Drop de MonModule.dll sur NabazLab.Service.exe,
• Ouvrez l'interface web à http://localhost:8080,
• Si nécessaire sélectionnez votre module comme module actif.

Si vous utilisez une version complète de Visual Studio, la configuration suivante est plus pratique :

• Double-cliquez Properties dans l'Explorateur de solutions,
• Sélectionnez l'onglet Déboguer,
• Sélectionnez l'option Démarrer un programme externe,
• Utilisez le bouton Parcourir (...) pour sélectionner le fichier NabazLab.Service.exe,
• Dans le champs Arguments de ligne de commande entrez MonModule.dll,
• Vous pouvez maintenant démarrer directement votre module en mode Déboguage depuis Visual Studio

Pour les versions Express, un résultat similaire peut être obtenu en ajoutant à votre solutions les projets NabazLab.Core et NabazLab.Service.

Si vous souhaitez que le module soit chargé automatiquement par le Service en fonctionnement normal, renommez-le avec l'extension .nzmod.
Pour compiler directement avec cette extension, une procédure est proposée sur la page Service.

Conclusion

Ce module basique est réalisé en moins de cent lignes de code assembleur et C#.

L'infrastructure NabazLab permet de se concentrer sur de nouvelles fonctionnalités inédites pour le Nabaztag, et les possibilités d'utilisation ne sont limitées que par votre imagination.

Quelles que soit vos expériences, nous vous invitons à les partager sur le forum de NabazLab.
Et pourquoi pas, à contribuer en rejoignant le projet NabazLab...

En attendant, bon amusement avec le lapin !