Audela
Audela |
|
L'utilisation du logiciel Audace en réseau constitue une illustration de l'intérêt à utiliser des scripts pour piloter son installation astronomique à distance.
Un réseau est un ensemble de plusieurs applications qui peuvent communiquer ensemble. Dans le cas du logiciel Audela, un réseau peut être utile si l'on souhaite commander un observatoire (caméra, télescope, coupole, etc.) depuis un site distant. Par exemple, faire des images CCD avec une caméra et un ordinateur placés dehors et piloter depuis un second ordinateur placé dans la maison.
Techniquement, un réseau se construit en connectant deux ordinateurs avec un câble spécial. Ensuite il faut configurer les ordinateurs avec le protocole TCP/IP. L'installation détaillée du réseau, sous Windows, est disponible en cliquant ici.
Enfin, il faut affecter un logiciel Audela à la tâche de serveur (généralement celui qui est placé dans l'ordinateur près de l'observatoire) et l'autre logiciel Audela sera client. Cela est effectué dans Audela grâce à la bibliothèque d'extension Tcl-dp. Rappelons qu'un logiciel serveur est un logiciel qui attend de recevoir un ordre pour l'exécuter. Un serveur est donc tout le temps à l'écoute et attend les ordres. Un logiciel client est un logiciel qui va se connecter à un serveur pour lui demander d'exécuter un ordre.
Pour commencer, le premier test proposé consiste à utiliser Tcl-DP sur un seul ordinateur en lançant deux applications Audace sous Audela et en les faisant communiquer. Vérifier que le protocole TCP/IP est bien installé sinon rien ne fonctionnera ! Notons que le protocole NetBEUI Microsoft permet d'échanger facilement des fichiers entre deux ordinateurs en réseau mais il est insuffisant pour le fonctionnement avec Tcl-DP. Les deux protocoles NetBEUI et TCP/IP peuvent être utilisés ensemble, sans problème, sur un même réseau local.
Démarrer le logiciel Audela et choisir l'interface Audace.
Ecrire le script suivant testser.tcl dans le dossier parent de binwin (ou de binlinux) :
# --- fichier testser.tcl : installe un serveur RPC
# --- loading the dp module for Audela
package require dp
# --- Create a Server for the port 5000
set rpcid [dp_MakeRPCServer 5000]
# --- Indique que la console est un serveur :
wm title .console "Console serveur"
# --- Initialize the a variable
set a 5
Dans la console de Audace, envoyer la commande source testser.tcl :
Normalement, le chiffre 5 devrait s'afficher en bleu après le chargement. Le script testser.tcl a pour rôle de créer un serveur et d'initialiser la variable a à 5 :
Démarrer un autre logiciel Audela et choisir l'interface Audace.
Ecrire le script suivant testcli.tcl dans le dossier parent de binwin (ou de binlinux) :
# --- fichier testcli.tcl : connecte un client RPC
# --- loading the dp module for Audela
package require dp
# --- Create a client to connect at the port 5000 of the machine 127.0.0.1
set rpcid [dp_MakeRPCClient 127.0.0.1 5000]
# --- Indique que la console est un serveur :
wm title .console "Console client"
# --- Send commands to the server
dp_RPC $rpcid console::affiche_erreur "client bien connecte\n"
dp_RPC $rpcid expr \$a+4
Dans la console de Audace, envoyer la commande source testcli.tcl :
Normalement, le chiffre 9 devrait s'afficher en bleu après le chargement. Le script testcli.tcl a pour rôle de créer un client et d'envoyer quelques instructions au serveur :
Les deux dernières lignes sont intéressantes. Ce sont elles qui envoient les instructions au serveur. La première des deux lignes fait afficher la phrase "client bien connecte" sur la console du serveur. Vérifier cela en constatant que la console du serveur ressemble à cela :
La dernière ligne envoie un calcul à effectuer par le logiciel serveur. Il s'agit d'additionner 4 à la variable a qui se trouve dans le serveur. Comme la substitution de la variable doit être faite dans le serveur et non au départ du client, on ajoute \ devant $a pour retarder la substitution de la variable $a. Comme la variable a avait été initialisée à 5 dans le logiciel serveur, la valeur en retour, pour le client est donc 9.
Résumons donc les 4 procédures de base à connaître pour établir la connexion entre deux applications Audela :
package require dp
set rpcid [dp_MakeRPCServer 5000]
la variable rpcid contient l'identificateur délivré par la fonction dp_MakeRPCServer de Tcl-DP.
set rpcid [dp_MakeRPCClient 127.0.0.1 5000]
le numéro IP 127.0.0.1 désigne la machine locale. Si l'on procède avec deux ordinateurs distants, remplacer le numéro IP par celui de la machine sur laquelle a été lancé Audela serveur. La variable rpcid contient l'identificateur délivré par la fonction dp_MakeRPCClient de Tcl-DP. Il peut paraître paradoxal d'être obligé de désigner le numéro IP alors que le client et le serveur sont sur le même ordinateur mais cette logique d'écriture s'inscrit dans un cadre général où les clients et les serveurs sont délocalisés (cf. le chapitre suivant "Audela en réseau sur deux machines").
dp_RPC $rpcid $commande
Installer Audela et Tcl-DP pourAudela sur les deux ordinateurs. Vérifier que le protocole TCP/IP est bien installé. Les deux ordinateurs doivent avoir des numéros IP différents. Dans le cas d'une utilisation locale, on préférera les numéro IP de style 192.168.0.1, 192.168.0.2, etc.
Nous considérons deux ordinateurs reliés par un réseau local (=pas de liaison au réseau Internet). Le but est de piloter l'installation de l'observatoire depuis une salle chauffée dans la maison.
L'ordinateur qui pilote la caméra (et éventuellement le télescope) est appelé ordinateur Jardin. Nous lui assignons le numéro IP 192.168.0.2 et il sera serveur.
L'ordinateur qui va servir à envoyer les ordres depuis la salle chauffée est appelé ordinateur Maison. L'ordinateur Maison sera le client et nous lui assignons le numéro IP 192.168.0.1.
Nous allons maintenant décrire deux scripts plus puissants que testser.tcl et testcli.tcl car il faut envoyer des ordres de façon simple pour alléger l'écriture.
Le script ci-dessous (serveur.tcl) permet à Audace, installée sur l'ordinateur Jardin de devenir un serveur.
#
# Fichier : serveur.tcl
#
# --- Charge le module dp
global rpcid
package require dp
# --- Cree un port serveur numero 5000
set rpcid(serveur) [dp_MakeRPCServer 5000]
# --- Fonction d'analyse du message du client
proc eval_client { arg } {
uplevel $arg
}
# --- Fonction pour renvoyer des messages a executer vers le client
proc send { arg } {
global rpcid
dp_RPC $rpcid(client) console::affiche_resultat "Execute : $arg \n"
set message "dp_RPC $rpcid(client) eval_serveur \{ $arg \}"
eval $message
}
Dans la console de Audace, envoyer la commande source serveur.tcl
Le script ci-dessous (serveur.tcl) permet à Audace, installée sur l'ordinateur Maison de devenir un client.
#
# Fichier : client.tcl
#
# --- Charge le module dp
package require dp
# --- Cree un client connecte au port 5000 de la machine 192.168.0.2
global rpcid
set rpcid(client) [dp_MakeRPCClient 192.168.0.2 5000]
# --- Envoi un message de connexion a afficher sur la console du serveur
dp_RPC $rpcid(client) console::affiche_resultat "client bien connecte\n"
# --- Fonction pour envoyer des messages a executer par le serveur
proc send { arg } {
global rpcid
dp_RPC $rpcid(client) console::affiche_resultat "Execute : $arg \n"
set message "dp_RPC $rpcid(client) eval_client \{ $arg \}"
eval $message
}
# --- Fonction d'analyse du message de retour eventuel du serveur
proc eval_serveur { arg } {
uplevel $arg
}
# --- Cree un port serveur numero 5001 pour permettre au serveur
# --- de renvoyer des ordres au client
set rpcid(serveur) [dp_MakeRPCServer 5001]
# --- Demande au serveur de se connecter au "serveur" du client
send {set rpcid(client) [dp_MakeRPCClient 192.168.0.1 5001]}
Dans la console de Audace, envoyer la commande source client.tcl
Vous pouvez désormais envoyer n'importe quelle commande à partir du client, en la faisant précéder du mot send. La fonction send envoie la chaîne d'arguments vers le serveur et le serveur l'exécute automatiquement.
sendremplace avantageusement l'écriture de
dp_RPC $rpcid. Par exemple, sur la console du client (à la Maison) :
send {set a 5}
# 5
send {expr $a+4}
# 9
Ces deux commandes sont similaires à ce que l'on avait testé au chapitre précédent. Cependant, le fait d'envoyer les expressions entre accolades {} permet de retarder la substitution et donc il n'est plus nécessaire de placer un \ devant de $a. Cela simplifie l'écriture des commandes à envoyer,
sendest donc une fonction très opérationnelle.
D'un point de vue très pratique, si l'on veut faire bouger un télescope depuis la maison, on procèdera ainsi :
send {::tel::create lx200 com2}
# 1
send {tel1 goto {12h35m26s -12d45m51s} }
#
set coord [send {tel1 coord }]
# 12h35m26s -12d45m51s
L'ordinateur de la Maison demande à l'ordinateur du Jardin de pointer le télescope aux coordonnées indiquées puis de lire les coordonnées du télescope. La position lue est alors stockée dans la variable coord de l'ordinateur de la Maison. Il est intéressant d'envoyer des scripts complets pour piloter aisément les instruments distants. Par exemple, pour faire l'acquisition d'une image et afficher le resultat sur l'écran de la Maison, on enverra le script suivant :
send {acq 60 2}
send {saveima //maison/c/audela/image.fit}
send {send {loadima c:/audela/image.fit} }
Dans ce script, on considère que l'ordinateur Maison porte le nom "maison" sur le réseau et que le disque c: est identifié par "c" dans le partage des fichiers.
On pourra créer une fonction, pour le client, afin que l'ordre d'acquisition se résume à une seule fonction. Ainsi, le script suivant crée la fonction sendacq qui effectue cela :
#
# Fichier : sendutil.tcl
#
proc sendacq {exptime binning} {
eval "send \{acq $exptime $binning\}"
send {saveima //maison/c/audela/temp}
send {send {loadima c:/audela/temp}}
}
Pour avoir accès à la fonction sendacq, il faut d'abord enregistrer cette fonction dans l'interpréteur Tcl :
source sendutil.tcl
Ensuite, on lance une pose de 10 secondes en binning 2x2 par la fonction :
sendacq 10 2
L'image s'affiche sur l'écran Audace de l'ordinateur de la Maison.
Dans le cadre de l'interface Audace, l'ensemble des fonctions précédentes sont déjà définies dans le fichier audnet.tcl. Ces fonctionnalités sont utilisées dans le panneau remotecontrol.tcl.
Dans le cadre d'une utilisation du réseau Internet on peut piloter un observatoire très éloigné (distance supérieure à 150 mètres). Il faudra alors utiliser deux ordinateurs ayant des adresses fixes sur Internet. Le reste de l'utilisation est similaire à celle d'un réseau local.
La grande difficulté d'un observatoire piloté sur Internet réside dans la synchronisation entre les requêtes d'observation et la réception des images. On contourne généralement ce problème en utilisant plutôt un fonctionnement Internet par script CGI plutôt qu'une prise en main directe. Cela permet, en plus, au client d'avoir une adresse variable délivrée par un fournisseur d'accès et de se connecter à l'ordinateur de l'observatoire depuis n'importe quel navigateur Web. Le fonctionnement de Audela en tant que script CGI est détaillé dans la page suivante.