Petit guide de Squawk sur SunSpot

Transcription

Petit guide de Squawk sur SunSpot
1. Création d'un programme
Les programmes pour les capteurs sont placés dans un fichier d'archive .jar. Ce fichier contient toutes les
classes compilées constituant l'application ainsi qu'un manifeste (fichier texte) qui indique quelle classe contient
le programme à lancer.
La classe contenant le programme à lancer doit se conformer à un modèle qui est fourni par la classe MIDlet.
On écrit donc une classe qui hérite de MIDled et on surcharge les méthodes :
protected void startApp() throws MIDletStateChangeException
protected void pauseApp()
protected void destroyApp(boolean unconditional) throws MIDletStateChangeException
- La première contient le corps du programme, l'exception de classe MIDletStateChangeException peut être
levée par le programme s'il ne peut pas démarrer.
- La deuxième n'est pas utilisée pour le moment par Squawk.
- La dernière est appelée lorsque le programme est terminé, elle contient tout ce qui doit être fait dans ce cas
si nécessaire. Le paramètre est true si la destruction est inconditionnelle, dans ce cas le programme
doit se terminer. Lorsque ce paramètre est false cela signifie que Squawk accepte que le programme
ne se termine pas, dans ce cas il lui suffit de lever une exception de classe
MIDletStateChangeException pour pouvoir continuer.
La méthode notifyDestroyed() n'est pas surchargée, elle peut être appelée pour terminer le programme. Elle ne
provoque pas l'exécution de destroyApp.
Un programme pour capteur a donc l'allure suivante :
/* bibliothèques incluses */
package org.sunspotworld;
import com.sun.spot.peripheral.Spot;
import com.sun.spot.sensorboard.EDemoBoard;
import com.sun.spot.sensorboard.peripheral.ISwitch;
import com.sun.spot.sensorboard.peripheral.ITriColorLED;
import com.sun.spot.peripheral.radio.IRadioPolicyManager;
import com.sun.spot.io.j2me.radiostream.*;
import com.sun.spot.io.j2me.radiogram.*;
import com.sun.spot.util.*;
import java.io.*;
import javax.microedition.io.*;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
/**
* La méthode startApp est appelée par la machine virtuelle pour lancer l'application.
*
* Le manifeste spécifie cette classe comme MIDlet-1, càd comme application à lancer.
*/
public class MonApplication extends MIDlet {
// propriétés de la Midlet par exemple, pour utiliser les LEDs :
private ITriColorLED [ ] leds; // par exemple ici les 8 leds tricolores
protected void startApp() throws MIDletStateChangeException {
// corps du programme
notifyDestroyed();
// fin de la MIDlet (si elle se termine)
}
Petit guide de Squawk
M. Dalmau , IUT de Bayonne-Pays basque
1
protected void pauseApp() {
// Non utilise => laissé vide
}
}
protected void destroyApp(boolean unconditional) throws MIDletStateChangeException {
// Choses à faire quand la Midlet se termine
}
// fin de la classe
Le logiciel Netbeans permet de créer des projets conforme à ce modèle, il génère en outre le fichier manifeste et
le fichier d'archive prêt à être téléchargé sur le capteur.
2. Utilisation des périphériques
La classe de base permettant l'accès aux périphériques est la classe : EDemoBoard. Elle offre une méthode
getInstance qui fournit un objet de classe EDemoBoard à partir duquel on peut récupérer des objets
correspondant aux divers périphériques du capteur SunSpot. On procède donc comme suit :
ClasseDePériherique nomDu Périphérique = EDemoBoard.getInstance().getxxx();
Les méthodes getxxx et les classes de périphériques sont décrites dans ce qui suit :
2.1 LEDs
Le capteur SunSpot possède une rangée de 8 leds multicolores dont on peut choisir la couleur et que l'on peut
allumer et éteindre.
Bibliothèques à inclure : com.sun.spot.sensorboard.EDemoBoard,
com.sun.spot.sensorboard.peripheral.ITriColorLED
Classe de périphérique : ITriColorLED
Méthode getxxx : getLEDs() qui retourne un tableau de 8 objets (un par LED) chacun de classe ITriColorLED.
On fait donc, par exemple :
ITriColorLED ledUne = EDemoBoard.getInstance().getLEDs() [0];
puis on utilise l'objet ledUne qui correspond à la première LED.
Principales méthodes de ITriColorLED :
int getBlue()
int getGreen()
int getRed()
void setRGB(int rouge, int vert, int bleu)
void setOn()
void setOff()
boolean isOn()
boolean isOff()
retourne la composante bleue de la LED
retourne la composante verte de la LED
retourne la composante rouge de la LED
définit la couleur de la LED
allume la LED
éteint la LED
retourne true si la LED est allumée
retourne true si la LED est éteinte
Remarque : les couleurs sont définies par 3 composantes (rouge, vert et bleu) qui sont des entiers entre 0 et 255.
2.2 Interrupteurs
Le capteur SunSpot possède deux petits interrupteurs accessibles sur sa face avant.
Bibliothèques à inclure : com.sun.spot.sensorboard.EDemoBoard, com.sun.spot.sensorboard.peripheral.ISwitch,
com.sun.spot.sensorboard.peripheral.ISwitchListener
Classe de périphérique : ISwitch
Méthode getxxx : getSwitches() qui retourne un tableau de 2 objets (un par interrupteur) chacun de classe
ISwitch.
On fait donc, par exemple :
ISwitch bouton1 = EDemoBoard.getInstance().getSwitches() [EDemoBoard.SW1];
puis on utilise l'objet bouton1 qui correspond à l'interrupteur de gauche (utiliser EDemoBoard.SW2 en indice de
tableau pour obtenir l'autre interrupteur).
2
Principales méthodes de ISwitch :
boolean isClosed()
retourne true si l'interrupteur est fermé
boolean isOpen()
retourne true si l'interrupteur est ouvert
void waitForChange()
attend que l'interrupteur ait été actionné
void addISwitchListener(ISwitchListener ecouteur) permet d'associer un écouteur d'événements à
l'interrupteur. C'est objet d'une classe, à écrire, implémentant l'interface ISwitchListener dans
laquelle on a surchargé les 2 méthodes suivantes (l'une peut être vide) :
void switchPressed (ISwitch bouton) appelée quand l'interrupteur est appuyé. Le paramètre
est l'interrupteur.
void switchReleased (ISwitch bouton) appelée quand l'interrupteur est lâché. Le paramètre est
l'interrupteur.
void removeISwitchListener(ISwitchListener ecouteur)
pour enlever un écouteur d'événements
2.3 Accéléromètre
Le capteur SunSpot contient un accéléromètre 3 axes capable de mesurer les accélérations et les inclinaisons
selon les axes X, Y et Z.
Bibliothèques à inclure : com.sun.spot.sensorboard.EDemoBoard ,
com.sun.spot.sensorboard.peripheral.IAccelerometer3D ,
com.sun.spot.sensorboard.peripheral.IAccelerometer3DThresholdListener
Classe de périphérique : IAccelerometer3D
Méthode getxxx : getAccelerometer() qui retourne un objet de classe IAccelerometer3D.
On fait donc :
IAccelerometer3D accelerometre = EDemoBoard.getInstance().getAccelerometer();
puis on utilise l'objet accelerometre qui correspond à l'accéléromètre à 3 axes.
Principales méthodes de IAccelerometer3D :
double getAccelX()
renvoie l'accélération en G selon l'axe X (de -2 à 2)
double getAccelY()
renvoie l'accélération en G selon l'axe Y (de -2 à 2)
double getAccelZ()
renvoie l'accélération en G selon l'axe Z (de -2 à 2)
double getAccel()
renvoie l'accélération en G totale
double getTiltX()
renvoie l'inclinaison selon l'axe X en radians (de –π/2 à π/2)
double getTiltY()
renvoie l'inclinaison selon l'axe Y en radians (de –π/2 à π/2)
double getTiltZ()
renvoie l'inclinaison selon l'axe Z en radians (de –π/2 à π/2)
void setRestOffsets()
mémorise les valeurs actuelles selon les 3 axes. Cette méthode est
utilisée lorsque l'on veut définir des seuils relatifs (voir méthode
setThresholds).
double getRelativeAccelX()
renvoie l'accélération relative en G selon l'axe X (voir méthode
setRestOffsets) .
double getRelativeAccelY()
renvoie l'accélération relative en G selon l'axe Y (voir méthode
setRestOffsets) .
double getRelativeAccelZ()
renvoie l'accélération relative en G selon l'axe Z (voir méthode
setRestOffsets) .
void setThresholds(int axe, double bas, double haut, boolean relatif)
permet de définir des seuils haut
et bas. Le paramètre axe indique l'axe sur lequel un seuil est défini, il
vaut (IAccelerometer3D.X_AXIS ou IAccelerometer3D.Y_AXIS ou
IAccelerometer3D.Z_AXIS). Le paramètre relatif est un booléen qui
vaut true si le seuil définit est relatif et false s'il est absolu (voir
méthode setRestOffsets).
void enableThresholdEvents(int axe, boolean actif) valide ou invalide la levée d'événements lors d'un
dépassement de seuils selon l'axe précisé. Le paramètre axe indique
l'axe sur lequel un seuil est défini, il vaut (IAccelerometer3D.X_AXIS
ou IAccelerometer3D.Y_AXIS ou IAccelerometer3D.Z_AXIS). Le
paramètre 'actif' est un booléen qui vaut true si les événements doivent
être levés et false sinon.
void addIAccelerometer3DThresholdListener(IAccelerometer3DThresholdListener ecouteur)
permet d'associer un écouteur d'événements à l'accéléromètre. C'est un objet d'une classe, à écrire,
implémentant l'interface IAccelerometer3DThresholdListener dans laquelle on a surchargé les 2
méthodes suivantes (l'une peut être vide) :
3
void thresholdExceeded(IAccelerometer3D accel, int axe, double val, boolean relatif)
appelée quand l'un des seuils définis est dépassé. Le paramètre axe indique l'axe sur
lequel un seuil a été dépassé, il vaut (IAccelerometer3D.X_AXIS ou
IAccelerometer3D.Y_AXIS ou IAccelerometer3D.Z_AXIS). Le paramètre relatif est un
booléen qui vaut true si le dépassement est relatif et false s'il est absolu.
void thresholdChanged(IAccelerometer3D accel, int axe, double bas, double haut,
boolean relatif)
appelée quand les seuils définis sont modifiés. Le paramètre axe indique l'axe sur lequel
les seuils ont été modifiés, il vaut (IAccelerometer3D.X_AXIS ou
IAccelerometer3D.Y_AXIS ou IAccelerometer3D.Z_AXIS). Les deux paramètres
suivants sont les nouvelles valeurs de seuils. Le dernier paramètre est un booléen qui
vaut true si les seuils sont définis en relatif et false s'ils le sont en absolu.
void removeIAccelerometer3DThresholdListener(IAccelerometer3DThresholdListener ecouteur)
pour enlever un écouteur d'événements.
Remarque : La plupart de ces méthodes peuvent lever une exception de classe IOException
2.4 Température
Le capteur SunSpot possède un capteur de température intégré.
com.sun.spot.sensorboard.peripheral.ITemperatureInput ,
com.sun.spot.sensorboard.peripheral.ITemperatureInputThresholdListener
Classe de périphérique : ITemperatureInput
Méthode getxxx : getADCTemperature() qui retourne un objet de classe ITemperatureInput.
On fait donc :
ITemperatureInput temp = EDemoBoard.getInstance().getADCTemperature ();
puis on utilise l'objet temp qui correspond au capteur de température.
Principales méthodes de ITemperatureInput :
double getCelsius()
renvoie la valeur de température mesurée en ° Celsius (-40 à 60)
double getFahrenheit ()
renvoie la valeur de température mesurée en ° Fahrenheit (-40 à 140)
void setThresholds(double bas, double haut, boolean mode)
définit des seuils haut et bas. Ces
seuils expriment la température en ° Fahrenheit, le dernier paramètre doit être false (sinon ça ne
marche pas !). Voir formules de conversion Celsius Fahrenheit ci-dessous.
void enableThresholdEvents(boolean actif) valide ou invalide la levée d'événements lors d'un
dépassement de seuils. Le paramètre est un booléen qui vaut true si les événements doivent être
levés et false sinon.
void addITemperatureInputThresholdListener(ITemperatureInputThresholdListener ecouteur)
permet
d'associer un écouteur d'événements au capteur de température. C'est un objet d'une classe, à
écrire, implémentant l'interface ITemperatureInputThresholdListener dans laquelle on a
surchargé les 2 méthodes suivantes (l'une peut être vide) :
void thresholdExceeded(ITemperatureInput temp, double val, boolean enCelsius)
appelée quand l'un des seuils définis est dépassé. Le premier paramètre est le capteur de
température, le second la valeur mesurée, le dernier vaut true si la mesure est en °
Celsius et false si elle est ° Fahrenheit.
void thresholdChanged(ITemperatureInput temp, double bas, double haut, boolean enCelsius)
appelée quand les seuils définis sont modifiés. Le premier paramètre est le capteur de
température, le second le nouveau seuil bas, le troisième le nouveau seuil haut et le
dernier vaut true si les seuils sont en ° Celsius et false s'ils sont en ° Fahrenheit.
void removeITemperatureInputThresholdListener(ITemperatureInputThresholdListener ecouteur)
Les conversions °C , °F se font selon les formules suivantes :
C → F : F = 5/9 (C-32)
F → C : C = 9 F/5 + 32
4
2.5 Lumière
Le capteur SunSpot possède un capteur de lumière intégré.
com.sun.spot.sensorboard.peripheral.ILightSensor,
com.sun.spot.sensorboard.peripheral.ILightSensorThresholdListener
Classe de périphérique : ILightSensor
Méthode getxxx : getLightSensor() qui retourne un objet de classe ILightSensor.
On fait donc :
ILightSensor lumiere = EDemoBoard.getInstance().getLightSensor ();
puis on utilise l'objet lumiere qui correspond au capteur de lumière.
Principales méthodes de ILightSensor:
int getValue()
renvoie la valeur de luminosité mesurée (0 à 750).
int getAverageValue()
effectue 17 mesures, une chaque ms, et renvoie la valeur moyenne
int getAverageValue(int n)
effectue n mesures, une chaque ms, et renvoie la valeur moyenne
void setThresholds(int bas, int haut)
définit des seuils haut et bas
void enableThresholdEvents(boolean actif) valide ou invalide la levée d'événements lors d'un
dépassement de seuils. Le paramètre est un booléen qui vaut true si les événements doivent être
levés et false sinon.
void addILightSensorThresholdListener (ILightSensorThresholdListener ecouteur)
permet
d'associer un écouteur d'événements au capteur de lumière. C'est un objet d'une classe, à écrire,
implémentant l'interface ILightSensorThresholdListener dans laquelle on a surchargé les 2
méthodes suivantes (l'une peut être vide) :
void thresholdExceeded(ILightSensor lum, int val) appelée quand l'un des seuils définis est
dépassé. Le premier paramètre est le capteur de lumière, le second la valeur mesurée.
thresholdChanged(ILightSensor light, int bas, int haut)
appelée quand les seuils définis
sont modifiés. Le premier paramètre est le capteur de lumière, les suivants sont les
nouvelles valeurs de seuils.
void removeILightSensorThresholdListener(ILightSensorThresholdListener ecouteur)
3. Contrôleurs du processeur et des interruptions
La classe de base permettant l'accès aux contrôleurs du processeur est la classe : Spot. Elle offre une méthode
getInstance qui fournit un objet de classe Spot à partir duquel on peut récupérer des objets correspondant à
diverses entités du processeur. On procède donc comme suit :
ClasseDElement nomDeLEntite = Spot.getInstance().getxxx();
La méthode getAT91_AIC() permet d'accéder au contrôleur d'interruptions du processeur.
La méthode getAT91_TC() permet d'accéder aux timers du processeur.
La méthode getAT91_PowerManager() permet d'accéder au contrôleur d'alimentation
La méthode getFlashMemoryDevice() permet d'accéder à la mémoire flash
La méthode getI802_15_4_PHY() permet d'accéder à l'émetteur récepteur radio
Bibliothèques à inclure : com.sun.spot.peripheral.Spot
Les timers
Le processeur contient 3 timers permettant de mesurer des durées ou de générer des interruptions dans un délai
donné ou selon une fréquence donnée.
Bibliothèques à inclure : com.sun.spot.peripheral.IAT91_TC, com.sun.spot.peripheral.TimerCounterBits
Classe représentant un timer : IAT91_TC
Méthode getxxx : getAT91_TC(int numero) qui retourne un objet de classe IAT91_TC. Le paramètre
désigne le numéro du timer à récupérer (0 à 2).
5
On fait donc :
IAT91_TC timerUn= Spot.getInstance().getAT91_TC(0);
puis on utilise l'objet timerUn qui correspond au premier timer.
Pour utiliser le Timer en mesure de temps, choisir le mode capture et la vitesse d'horloge. Lancer le timer et, plus
tard, récupérer la mesure faite et la convertir en unités utiles (par exemple) :
timerUn.configure(TimerCounterBits.TC_CAPT | TimerCounterBits.TC_CLKS_MCK32);
timerUn.enableAndReset();
... intervalle à mesurer ne dépassant pas 35ms ...
double cntr = timerUn.counter();
double intervalle = cntr * 0.5342; // temps en microsecondes (voir ci-dessous pour le coef multiplicateur)
Les vitesses d'horloge sont définies par les constantes suivantes :
- TimerCounterBits.TC_CLKS_MCK2 : comptage = 0.0334 µsec.
- TimerCounterBits.TC_CLKS_SLCK : comptage = 30.5176 µsec.
Durée max = 2.188 msec.
Durée max = 2 sec.
Pour utiliser le timer pour générer une interruption après un certain délai ou à intervalles réguliers, choisir le
mode capture avec comparaison et la vitesse d'horloge. Puis déterminer la valeur de déclenchement de
l'interruption et lancer le timer.
timerUn.configure(TC_CAPT | TC_CPCTRG | TC_CLKS_MCK32);
timerUn.setRegC(valeurAAtteindre);
timerUn.enableAndReset();
On peut gérer les interruptions directement en Java. Pour cela il faut utiliser la méthode enableIrq(TC_CPCS)
du timer pour autoriser les interruptions
Si on ne veut pas bloquer le programme principal, on utilisera un thread pour gérer les interruptions. Ce thread
effectue en boucle les 4 opérations suivantes :
1. appeler la méthode waitForIrq() du timer pour attendre l'interruption.
2. appeler la méthode status() du timer pour effacer l'interruption.
3. Traiter cette interruption
4. A la fin du traitement, appeler la méthode enableIrq(TimerCounterBits.TC_CPCS) du timer pour
autoriser une autre interruption.
On peut utiliser disableIrq(TimerCounterBits.TC_CPCS) du timer pour ne plus avoir d'interruptions.
Principales méthodes de la classe IAT91_TC :
void configure(int)
configure le timer. Le paramètre est une combinaison de constantes
(voir exemples ci-dessus)
void enableAndReset()
lance le timer
int counter()
retourne le contenu du timer
void enableIrq(int)
autorise les interruptions. Le paramètre indique quelle interruption est
autorisée. Par exemple la constante TC_CPCS autorise l'interruption
quand le timer atteint la valeur placée dans le registre C (voir setRegC)
void disableIrq(int)
interdit les interruptions. Le paramètre indique quelle interruption est
interdite. Par exemple la constante TC_CPCS interdit l'interruption
quand le timer atteint la valeur placée dans le registre C (voir setRegC)
void setRegC(int)
écrit le paramètre dans le registre C. Ce registre peut être utilisée pour
générer une interruption lorsque le timer atteint la valeur qu'il contient.
void void waitForIrq()
bloque le processus jusqu'à une interruption
int status()
lecture de l'état du timer. La valeur retournée n'a pas d'importance, la
lecture de l'état permet d'effacer les indicateurs d'interruption.
6
4. Radio
Le capteur SunSpot contient un émetteur/récepteur radio qui permet d'établir des communications en point à
point ou en broadcast. Dans le premier cas on peut utiliser des flux java tandis que dans le second on doit utiliser
des trames.
Chaque capteur a une adresse sur 64 bits fixée lors de la fabrication qui l'identifie de façon unique (adresse
IEEE).
4.1 Récupérer l'adresse IEEE du capteur
Bibliothèques à inclure : com.sun.spot.peripheral.Spot
L'adresse physique d'un capteur est représentée par un entier long que l'on peut récupérer en faisant :
long monAdresse = Spot.getInstance().getRadioPolicyManager().getIEEEAddress();
4.2 Manipuler des adresses IEEE
La classe IEEEAddress permet de convertir des adresses IEEE sous différents formats.
Bibliothèques à inclure : com.sun.spot.util.IEEEAddress
Principales méthodes de IEEEAddress:
IEEEAddress(long adresse)
crée une adresse IEEE à partir d'un entier long.
IEEEAddress(String adresse) crée une adresse IEEE à partir d'une chaîne.
String asDottedHex()
retourne l'adresse sous forme d'une chaîne du type "7F00.0001.0000.1002"
long asLong()
retourne l'adresse sous forme d'un entier long
Exemple : pour convertir une adresse contenue dans l'entier long (formeLong) en la chaîne de caractères
(formeChaine) on fera :
String formeChaine = new IEEEAddress(formeLong).asDottedHex();
4.3 Communication par trames
Elle est utilisée pour les messages en broadcast mais permet tout type de communication.
Bibliothèques à inclure : javax.microedition.io.Connector , java.io.IOException
com.sun.spot.io.j2me.radiogram.RadiogramConnection ,
javax.microedition.io.Datagram , com.sun.spot.peripheral.TimeoutException
La communication se fait par des trames dans lesquelles on lit et écrit les valeurs. Pour créer ces trames on doit
disposer d'un connecteur qui est un objet de classe RadiogramConnection. Cette classe possède les méthodes
suivantes :
int getMaximumLength()
qui retourne la taille maximale des trames
Datagram newDatagram(int taille)
qui crée une trame qui pourra être utilisée pour émettre ou pour
recevoir. Le paramètre indique la taille du buffer alloué, on peut
prendre la valeur retournée par getMaximumLength.
void receive(Datagram dgram)
qui reçoit une trame et la place dans le paramètre
void send(Datagram dgram)
qui envoie la trame contenue dans le paramètre (cette trame doit au
préalable avoir été remplie)
void setTimeout(long temps)
qui définit un délai en ms au-delà duquel une exception de classe
TimeoutException sera levée si une lecture (receive) sur ce
connecteur n'est pas terminée dans ce délai. Une valeur de -1
supprime tout délai.
void close()
qui ferme le connecteur.
4.3.1 Emission en broadcast
Les messages émis en broadcast n'ont pas d'adresse de destinataire, ils sont reçus par tous les capteurs à portée.
7
Création d'un connecteur pour émettre en broadcast :
RadiogramConnection broadConn = (RadiogramConnection) Connector.open("radiogram://broadcast:114");
Le paramètre de Connector.open est une chaîne de caractère contenant 3 parties :
- radiogram:// indique que l'on ouvre une connexion radio en mode trame
- broadcast: indique que l'on ouvre une connexion en broadcast
- la valeur qui suit le : est le numéro de port
A partir de ce connecteur on crée une trame qui est un objet de classe Datagram de la façon suivante :
Datagram dg = broadConn.newDatagram(broadConn.getMaximumLength());
Pour écrire dans cette trame on utilise les méthodes de la classe Datagram suivantes :
void reset()
réinitialise à 0 le contenu de la trame
void write(byte[] b, int offset, int taille)
qui envoie taille octets pris dans le tableau b en commençant à
partir du rang offset.
void writeBoolean(boolean v)
qui envoie le booléen b
void writeByte(int v)
qui envoie l'octet v
void writeChar(int v)
qui envoie le caractère v (2 octets)
void writeChars(String s)
qui envoie la chaîne de caractères s
void writeDouble(double v)
qui envoie le réel en double précision v (8 octets)
void writeFloat(float v)
qui envoie le réel en simple précision v (4 octets)
void writeInt(int v)
qui envoie l'entier v
void writeLong(long v)
qui envoie l'entier long v (8 octets)
void writeShort(int v)
qui envoie l'entier court v (2 octets)
void writeUTF(String str)
qui envoie la chaîne de caractères str selon le codage UTF-8 qui
est indépendant de la machine.
Remarque : Ces méthodes peuvent lever une exception de classe IOException
Puis il suffit d'envoyer cette trame par la méthode send du connecteur (voir ci-dessus).
4.3.2 Réception de broadcast
Pour recevoir des trames en broadcast on utilisera un connecteur et un objet contenant la trame reçue.
Création d'un connecteur de classe RadiogramConnection pour recevoir en broadcast :
RadiogramConnection recConn = (RadiogramConnection) Connector.open("radiogram://:114");
Le paramètre de Connector.open est une chaîne de caractère contenant 2 parties :
- la valeur qui suit le : est le numéro de port utilisé par celui qui émet en broadcast
Datagram dg = recConn.newDatagram(recConn.getMaximumLength());
Puis on attend la réception d'une trame par la méthode receive du connecteur (voir ci-dessus).
Pour récupérer les informations contenues dans cette trame on utilise les méthodes de la classe Datagram
suivantes :
String getAddress()
retourne l'adresse de l'expéditeur de la trame
void reset()
réinitialise à 0 le contenu de la trame
int read()
qui lit un octet, la valeur retournée est -1 si la connexion est fermée,
dans le cas contraire read attend jusqu'à recevoir un octet
int read(byte[] b, int off, int len)
qui lit len octets et le place dans le tableau b à partir du rang off
boolean readBoolean()
qui lit un booléen
byte readByte()
qui lit un octet
char readChar()
qui lit un caractère
double readDouble()
qui lit un réel en double précision
8
float readFloat()
int readInt()
long readLong()
short readShort()
int readUnsignedByte()
int readUnsignedShort()
String readUTF()
qui lit un réel en simple précision
qui lit un entier
qui lit un entier long
qui lit un entier court
qui lit un octet non signé
qui lit un entier court non signé
qui lit une chaîne de caractères au format UTF-8 qui est indépendant de
la machine.
4.3.3 Emission par trames
On peut utiliser des trames pour émettre sans que ce soit en broadcast. Dans ce cas un utilise un connecteur non
broadcast et on indique l'adresse du destinataire dans la trame.
Création d'un connecteur de classe RadiogramConnection pour émettre des trames :
RadiogramConnection emetConn = (RadiogramConnection) Connector.open("radiogram://:114");
Le paramètre de Connector.open est une chaîne de caractère contenant 2 parties de la forme :
radiogram://:114
Datagram dg = emetConn.newDatagram(emetConn.getMaximumLength());
Pour écrire dans cette trame on utilise les méthodes de la classe Datagram décrites pour l'émission en broadcast
(voir ci-dessus) auxquelles viennent s'ajouter celles qui permettent de définir l'adresse de destinataire :
setAddress(Datagram reference)
définit l'adresse d'expédition de la trame à partir de celle d'une
autre trame passée en paramètre (par exemple une trame que l'on
a reçue et à laquelle on veut répondre)
setAddress(String adresse)
définit l'adresse d'expédition de la trame
4.4 Communication point à point
La communication de capteur à capteur peut se faire en utilisant des flux java plutôt que des trames réseau. C'est
une méthode plus générale que l'on utilisera de préférence.
Bibliothèques à inclure : javax.microedition.io.Connector , javax.microedition.io.StreamConnection,
java.io.DataOutputStream , java.io.DataInputStream , java.io.IOException
La communication se fait par des flux dans lesquels on lit et écrit les valeurs. Pour créer ces flux on doit disposer
d'un connecteur qui est un objet de classe StreamConnection que l'on crée de la façon suivante :
StreamConnection connecteur =null;
try{
connecteur = (StreamConnection) Connector.open("radiostream://" + adresseAutreSpot + ":100");
}
catch (Exception e) {
System.out.println("Erreur de création de connecteur radio");
}
Le paramètre de Connector.open est une chaîne de caractère contenant 3 parties, il est de la forme :
radiostream://7F00.0001.0000.1002:100
9
- radiostream:// indique que l'on ouvre une connexion radio
- la partie qui suit jusqu'au : est l'adresse du capteur auquel on veut envoyer sous forme de chaîne de
caractères en hexadécimal séparés par des points.
4.4.1 Emission par flux
On utilise des flux de sortie (objets de classe DataOutputStream) pour envoyer des informations au travers du
connecteur.
Exemple de création d'un flux de classe DataOutputStream pour l'envoi par radio :
DataOutputStream ecrire = null;
try{
ecrire = (DataOutputStream) connecteur.openDataOutputStream();
}
System.out.println("Erreur d'ouverture de connexion radio");
}
L'objet de classe DataOutputStream possède les méthodes suivantes :
void write(byte[] b, int offset, int taille) qui envoie taille octets pris dans le tableau b en commençant à
partir du rang offset.
void writeBoolean(boolean v)
qui envoie le booléen b
void writeByte(int v)
qui envoie l'octet v
void writeChar(int v)
qui envoie le caractère v (2 octets)
void writeChars(String s)
qui envoie la chaîne de caractères s
void writeDouble(double v)
qui envoie le réel en double précision v (8 octets)
void writeFloat(float v)
qui envoie le réel en simple précision v (4 octets)
void writeInt(int v)
qui envoie l'entier v
void writeLong(long v)
qui envoie l'entier long v (8 octets)
void writeShort(int v)
qui envoie l'entier court v (2 octets)
void writeUTF(String str)
qui envoie la chaîne de caractères str selon le codage UTF-8 qui
est indépendant de la machine.
void flush()
qui vide le tampon d'écriture et force l'émission
void close()
qui ferme le flux d'écriture
4.4.2 Réception par flux
On utilise des flux d'entrée (objets de classe DataInputStream) pour recevoir des informations au travers du
connecteur.
Exemple de création d'un flux de classe DataInputStream de lecture par radio :
DataInputStream lire = null;
try{
lire = (DataInputStream) connecteur.openDataInputStream();
}
System.out.println("Erreur d'ouverture de connexion radio");
}
L'objet de classe DataInputStream possède les méthodes suivantes :
int read()
qui lit un octet, la valeur retournée est -1 si la connexion est fermée,
dans le cas contraire read attend jusqu'à recevoir un octet
int read(byte[] b, int off, int len)
qui lit len octets et le place dans le tableau b à partir du rang off
boolean readBoolean()
qui lit un booléen
byte readByte()
qui lit un octet
char readChar()
qui lit un caractère
10
double readDouble()
float readFloat()
int readInt()
long readLong()
short readShort()
int readUnsignedByte()
int readUnsignedShort()
String readUTF()
void close()
qui lit un réel en double précision
qui lit un réel en simple précision
qui lit un entier
qui lit un entier long
qui lit un entier court
qui lit un octet non signé
qui lit un entier court non signé
qui lit une chaîne de caractères au format UTF-8 qui est indépendant
de la machine.
qui ferme le flux de lecture
11
SOMMAIRE
1. Création d'un programme.................................................................................................................................... 1
2. Utilisation des périphériques............................................................................................................................... 2
2.1 LEDs ............................................................................................................................................................. 2
2.2 Interrupteurs .................................................................................................................................................. 2
2.3 Accéléromètre ............................................................................................................................................... 3
2.4 Température .................................................................................................................................................. 4
2.5 Lumière ......................................................................................................................................................... 5
3. Contrôleurs du processeur et des interruptions ................................................................................................... 5
Les timers............................................................................................................................................................ 5
4. Radio ................................................................................................................................................................... 7
4.1 Récupérer l'adresse IEEE du capteur............................................................................................................. 7
4.2 Manipuler des adresses IEEE ........................................................................................................................ 7
4.3 Communication par trames ........................................................................................................................... 7
4.3.1 Emission en broadcast............................................................................................................................ 7
4.3.2 Réception de broadcast........................................................................................................................... 8
4.3.3 Emission par trames ............................................................................................................................... 9
4.4 Communication point à point ........................................................................................................................ 9
4.4.1 Emission par flux ................................................................................................................................. 10
4.4.2 Réception par flux ................................................................................................................................ 10
12

Petit guide de Squawk sur SunSpot

Transcription

Documents pareils

Casse briques.

IP1 2014–2015 TP noté (groupe I2, sujet A)

FICHE TECHNIQUE – Redlight

Journal_du_RAM_1er trimestre 2010

Enoncé - Charlie-Soft

TP n4 : Sudoku - Charlie-Soft

Organigramme Direction communication

REDLIGHT

PPT3 - Writing in the Disciplines @ Dawson College

ED/TP Récursivité et expressions régulières