Carte TINI

Sensibilisation a la maîtrise de l’énergie :
Partie personnel
Introduction NETMASTER
Netmaster est un sous-système programmable basé sur un module de Dallas TINI. Sa
connectivité dans le réseau lui permet une intégration avec d'autres systèmes.
Ainsi l'interface Ethernet permet d’installer Netmaster dans le réseau, cela garantie une
interaction avec toutes les ressources du réseau. L'appui du protocole Tcp-IP et la
disponibilité d’un serveur internet permettent à Netmaster le raccordement avec des réseaux
Internet ou Intranet. De cette façon, il est possible de n'importe quel PC relié au réseau ou
ayant un accés au Web, de recevoir des informations ou d’envoyer des commandes à
Netmaster depuis un navigateur sans employer des programmes spécifiques.
Grâce à la ligne RS232 ou par le moyen d’un raccordement via ftp, il est possible de
programmer NETMASTER en langage Java ainsi qu’en langage C.
Caractéristiques:
- 12 entrées logiques opto-isolées, visualisées par Leds,
- 8 sorties logiques avec relais (dynamiques ou statiques), visualisées par Leds,
- 4 entrées analogiques (0-10 Vdc), 12 bits,
- 2 sorties analogiques (0-2,5 Vdc), 12 bits,
- bus CAN ou RS485,
- interface Ethernet 10-baseT,
- interface 1-Wire
- clavier 6 touches + afficheur alphanumérique LCD,
- disponibilité du protocole PPP.
Carte TINI
Introduction
TINI (Tiny InterNet Interface) est une carte qui permet de développer des applications Java
Embarqué.
L'unité centrale de traitement de TINI est le DS80C390 de Dallas Semiconductor. La carte
TINI possède une gestion de réseau, des interfaces intégrées Ethernet pour relier différents
types de matériel, une interface RS232, une horloge en temps réel, une unique adresse MAC
d'Ethernet, et une protection de batterie pour la RAM.
La ROM Flash contient les bibliothèques, la machine virtuelle de Java et les librairies des
classes Java de TINI.
Rom Flash (Java Runtime Environment)
Contrôleur Ethernet
Microcontrôleur
SRAM
RS232
Horloge temps réel
SRAM non volatile
Pile au lithium
Installation complète de la carte TINI
I.
Point de vue matériel
A.
Matériel nécessaire pour installer la carte
La liste du matériel indispensable pour installer et utiliser la carte TINI est la
suivante:
o
o
o
o
o
La carte TINI
Une alimentation stabilisée de tension 30 V
Un câble série RS232
Un câble RJ45 croisé
Un ordinateur avec un système d'exploitation MS-Windows XP ou
Linux
B.
Réglages à effectuer
En premier lieu il faut connecter le Netmaster au PC en utilisant une interface
série au moyen d’un câble RS232, pour pouvoir configurer l’interface Ethernet
(adresse ip, masque sous-réseau, passerelle…) de la carte TINI et installer le
firmware (qui contient un ensemble de logiciels assurant le fonctionnement de
la carte). J’ai commencé par fabriquer un câble RS232/RJ45. Je me suis aidé
pour cela d’un schéma électrique fournie par Elsist, le constructeur du
Netmaster.
Une fois le firmware installé et l’interface Ethernet correctement configuré on
utilisera l’interface Ethernet via un câble RJ/45 pour communiquer avec le kit
TINI.
II.
Point de vue logiciel
A.
Fichiers nécessaires pour charger le firmware dans la flash ROM de la carte

Le TINI Firmware 1.02 : tini1_02.tgz.
Qui contient le programme pour communiquer avec la carte via le port série,
les pilotes pour la carte, le slush une sorte de mini shell type UNIX et l'outil
pour compiler les programmes précompilé java en programme exécutable par
la carte TINI. A noter que le slush est une application JAVA.

Le Java Development Kit de Sun v1.5
Pour pouvoir compiler et lancer les programmes java

L'API javax.comm 3.0
Qui contient les pilotes indispensables pour gérer les ports séries et parallèles
de l’ordinateur (spécifique à l’OS Windows)
B.
Opérations a suivre pour installer le firmware.
1.
Installez le JDK
2.
Installez javax.comm :




Décompressez le fichier dans le dossier du JDK
Placez le fichier comm.jar dans <dossier JDK>/jre/lib/ext/,
le fichier javax.comm.properties dans <dossier JDK>/jre/lib/
et le fichier win32com.dll dans <dossier JDK>/jre/bin/
3.
Décompressez le fichier tini1_02.tgz. dans le dossier du JDK
4.
Pour lancer le JavaKit qui permet de charger le :


Le cable série est bien branché et la TINI est sous tension.
Sous MS-DOS effectuer les commandes:
java -classpath <dossier tini>\bin\tini.jar ; JavaKit
(ne pas oublier les majuscules)
5.
Une fois le JavaKit lancé, pour charger le firmware opérez comme ceci:




Choisissez le port série sur lequel vous avez branché le câble.
Choisissez la vitesse de transmission (part défaut utilisez 115200
bauds)
Cliquez sur le bouton "open port"
Cliquez sur le bouton "Reset".
Ceci permet d’arrêter tout les programmes qui sont lancés sur la carte et
d'afficher le menu de chargement de la carte.

Un affichage doit s'imprimer sur l'écran du type:

Allez dans le menu File et sélectionnez "Load File".
Choisissez le fichier <DossierTINI>\bin\tini.tbin.
JavaKit doit afficher l'évolution du chargement.
Tbin est l’abréviation de "TINI binaire", ce type de fichier est ciblé pour être
chargé dans la flash ROM. Les dossiers TBIN distribués avec le TINI SDK
contiennent les implémentations TINI Java Runtime ainsi que l’application du
slush. Il faut maintenant réinitialiser la carte.
Attention cette manœuvre entraînera la destruction de tous les fichiers présents
sur la carte.
N'oubliez pas de sauvegarder toutes vos données par le FTP.
Pour réinitialiser la carte tapez dans le JavaKit:


B 18 <Entrée> // permet de se placer sur la bank 18
F 0 <Entrée> // remplie bank 18 avec des 0 donc l'efface.
La carte est donc maintenant opérationnelle.
C.
Installation et utilisation du slush.
Le slush est un petit shell avec des commandes UNIX et des commandes
spécifiques.
Il permet de gérer les dossiers et les fichiers, de créer des utilisateurs, mais il
permet aussi de configurer la carte pour les liaisons FTP et Telnet et de lancer
les programmes java.
1. Dans le JavaKit allez dans le menu "File" et sélectionnez "Load File".
Choisissez le fichier <Dossier TINI>\bin\slush.tbin.
2. Appuyer sur Entrée pour avoir ">" qui s'affiche puis pour se connecter
au slush à partir de la liaison série tapez:
e <Entrée>
Pendant la connexion on peut voir s’afficher au bout d'un moment:
[-=
slush Version 1.02
=-]
[
System coming up.
]
[
Beginning initialization... ]
[
Not generating log file.
] [Info]
[ Initializing shell commands... ] [Done]
[
Checking system files...
] [Done]
[ Initializing and parsing .startup... ]
[
Initializing network...
]
[ Network configurations not set. ] [Skip]
[
Network configuration
] [Done]
[
System init routines
] [Done]
[ Slush initialization complete. ]
[
Bring up Serial Server...
]
Hit any key to login.
Welcome to slush. (Version 1.02)
TINI login: root
TINI password:
TINI/>
Il est a noté qu'il y a par défaut 2 comptes créés: "guest" avec le mot
de passe "guest" et le super utilisateur "root" avec le mot de passe
"tini". Il est également possible de créer un autre utilisateur avec la commande
useradd.
Pour qu'elle soit pleinement utilisable, il a fallu l’interface Ethernet de la carte
TINI. La procédure est similaire à Linux.
Il suffit, pour cela, d'utiliser la commande ipconfig. Voici la configuration pour
le lycée du LGM :
ipconfig -a 192.16.104.94 -m 255.255.0.0 -g 192.16.104.1
TINI /> help ipconfig ipconfig [options]
Configure or display the network settings.
[-a IP -m mask] Set IPv4 address and subnet mask.
[-n domainname] Set domain name
[-g IP] Set gateway address
[-p IP] Set primary DNS address
Le slush gère les protocoles telnet et ftp pour télécharger les applications Java
via la liaison Ethernet.
Programmation sur carte tini
La phase de programmation sur carte tini se décompose en 5 étapes :
1)
2)
3)
4)
5)
Création du fichier source
Compilation du fichier source
Conversion du fichier class
Chargement de l’image converti
Exécution de l’image convertie
1) Création fichier source
Pour la création du fichier source il est nécessaire d’utiliser un
environnement de développement intégré. Pour le projet, nous avons
utilisé eclipse 3.1.2. Il est très important d’utilisé une version 1.4.2 du
J2SE ou plus récent, une version ultérieure n’étant pas compatible avec
eclipse.
2) Compilation fichier source
Pour compiler le fichier, il faut le déplacer dans le répertoire où est installé le kit de
développement JAVA.
Javac –target 1.1 MonProgramme.java
Il est obligatoire d’utiliser la commande –target si on utilise une version plus récente que
JAVA 1.1. Cela s’explique du fait que le slush application de type Java, a été développer avec
la version 1.1 du JDK.
Si la compilation est réussie, on obtient MonProgramme.class
3) Conversion du ficher class
Pour que TINI puisse exécuter le fichier, il est nécessaire qu’elle puisse le comprendre. Le
TINI Firmware contient un programme nommé TINICONVERTOR capable de convertir un
fichier .class en une image binaire exécutable sur TINI.
Tapez la commande suivante :
java -classpath <DOSSIER TINI>\bin\tini.jar TINIConvertor -f MonProgramme.class -d
<DOSSIER TINI>\bin\tini.db -o MonProgramme.tini Cette commande lit le fichier source
MonProgramme.class, recherche les librairies nécessaires dans le répertoire tini.jar indiqué
par l'option -classpath (un fichier d'archive .jar étant considéré comme un répertoire). Le
fichier après conversion sera nommé MonProgramme .tini. Il doit contenir la méthode main.
4) Chargement de l’image convertie
Pour exporter le fichier MonProgramme.tini sur la carte TINI, il suffit d’établir une connexion
via ftp entre l’ordinateur et la carte :
ftp> put MonProgramme.tini
5) Exécution de l’image convertie
Une fois le programme chargé sur la carte TINI, on l’exécute ainsi :
TINI /> java MonProgramme.tini
Introduction
Le rôle de la partie que j’ai à traitée est de transmettre les valeurs d’énergies instantanées
produites ainsi que leurs moyennes lors du challenge vélo au PC superviseur qui se chargera
de les afficher sur le grand écran. Ces valeurs d’énergies m’auront été préalablement fournies.
Sur le plan matériel, mon interaction se limitera au Netmaster, où est embarqué la carte Tini et
le PC superviseur. C’est à cet endroit que s’effectuera le dialogue client/serveur.
Analyse détaillée
Pour mon projet et la mise en place d’un dialogue client/serveur je dois utiliser un protocole
web de type xml-rpc. Xml-rpc est ce qu’on appelle un service web.
Principes des services web
Ils permettent de faire communiquer des programmes tournant sur des machines différentes
et écrits dans des langages de programmation différents.
Ils autorisent l'appel d'une méthode, d'un objet distant en utilisant un protocole web pour
transporter des données au format XML pour formater les échanges. Les services web
fonctionnent sur le principe du client serveur :



Un client appelle les services web.
Le serveur traite la demande et renvoie le résultat au client.
Le client utilise le résultat.
Principes de xml-rpc
1. Un message en xml est construit, il contient un nom de méthode et des paramètres.
2. Ce message est envoyé vers une adresse URL.
3. Cette url correspond à un serveur, qui va analyser le message reçu. il exécute alors la
méthode indiquée en lui donnant les paramètres reçus.
4. Une réponse est ensuite renvoyée : elle indique un message d'erreur ou des valeurs
résultats, toujours sous forme XML.
Cependant les programmeurs n’ont pas besoin d’acquérir des connaissances particulières
sur le langage xml. En effet des composants réalisé en Javascript se chargent de formater
les messages, de faire les appels et de recevoir les réponses. Tout reste donc transparent.
Serveur XML-RPC
Client Web Embarqué
La première étape dans la réalisation de ce projet a été de développer un client
WEB pour le module TINI. Ce travail a reposé sur l’API xmlrpc2.0. Celle-ci contient le
paquetage org.apache.xmlrpc pour la manipulation du protocole XML-RPC, conformément
aux demandes du cahier des charges.
Le principe de fonctionnement réside dans le fait qu’il y est une carte tini par vélo. Le client
se trouve sur la carte. Dès qu’il se connecte au serveur basé sur un pc superviseur, le
serveur lui renvoie un numéro d’identification qui lui sera propre. Ce numéro permettra de
différencier les sources des énergies récupérées par les différents vélos.
1) Côté serveur
public class xmlrpc_serveur extends WebServer
La classe xmlrpc_serveur hérite des méthodes de la classe WebServer.
public xmlrpc_serveur(int port)
super(port);
On appelle ici, le constructeur de la classe mère.
public static void main (String[]args) {
try {
System.out.println("Tentative du lancement du serveur XML-RPC...");
xmlrpc_serveur serveur = new xmlrpc_serveur(2003);
serveur.setParanoid(true);
serveur.acceptClient("127.0.0.1");
System.out.println("Lancement du serveur réussi");
Création un objet de type xmlrpc_serveur qqui va représenter notre serveur.
setParanoid permet d’activer un filtre d’IP. Ici en l’occurrence seule la machine hôte pourra se
connecter au serveur.
serveur.addHandler("service", new xmlrpc_transfert());
serveur.start();
Ajout d’un service de procédure distante nommé service. Ainsi toutes les méthodes publiques
de cette instance pourront se voir invoquées.
2) Côté service
public class xmlrpc_transfert
protected Vector buffersEnergie = new Vector();
Un vecteur contenant des buffers pour les énergies provenant des différents vélos.
Un vecteur est un tableau d’objet ce qui nécessitera des transtypages.
public int déclareNouveauVélo()
nombreVélosDéclarés++;
buffersEnergie.addElement(new double[TAILLE_BUFFER]);
curseursBuffers.addElement(new Integer[0]);
return nombreVélosDéclarés;
Méthode appelée par chaque carte TINI pour déclarer son vélo et obtenir un identifiant unique
pour ce vélo (un int). Cet identifiant sera ensuite utilisé pour identifié le vélo pour transmettre
des valeurs d'énergie. Retourne l'identifiant attribué par le serveur pour le nouveau vélo.
curseursBuffers et buffersEnergie sont des objets de type vecteur.
public boolean addNouvelleEnergie(Integer idVélo, Double énergie)
Méthode qui va rajouter une nouvelle énergie dans un buffer.
int positionCurseur =
((Integer)curseursBuffers.elementAt(idVélo.intValue())).intValue();
System.out.println(+positionCurseur);
On récupère la position actuelle du curseur dans le buffer pour ce vélo.
La méthode elementAt() donne l'objet stocké dans le vecteur à la position idVélo.
La méthode elementAt() donne un objet générique. Il faut donc convertir l'objet pour l'utiliser.
double[] buffer = (double[])buffersEnergie.elementAt(idVélo.intValue());
On récupère le buffer correspondant au numéro du vélo.
buffer[positionCurseur] = énergie.doubleValue();
System.out.println(buffer[positionCurseur]);
Puis on ajoute la nouvelle valeur à la position du curseur dans le buffer.
if (positionCurseur == TAILLE_BUFFER) {
// BD...
// passer le buffer à une méthode pour sauvegarde dans BD
// ex: sauvegardeBuffer(idVélo, buffer);
positionCurseur = 0;
Si le buffer est plein alors, la personne qui est en charge de la base de donnée, appellera une
méthode avec comme argument l’identifiant du vélo, ainsi que le buffer.
curseursBuffers.setElementAt(new Integer(positionCurseur), idVélo.intValue());
On revient à l’indice 0 dans le buffer si l’opération c’est bien passée.
public double CalculMoyenneEnergie(Integer id Vélo, Double énergie){
nb_envois++;
somme_energie=somme_energie+énergie;
System.out.println("Transaction moyenne énergie effectuée");
return somme_energie/nb_envois;
Méthode qui permet de calculer la moyenne de l’énergie.
3) Côté Client
public class xmlrpc_client extends XmlRpcClient
La classe xmlrpc_client hérite des methodes d’XmlRpcClient
public xmlrpc_client(String urlServeur) throws java.net.MalformedURLException
super(urlServeur);
Constructeur pour la classe xmlrpc_client.
private boolean init() {
…
try {
idVélo = ((Integer)this.execute("service.déclareNouveauVélo",
paramètres)).intValue();
Etablit la connexion avec le serveur XMLRPC et obtient du serveur un identificateur unique
pour identifier le vélo attaché à la carte TINI sur laquelle tourne ce client.
public void envoyerValeurEnergie(double valeurEnergie)
…
paramètres.addElement(new Integer(idVélo));
paramètres.addElement(new Double(valeurEnergie));
Méthode utilisée par le capteur d'énergie pour communiquer des valeurs au serveur
XML_RPC ; Les 2 paramètres correspondent aux paramètres de la méthode distante
addNouvelleEnergie.
résultat = ((Boolean)this.execute("service.addNouvelleEnergie",paramètres)).booleanValue();
Exécution de la méthode distante avec passage des 2 paramètres. Les 2 paramètres doivent
être impérativement de type vecteur.