Il y a 5 ans, nous avions modifié notre machine à café Jura Josephine afin de pouvoir la télécommander depuis une page web. L'idée était amusante mais en réalité cette fonctionnalité ne servait à rien car il fallait quand même se déplacer pour mettre une tasse devant machine à café. Mais aujourd'hui, grâce au Yocto-Proximity, on peut faire quelque chose de plus utile: on va lancer un café dès qu'une tasse est posée sur la machine.
Nous avons vu dans les deux précédents articles (ici et là) comment contrôler la machine, mais il reste à détecter la présence et l'absence d'une tasse. Pour ce faire, nous allons utiliser notre nouveau module, le Yocto-Proximity.
Le hardware
Le Yocto-Proximity est en effet idéal pour ce type d'usage, il ne nécessite pas de partie mécanique, ni de réflecteur, ce qui facilite considérablement son installation dans la machine.
Le Yocto-Proxmitiy est utlisé pour détecter la présence d'une tasse sous les buses de la machine à café
Nous avons caché le Yocto-Proximity dans le bord gauche de la machine. A cet endroit, le Yocto-Proximity ne risque pas de recevoir des éclaboussures de café et ne bloque pas l'accès au bac de récupération du marc de café.
La portée du Yocto-Proximity est largement suffisante pour détecter la présence de la tasse sous les buses. De plus, comme nous n'utilisons qu'une seule taille de tasse à café, on peut même détecter si la tasse n'est pas centrée sous les deux buses.
Le Yocto-Proxmitiy est placé sur le côté de la machine
La fixation du Yocto-Proximity est assez facile car nous avions déjà modifié la machine pour cacher les relais qui pilotait la machine. Il suffit de démonter le cache de la machine, percer un petit trou de 5 mm pour que le capteur puisse "voir" la tasse.
Le Yocto-Proximity vise la tasse à travers ce petit trou
Nous avons aussi profité de l'occasion pour remplacer le Micro-USB-Hub-V2 par un YoctoHub-Wireless-SR, de cette manière la machine à café n'a plus besoin d'être branchée directement sur un port USB du PC pour fonctionner.
Maintenant que nous avons réglé la partie "mécanique", occupons-nous de la partie logiciel.
Le Logiciel
Pour que le système fonctionne, il faut un petit programme qui surveille la valeur notifiée du Yocto-Proximity et simule l’appui du bouton "café" de la machine à l'aide du relais branché en parallèle.
Le Yocto-Relay et le Yocto-Proximity sont accessibles par WiFi grâce au YoctoHub-Wireless-SR
Nous avons décidé d’écrire ce petit programme en Python car on peut le faire tourner facilement sur n'importe quelle machine. Ce programme s’exécute sur un Raspberry Pi qui est allumé en permanence.
Au démarrage, le programme enregistre l'adresse IP du YoctoHub-Wireless-SR et vérifie la présence du Yocto-Proximity et du Yocto-Relay.
# Setup the API to use local USB devices
if YAPI.RegisterHub("192.168.1.52", errmsg) != YAPI.SUCCESS:
sys.exit("init error" + errmsg.value)
proximity = YProximity.FirstProximity()
if proximity is None:
sys.exit("No Yocto-Proximity found")
relay_power = YRelay.FindRelay("power")
if not relay_power.isOnline():
sys.exit("No relay with logical name \"power\" found")
relay_coffee = YRelay.FindRelay("coffee")
if not relay_coffee.isOnline():
sys.exit("No relay with logical name \"coffee\" found")
Ensuite, il enregistre un callback functionValueChangeCallback qui est appelé à chaque changement de valeur du capteur de proximité. La classe CoffeeMachine est une machine à état très basique qui déclenche un café uniquement si on passe de l'état "pas de tasse" à l'état "tasse présente et centrée". Pour déclencher un café, on appelle la méthode pulse() du relais.
class CoffeeMachine(object):
READY = 1
DISPENSING = 2
CUP_MISALIGNED = 3
def __init__(self, arg_proximity, arg_relay_coffee):
super().__init__()
self.proximity = arg_proximity
self.relay_coffee = arg_relay_coffee
self.state = None
self._set_ready_state()
def updateProximity(self, value):
if self.state == self.READY or self.state == self.CUP_MISALIGNED:
if value >= 1000:
self._set_ready_state()
return
if 400 < value < 800:
# cup present
self.relay_coffee.pulse(200)
self._set_dispensing_state()
else:
self._set_missaligned_state()
elif self.state == self.DISPENSING:
if value >= 1000:
self._set_ready_state()
return
if value < 400 or value > 800:
self._set_missaligned_state()
def _set_ready_state(self):
if self.state != self.READY:
print("switch to state READY")
self.state = self.READY
def _set_missaligned_state(self):
if self.state != self.CUP_MISALIGNED:
print("switch to state CUP_MISALIGNED")
self.state = self.CUP_MISALIGNED
def _set_dispensing_state(self):
if self.state != self.DISPENSING:
print("switch to state DISPENSING")
self.state = self.DISPENSING
def functionValueChangeCallback(fct, value_str):
value = int(value_str)
global coffee_machine
coffee_machine.updateProximity(value)
coffee_machine = CoffeeMachine(proximity, relay_coffee)
proximity.registerValueCallback(functionValueChangeCallback)
while True:
YAPI.Sleep(1000, errmsg) # traps value events
Le code complet est disponible sur GitHub :
https://github.com/yoctopuce-examples/josephine
Conclusion
Comme vous pouvez le voir dans la vidéo, le système fonctionne bien:
Nous avons même ajouté un Yocto-Buzzer qui émet un son lorsque la tasse n'est pas centrée ou si personne n'a enlevé la tasse après 1 minute. Cela évite que les étourdis comme moi oublient leur tasse et boivent leur café froid ;-)
