Table des Matières
Publicité
22. Programmation avancée
{
Console.WriteLine("Nouveau module
}
L'initialisation
Vous devez ensuite signaler à l'API qu'il faut appeler votre callback quand un nouveau module est
branché.
YAPI.RegisterDeviceArrivalCallback(deviceArrival);
Notez que si des modules sont déjà branchés lorsque le callback est enregistré, le callback sera
appelé pour chacun de ces modules déjà branchés.
Déclenchement des callbacks
Un problème classique de la programmation par callbacks est que ces callbacks peuvent être
appelés n'importe quand, y compris à des moments où le programme principal n'est pas prêt à les
recevoir, ce qui peut avoir des effets de bords indésirables comme des dead-locks et autres
conditions de course. C'est pourquoi dans l'API Yoctopuce, les callbacks d'arrivée/départs de
modules ne sont appelés que pendant l'exécution de la fonction
suffit d'appeler
UpdateDeviceList()
spécifique pour controller précisément quand les appels à ces callbacks auront lieu:
// boucle d'attente gérant les callback
while (true)
{
// callback d'arrivée / départ de modules
YAPI.UpdateDeviceList(ref errmsg);
// attente non active gérant les autres callbacks
YAPI.Sleep(500,
}
De manière similaire, il est possible d'avoir un callback quand un module est débranché. Vous
trouverez un exemple concret démontrant toutes ces techniques dans la librairie de programmation
Yoctopuce de chaque langage. L'exemple se trouve dans le répertoire Examples/Prog-EventBased.
Attention: dans la plupart des langages, les callbacks doivent être des procédures globales, et non
pas des méthodes. Si vous souhaitez que le callback appelle une méthode d'un objet, définissez
votre callback sous la forme d'une procédure globale qui ensuite appellera votre méthode.
Détecter le changement de valeur d'un senseur
L'API Yoctopuce fournit aussi un système de callback permettant d'être prévenu automatiquement
de la valeur d'un senseur, soit lorsqu'il a changé de manière significative, ou soit à intervalle fixe. Le
code nécessaire à cet effet est assez similaire au code utilisé pour détecter l'arrivée d'un module.
Cette technique est très utile en particulier si vous voulez détecter des changements de valeur très
rapides (de l'ordre de quelques millisecondes), car elle est beaucoup plus efficace (en terme de
traffic sur USB) qu'une lecture répétée de la valeur et permet donc des meilleures performances.
L'appel des callbacks
Afin de permettre un meilleur contrôle du contexte d'appel, les callbacks de changement de valeurs
et les callback périodiques ne sont appelés que pendant l'exécution des fonctions
et
YAPI.HandleEvents()
soit depuis un timer soit depuis un thread parallèle.
while (true)
{
// boucle d'attente permettant de déclencher les callbacks
YAPI.Sleep(500,
}
Dans les environnements de programmation où seul le thread d'interface a le droit d'interagir avec
l'utilisateur, il est souvent approprié d'appeler
172
ref errmsg);
. Vous devez donc appeler une de ces fonctions à intervalle régulier,
ref errmsg);
: "
+ m.get_serialNumber());
à intervalle régulier depuis un timer ou un thread
YAPI.HandleEvents()
UpdateDeviceList()
YAPI.Sleep()
depuis ce thread.
www.yoctopuce.com
. Il vous
Publicité
Table des Matières
