1. Récuperer tout d'abord le logiciel leJOS_NXJ_0.85-Setup.exe.
2. Lancez ce programme pour l'installation :
   
   
3. Bien entendu, pour la suite, il est préférable d'avoir installé la JDK et même de préciser sa localisation en réglant la variable d'environnement PATH :
   
   
4. Si cette variable d'environnement est bien spécifiée, vous devez voir alors la boîte de dialogue suivante. Il s'agit juste ici de valider le début de l'installation :
   
   
5. Vous avez la possibilité de choisir votre répertoire de destination. Remarquez au passage la reconnaissance de laJDK installée :
   
   
6. Vous pouvez également choisir votre répertoire qui va stocker l'ensemble de vos projets :
   
   
7. Une fois que ces différents informations sont collectées, l'installation proprement dite peut débuter :
   
   
8. Si une ancienne version est déjà installée, on vous propose alors de la désinstaller :
   
   
9. Après confirmation, la désinstallation commence :
   
   
10. Losrque la désinstallation est terminée, vous en êtes averti :
    
    
11. La nouvelle version peut maintenant être installée :
    
    
    
    
    
    
12. Lorsque vous cliquez sur Finish, l'utilitaire qui permet de flasher le firmware NXJ se lance pour vous permettre de mettre à jour éventuellement cette nouvelle version. Si c'est la première fois ou si c'est pour une remise à jour, vous devez cliquer sur le bouton Start program.
    
    
13. Assurez-vous que le robot est disponible et surtout connecté :
    
    
14. On vous demande ensuite d'effacer la totalité de la mémoire du Robot NXT et donc de supprimer tous les fichiers déjà intégrés :
    
    
15. Encore une fois, on vous demande de bien connecter votre Robot NXT avec le cable USB.
    
    
16. Après validation, nous voyons la progression du transfert du firmware avec ses différents fichiers :
    
    
    
17. On vous demande éventuellement de flasher un autre Robot :
    

L'utilitaire qui permet de flasher le firmware se nomme nxjflashginst.bat qui se trouve dans le sous-répertoire bin du répertoire d'installation de leJOS NJX.
.

1. nxjc
2. nxjlink
3. nxjupload
4. nxj

Noter que normalement vous avez juste besoin des commandes nxjc ainsi que njx, sachant que cette dernière est l'équivalent de nxjlink suivi de nxjupload.
.

Compilation

nxjc <fichiers java>

Exemple :

nxjc Exemple.java

nxjc appelle en réalité javac avec les paramètres suivants :

• -bootclasspath <path vers classes.jar>
• <fichiers java>

-bootclasspath est proposé parce que leJOS n'utilise pas les classes standard du paquet java.lang mais utilise ses propres versions placées dans l'archive classes.jar.

Edition de lien

nxjlink [-v|--verbose][-g|--debug][-a|--all] classe-principale -o <binary>

Exemple :

nxjlink -v Exemple -o Exemple.nxj

Sur cet exemple l'éditeur de lien fusionne la classe principale avec d'autres classes annexes présentes dans le projet, notamment celles qui figurent dans l'archive classes.jar de leJOS pour produire un fichier binaire NXJ représentant le programme qui va être déployé et exécuter directement sur la machine.

1. -v or --verbose : cette option donne la liste en temps réel, d'une part des noms des classes présentes dans le projet avec même la signature de chacune des méthodes internes. Cette option peut être très utile en phase de débuggage.
2. -g or --debug : cette option lance un moniteur de débuggage intégré au programme qui va être exécuté. Cela permet notamment au programme d'être interrompu dans sa phase d'exécution (appui sur les touches Entrée+Echappe).
3. -a or --all : Par défaut, l'éditeur de lien efface les méthodes qui ne sont pas utilisées. Avec cette option, vous demandez à inclure systématiquement toutes les méthodes qu'elles soient utilisées ou non. Normalement, ce n'est jamais nécessaire.
4. -h or --help : permet de connaître l'ensemble des options disponibles dans cette commande.

Déploiement de l'application

nxjupload [-b|--bluetooth][-u|--usb][-d|--address adresse][-n|--name nom][-r|--run] <binary>

Exemple :

nxjupload Exemple.nxj

Permet de transférer le fichier binaire (.nxj). Par défaut, l'USB est choisi en premier et ensuite le Bluetooth. Si l'option --bluetooth est spécifiée, seulement la connexion Bluetooth est sollicité. Si l'option --usb est choisie, c'est cette fois-ci la connexion USB qui est seulement utilisé.

Lorsque le Bluetooth est utilisé, une recherche du pilote Bluetooth est activée, uniquement si --address est positionné, et que la connexion avec la bonne adresse est possible.

1. -d or --address : Lorsque le Bluetooth est utilisé, une recherche du pilote Bluetooth est activée, uniquement si --address est positionné, et que la connexion avec la bonne adresse est possible.
2. -n or --name : ce paramètre permet de limiter la recherche sur le NXT avec le nom donné. Si ce nom n'est pas spécifié, nxjupload essaie de se connecter sur chacun des robot NXT qu'il trouve et déploie le program sur le premier qui s'est correctement connecté.
3. -r or --run : lorsque cette option est spécifiée, le programme est automatiquement lancé sur le robot dès qu'il a été déployé.

Commande générale

nxj [option] classe-principale

Exemple :

nxj -r Exemple

La commande nxj réalise l'édition de lien et le déploiement en une seule fois. C'est donc équivalent à la commande njxlink suivie de nxjupload. N'importe quelle options de nxjlink et de nxjupload peut alors être utilisée.

Ainsi, dans l'exemple ci-dessus, grâce à l'option -r, nous demandons que le programme démarre instantanément dès qu'il se trouve dans le robot.
.

Programme sur PC qui pilote le robot à distance

Nous pouvons avoir besoin de développer un programme sur PC qui pilote le robot à distance. Cette fois-ci la notion de déploiement n'existe plus. Par ailleurs, nous n'avons pas besoin des mêmes librairies (pccomm.jar au lieu de classes.jar). Pour finir, comme le PC n'est pas une informatique embarquée, les critères de compilation et d'exécution sont différents. Du coup, il existe deux outils spécifiques pour réaliser la compilation et l'exécution dans le cas d'un programme qui gère le robot tout en restant sur le PC :

1. nxjpcc : compilateur.
2. nxjpc : lance le programme.

nxjpcc Exemple.java // compilation
nxjpc Exemple // exécution

package robot;

import lejos.nxt.*;

public class TestAfficheur {
   public static void main(String[] args)  throws Exception {
       LCD.drawString("Mem libre:", 0, 0);
       LCD.drawInt((int) System.getRuntime().freeMemory(), 6, 10, 0);
       Thread.sleep(5000);
   }
}

Nous avons découvert préalablement que nous pouvions également écrire sur l'afficheur à l'aide de la méthode toute simple System.out.println(). Le problème, c'est que dans ce cas là, l'affichage se décale automatiquement lorsque toutes les lignes sont déjà complètes, et nous perdons ainsi un certain nombre d'informations.

package robot;

import javax.microedition.lcdui.Graphics; // Attention, il faut importer le contexte graphique correspondant à l'afficheur du robot

public class LCDGraphique {
   public static void main(String[] args)  throws Exception {
       Graphics g = new Graphics();
       g.drawLine(5, 5, 60, 60);
       g.drawRect(62, 10, 25, 35);
       g.drawRoundRect(62, 10, 25, 35, 25, 35);
       g.drawString("Bienvenue", 15, 30, true);
       Thread.sleep(5000);
   }
}

package robot;

import lejos.nxt.*;

public class Boutons {
   public static void main(String[] args)  throws Exception {
       LCD.drawString("Boutons ?", 0, 0);
       while (true) {
           if (Button.ENTER.isPressed()) LCD.drawString("Validation", 0, 0);
           if (Button.LEFT.isPressed())    LCD.drawString("Gauche    ", 0, 0);
           if (Button.RIGHT.isPressed()) LCD.drawString("Droite      ", 0, 0);
           if (Button.ESCAPE.isPressed()) break; 
       }
       LCD.drawString("Quitter  ?  ", 0, 0);
       Button.ENTER.waitForPressAndRelease();
   }
}

package robot;

import lejos.nxt.*;

public class JouerSons {
    private static final int[] notes = {2349, 115, 0, 5, 1760, 165, 0, 35};

   public static void main(String[] args) {
       for (int i=0; i<notes.length; i+=2) {
           int temps = notes[i+1]*10;
           int note = notes[i];
           if (note != 0) Sound.playTone(note, temps);
           Sound.pause(temps);
       }
       Sound.beepSequence();
       Sound.beepSequenceUp();
   }
}

package robot;

import lejos.nxt.*;

public class FinDeCourse {
   public static void main(String[] args) throws InterruptedException {
       TouchSensor capteur = new TouchSensor(SensorPort.S3);
       LCD.drawString("Attente !", 0, 0);
       while (!capteur.isPressed());
       LCD.drawString("Capteur Actif", 0, 0);
       Thread.sleep(5000);
   }
}

package robot;

import lejos.nxt.*;

public class CapteurUltraSon  {
   
   public static void main(String[] args) {
       UltrasonicSensor capteur = new UltrasonicSensor(SensorPort.S1);
       
       LCD.clear();
       LCD.drawString(capteur.getVersion(), 0, 0);
       LCD.drawString(capteur.getProductID(), 0, 1);
       LCD.drawString(capteur.getSensorType(), 0, 2);
       LCD.drawString("Distance :    cm", 0, 3);
       while (!Button.ESCAPE.isPressed())    LCD.drawInt(capteur.getDistance(), 3, 10, 3);

   }
}

Piloter les deux moteurs avec des méthodes basiques

1. Faire tourner les deux moteurs du robot vers l'avant pendant une seconde.
2. Faire tourner les deux moteurs du robot vers l'arrière pendant une seconde.
3. Arrêter les deux moteurs.

package robot;

import lejos.nxt.*;

public class Moteurs  {
   
   public static void main(String[] args) {
       Motor gauche = new Motor(MotorPort.C);
       Motor.A.forward();
       gauche.forward();
       Sound.pause(1000);
       Motor.A.backward();
       gauche.reverseDirection();
       Sound.pause(1000);
       Motor.A.stop();
       gauche.stop();
   }
}

Utilisation du tachymètre

Les moteurs du Robot NXT sont construits avec un tachymètre intégré qui permet de contrôler en temps réel la valeur de l'angle en cours, exprimé en degré, de l'axe du moteur.

1. Faire tourner le moteur de droite du robot vers l'avant.
2. Attendre jusqu'à ce que l'axe du moteurs ait fait un tour complet.
3. Arrêter le moteur.
4. Attendre que le moteur se soit arrêté.
5. Afficher la valeur du tachymètre sur l'afficheur du robot.
6. Changer la vitesse de rotation du moteur à une valeur de 200 (360 par défaut - un tour complet par seconde).
7. Remettre à zéro le tachymètre.
8. Répéter une autre fois les étapes de 1 à 5.

package robot;

import lejos.nxt.*;

public class Moteurs  {
   private static Motor droite = Motor.A;
   
   public static void main(String[] args) {
        rotate360Degres();
        droite.resetTachoCount();
        droite.setSpeed(200);
        rotate360Degres();
        LCD.drawString("Quitter ?", 0, 0);
        Button.waitForPress();
   }

   public static void rotate360Degres() {
        droite.forward();
        int nombre = 0;
        while (nombre < 360) nombre = droite.getTachoCount();
        droite.flt();
        LCD.drawInt(nombre , 0, 1);
        while(droite.getRotationSpeed()>0);
        LCD.drawInt(droite.getTachoCount(), 7, 1);
   }
}

Contrôle la position de l'axe du moteur avec précision

La classe Motor implémente un thread de régulation qui fonctionne constamment. Comme nous l'avons déjà évoqué, cette classe utilise deux principes, dont l'un d'entre eux permet d'arrêter le moteur suivant un angle bien déterminé.

1. Faire tourner le moteur de droite du robot un tour complet.
2. Afficher la valeur du tachymètre sur l'afficheur du robot.
3. Faire tourner le moteur pour revenir à l'origine (angle = 0);
4. Changer la vitesse de rotation du moteur à une valeur de 200 (360 par défaut - un tour complet par seconde).
5. Répéter une autre fois les étapes de 1 à 3.

package robot;

import lejos.nxt.*;

public class Moteurs  {
    private Motor droite = Motor.A;
   
    public static void main(String args[]) {
        LCD.drawString("Rotation", 0, 0);
        Moteurs robot = new Moteurs();
        robot.lancer();
    }

    private void lancer() {
        rotate360Degres();
        droite.setSpeed(200);
        rotate360Degres();
    }

    private void rotate360Degres() {
        droite.rotate(360);
        LCD.drawInt(droite.getTachoCount(), 4, 0, 1);
        droite.rotateTo(0);
        LCD.drawInt(droite.getTachoCount(), 4, 0, 2);
    }
}

Arrêter la rotation du moteur

Quelquefois, vous pouvez avoir besoin d'arrêter le moteur en cours de route avant que ce dernier n'atteigne l'angle requis. Nous allons voir comment procéder.

1. Faire tourner le moteur de droite du robot deux tours complets.
2. Tant que le moteur tourne, affichez la valeur indiquée par le tachymètre.
3. Lorsqu'un des boutons est appuyé, arrêter immédiatement le moteur.
4. Lorsque le moteur est complètement arrêté, afficher la valeur du tachymètre.
5. Attendre l'action sur un bouton quelconque.
6. Faire tourner le moteur pour revenir à l'origine (angle = 0);
7. Répéter une autre fois les étapes de 2 à 5.

package robot;

import lejos.nxt.*;

public class Moteurs  {
    private Motor droite = Motor.A;
   
    private void lancer() {
        System.out.println("Interrupt  \n rotation");
        Sound.twoBeeps();
        Button.waitForPress();
        droite.rotate(720, true);
        visualiserRotation(1);
        droite.rotateTo(0, true);
        visualiserRotation(1);
    }

     public void visualiserRotation(int ligne) {
        while(droite.isMoving()) {
            LCD.drawInt(droite.getTachoCount(), 4, 0, ligne);
            if(Button.readButtons()>0) droite.stop();
        }
        while(droite.getRotationSpeed()>0);
        LCD.drawInt(droite.getTachoCount(), 4, 8, ligne);
        Button.waitForPress();
    }

    public static void main(String[] args) {
        new Moteurs().lancer();
    }
}

Remarquez qu'en fonctionnement, si nous appuyons sur un bouton de la brique avant que la rotation du moteur soit accomplie, le moteur s'arrête bien instentanément sans faire le tour complet. Autrement, la méthode stop() n'a aucun effet.

Gestion événementielle pour contrôler l'appui sur un des boutons de la brique du Robot - ButtonListener

void buttonPressed(Button bouton)

Cette méthode est sollicité dès que l'utilisateur appui sur le bouton désigné.

void buttonReleased(Button bouton)

Cette méthode est sollicité dès que l'utilisateur relâche le bouton désigné.

Gestion événementielle pour contrôler le changement de valeur d'un des ports d'entrée du Robot - ButtonListener

void stateChanged(SensorPort portEntrée, int ancienneValeur, int nouvelleValeur)

Cette méthode est sollicité dès que le port spécifié change de valeur, donc dès que le capteur correspondant enregistre une évolution.

Petit test qui permet d'afficher sur l'écran du LCD les événements produit par le bouton de validation et le capteur de fin de course

package robot;

import lejos.nxt.*;

public class Evenements implements ButtonListener, SensorPortListener {
    private Evenements() {
       Button.ENTER.addButtonListener(this);
       SensorPort.S3.addSensorPortListener(this);
    }

    public static void main(String[] args) {
        new Evenements();
        Button.ESCAPE.waitForPressAndRelease();
    }

    public void buttonPressed(Button button) {
        LCD.drawString("Validation...", 0, 0);
    }

    public void buttonReleased(Button button) {
        LCD.clear();
    }

    public void stateChanged(SensorPort sp, int ancien, int nouveau) {
        LCD.drawString("Capteur :", 0, 1);
        LCD.drawInt(nouveau, 4, 9, 1);  // 181 (actif)  -- 1023 (relâché)
    }
}

NXTConnection connexion = Bluetooth.waitForConnection();
ou
NXTConnection connexion = USB.waitForConnection();

Méthodes utiles de l'interface lejos.nxt.comm.NXTConnection

void openInputStream()

Renvoie un flux d'entrée représentant un flux d'octets non interprétés.

void openOutputStream()

Renvoie un flux de sortie représentant un flux d'octets non interprétés.

void openDataInputStream()

Renvoie un flux d'entrée de type DataInputStream qui permet de récupérer des données primitives comme les entiers, les réels, etc.

void openDataOutputStream()

Renvoie un flux de sortie de type DataOutputStream qui permet d'envoyer des données primitives comme les entiers, les réels, etc.

void close()

Clôture la communication.

Nous connaissons bien les classes DataInputStream et DataOutputStream avec lesquelles nous pouvons utiliser les méthodes de lecture et d'écriture, comme readInt(), readDouble(), etc. respectivement avec writeInt(), writeDouble(), etc.

NXTConnector connexion = new NXTConnector();
connexion.connectTo(1234); // pin par défaut du robot NXT

Méthodes utiles de la classe lejos.pc.comm.NXTConnector

void getInputStream()

Renvoie un flux d'entrée représentant un flux d'octets non interprétés.

void getOutputStream()

Renvoie un flux de sortie représentant un flux d'octets non interprétés.

void getDataIn()

Renvoie un flux d'entrée de type DataInputStream qui permet de récupérer des données primitives comme les entiers, les réels, etc.

void openDataOut()

Renvoie un flux de sortie de type DataOutputStream qui permet d'envoyer des données primitives comme les entiers, les réels, etc.

void close()

Clôture la communication.

void connectTo()

Etablie la connexion avec le robot NXT au dessus de tout protocole en mode paquets.

void connectTo(int mode)

Etablie la connexion avec le robot NXT en spécifiant le mode souhaité connect(1234).

void connectTo(String url)

Etablie la connexion suivant l'URL proposée connect("usb://").

void connectTo(String url, int mode)

Etablie la connexion suivant l'URL proposée et dans le mode souhaité.

Pensez bien à utiliser les outils de compilation et d'exécution, respectivement njxpcc et njxpc.
.

Emetteur - Communiquer avec le robot depuis le PC

package robot;

import java.io.*;
import lejos.pc.comm.*;

public class Emetteur {
   public static void main(String[] args) throws NXTCommException {
       NXTConnector  connexion = new NXTConnector();
       if (connexion.connectTo(1234)) {  // Code PIN du Robot NXT
           DataOutputStream requete = connexion.getDataOut();
           DataInputStream reponse = connexion.getDataIn();
            try {
                requete.writeInt(15);
                requete.flush();
                System.out.println("NXT : "+reponse.readInt());
                requete.close();
                reponse.close();
                connexion.close();
                System.out.println("Arret du programme...");
            }
            catch (IOException ex) {
                System.err.println("Problème pour envoyer les valeurs");
            }
       }
       else System.err.println("Aucune connexion Bluetooth");
   }
}

Récepteur - Attente de connexion du Robot et traitement de l'information le cas échéant

package robot;

import java.io.*;
import lejos.nxt.*;
import lejos.nxt.comm.*;

public class Recepteur implements ButtonListener {
   public Recepteur() {
       Button.ESCAPE.addButtonListener(this);
       LCD.drawString("Attente...", 0, 0);
       NXTConnection connexion = Bluetooth.waitForConnection();
       DataInputStream requete = connexion.openDataInputStream();
       DataOutputStream reponse = connexion.openDataOutputStream();
       LCD.drawString("Connexion", 0, 0);
        try {
            int nombre = requete.readInt();
            LCD.drawInt(nombre, 0, 1);
            reponse.writeInt(nombre*2);
            reponse.flush();
            requete.close();
            reponse.close();
            connexion.close();
        } 
        catch (IOException ex) {
            LCD.drawString("Probleme", 0, 3);
        }
       Sound.pause(4000);
   }
   
   public static void main(String[] args) { 
       new Recepteur();
   }

    public void buttonPressed(Button button) {
       System.exit(0); 
    }

    public void buttonReleased(Button button) {
        
    }
}

1. La gestion des boutons doit se faire de façon événementielle.
2. Vous allez mettre en oeuvre deux classes, Piloter la classe principale de l'application et la classe Robot qui représente les fonctionnalités du robot.
3. La classe Robot possède deux moteurs, droite et gauche, peut avancer(), tournerADroite() et tournerAGauche().

Cas d'utilisation

Diagramme de classe

Diagramme de séquence

Correction : Sources du projet.
.

1. La gestion des boutons doit toujours se faire de façon événementielle.
2. Vous allez conserver les deux classes, Piloter la classe principale de l'application et la classe Robot qui représente les fonctionnalités du robot.
3. La classe Robot possède deux moteurs, droite et gauche, peut avancer(), arrêter(), tournerADroite() et tournerAGauche().

Cas d'utilisation

Diagramme de classes

Diagramme de séquence

Correction : Sources du projet.
.

1. La gestion du bouton de validation se fait de façon événementielle.
2. La classe Robot possède deux attributs supplémentaires qui correspondent aux deux capteurs ultrason et finDeCourse. Nous rajoutons également des méthodes qui vont correspondre au fonctionnement attendu savoir, une nouvelle méthode avancer(vitesse), avec aussi les méthodes avancerPrudemment() et reculerLegerement().

Cas d'utilisation

Diagramme de classes

Diagramme de séquence

Correction : Sources du projet.
.

1. La gestion du bouton de validation se fait de façon événementielle.
2. Vous devez changer le comportement de la méthode avancerPrudemment() de la classe Robot afin de correspondre aux nouvelles fonctionnalités. Par ailleurs, vous devez implémenter une nouvelle méthode qui se nomme demiTour().

Cas d'utilisation

Diagramme de classes

Diagramme de séquence

Correction : Sources du projet.
.

1. La gestion des trois boutons se fait de façon événementielle.
2. Vous allez conserver les deux classes, Piloter la classe principale de l'application et la classe Robot qui représente les fonctionnalités du robot.
3. Vous pouvez vous servir des attributs et des méthodes que vous avez mis en oeuvre dans les TPs précédents. Pour les méthodes, il faudra peut-être en modifier le contenu.
4. En tout cas, l'avance du robot doit se réaliser dans une tâche concurrente pour prendre en compte toutes les actions souhaitées par l'utilisateur.

Cas d'utilisation

Diagramme de classes

Diagramme de séquence complet

Correction : Sources du projet.
.

1. Cette fois-ci, nous avons deux composants logiciels, un côté PC et un autre sur l'informatique embarquée du robot.
2. Côté robot, pour quitter le programme définitivement, une gestion événementielle est prévue avec le bouton d'annulation.
3. Toujours côté robot, vous allez conserver les deux classes, Piloter la classe principale de l'application et la classe Robot qui représente les fonctionnalités du robot.
4. Aucune modification n'ait à apporter sur cette denière classe Robot.
5. Par contre, côté PC, vous devez implémenter la classe Distante qui permettra, au travers d'une IHM succinte, de commander le robot par Bluetooth.

Cas d'utilisation

Diagramme de composants

Diagramme de classes

Diagramme de séquence

Correction : Sources du projet.
.

La première valeur hexadécimale de votre requête bluetooth indique la taille de la réponse. Si vous ne souhaitez pas de réponse, il suffit de placer le code hexadécimal 00.

Cette application fait également office de service qui permet de récupérer la requête bluetooth souhaitée, sous forme également de chaîne de caractères avec la structure que nous venons de voir, et de la soumettre instantanément au robot actuellement connecté. Là aussi, si une réponse est démandée, une chaîne de caractères est renvoyée au client dans le même format.

Vous avez ci-dessous le code Java correspondant. Attention toutefois, vous devez passer par la commande nxjpc afin de permettre l'exécution d'une application sur le PC qui pilote le robot à distance nxjpc nxtbluetooth/NXTBluetooth.

nxtbluetooth.NXTBluetooth.java

package nxtbluetooth;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.io.*;
import java.net.*;
import java.util.Scanner;
import lejos.pc.comm.*;
import javax.swing.*;

public class NXTBluetooth extends JFrame {
    private JTextArea notification= new JTextArea("Connectez-vous !\n", 20, 50);
    private JTextField iRobot = new JTextField("00:16:53:0C:BC:BF");
    private JTextField iRequete = new JTextField("03 03 F4 01 F4 01");
    private JToolBar boutons = new JToolBar();
    private NXTComm bluetooth;
    private boolean ouvert = false;
    private String retour;
    private ServerSocket service;

    private NXTBluetooth() {
        setTitle("Robot NXT");
        notification.setBackground(Color.YELLOW);
        iRobot.setBackground(Color.RED);
        iRequete.setBackground(Color.ORANGE);
        add(boutons, BorderLayout.NORTH);
        boutons.add(iRobot);
        boutons.add(new AbstractAction("Bluetooth") {
            @Override
            public void actionPerformed(ActionEvent e) {
                connexion();
            }
        });
        boutons.add(new AbstractAction("Stop") {
            @Override
            public void actionPerformed(ActionEvent e) {
                deconnexion();
            }
        });
        boutons.add(iRequete);
        boutons.add(new AbstractAction("Soumettre") {
            @Override
            public void actionPerformed(ActionEvent e) {
                commande();
            }
        });
        boutons.add(new AbstractAction("Effacer") {
            @Override
            public void actionPerformed(ActionEvent e) {
                notification.setText("");
            }
        });        
        add(new JScrollPane(notification));
        pack();
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);
    }
    
    private void connexion() {
        try {
            if (!ouvert) {
                NXTInfo infoBluetooth = new NXTInfo(NXTCommFactory.BLUETOOTH, "NXT", iRobot.getText());
                bluetooth = NXTCommFactory.createNXTComm(NXTCommFactory.BLUETOOTH);      
                ouvert = bluetooth.open(infoBluetooth);
                if (ouvert) { 
                    notification.append("Communication avec le robot "+iRobot.getText());
                    new Thread(new Serveur()).start();
                }
                else notification.append("ATTENTION problème avec "+iRobot.getText());
                notification.append("\n");    
            }
        } 
        catch (NXTCommException ex) {
            notification.append("ATTENTION probleme de BLUETOOTH...\n");
        }
    }
    
    private void deconnexion() {
       if (ouvert) 
       try {
          bluetooth.close();
          ouvert = false;
          notification.append("BLUETOOTH interrompu...\n");
          if (service!=null) {
              service.close();
              notification.append("Service (5588) interrompu...\n");
          }
       } 
       catch (IOException ex) { }     
    }
    
    private void commande() {
        try {
            if (ouvert) {
                String[] hexa = iRequete.getText().split("\\s");
                byte[] octets = new byte[hexa.length];
                for (int i=0; i<octets.length; i++) octets[i] = (byte) Integer.parseInt(hexa[i], 16);  
                byte nombreRetour = octets[0];    
                if (nombreRetour>0) {
                    octets[0] = 0;
                    byte[] reponse = bluetooth.sendRequest(octets, nombreRetour);
                    notification.append("Commande : ("+iRequete.getText()+") -- Retour : (");
                    StringBuilder chaine = new StringBuilder();
                    for (byte octet : reponse) chaine.append(octet+" ");
                    chaine.deleteCharAt(chaine.length()-1);
                    retour = chaine.toString();
                    notification.append(retour+")\n");
                }
                else {
                    octets[0] = (byte) 0x80;
                    bluetooth.sendRequest(octets, 0);
                    retour = "";
                    notification.append("Commande : ("+iRequete.getText()+")\n");
                }
            }
            else notification.append("ROBOT non connecté...\n");
        } 
        catch (Exception ex) {
            notification.append("ATTENTION : Commande non valide pour le ROBOT\n");
        }
    }

    private class Serveur implements Runnable {
        @Override
        public void run() {
            try {
                service = new ServerSocket(5588);
                notification.append("Service (5588) en action...\n");
                while (ouvert) {
                   notification.append("Attente d'un nouveau client...\n");
                   Socket client = service.accept();
                   String adresse = client.getInetAddress().getHostAddress();
                   notification.append("----------------------------- Connexion : "+adresse+" : \n");
                   Scanner requete = new Scanner(client.getInputStream());
                   PrintWriter reponse = new PrintWriter(client.getOutputStream(), true);
                   boolean fin = false;
                   do {
                       String soumission = requete.nextLine();
                       fin = soumission.equalsIgnoreCase("fin");
                       if (!fin) {
                           iRequete.setText(soumission);
                           commande();
                           reponse.println(retour);
                       }
                   } 
                   while(!fin);
                   client.close();
                   notification.append("----------------------------- Deconnexion\n");
                }
            }
            catch (IOException ex) {
                notification.append("Perte de la communication...\n");
            }            
        }        
    }
    
    public static void main(String[] args) throws Exception {
        new NXTBluetooth();
    }
}