Un compteur de vitesse pour hamster

Un compteur de vitesse pour hamster

Cette semaine nous allons réaliser un petit bricolage amusant: Nous allons fabriquer un compteur de vitesse pour une roue de hamster.






Principe


La technique pour calculer la vitesse de la roue est très simple, on colle un aimant sur la roue, et un "interrupteur à lames souples (ILS)" sur le support de la roue. Si ces deux éléments sont alignés correctement, il est possible de détecter le passage de l'aimant devant l’interrupteur en mesurant la résistance de ce dernier.

L'interrupteur à lames souples permet de détecter le passage de l'aimant à chaque tour
L'interrupteur à lames souples permet de détecter le passage de l'aimant à chaque tour



En termes plus simples, les deux fils de l’interrupteur à lames sont connectés seulement quand l'aimant est en face de l’interrupteur à lames. On peut donc ainsi déterminer la vitesse en mesurant le temps écoulé entre deux fermetures du contact.

L'interrupteur à lames est fixé sur la cage et l'aimant est collé sur la roue
L'interrupteur à lames est fixé sur la cage et l'aimant est collé sur la roue



Détecter le passage de l'aimant


Nous avons deux modules qui peuvent être utilisés pour détecter la fermeture d'un interrupteur à lames souples, le Yocto-Knob et le Yocto-PWM-Rx.

Pour ce montage, nous avons décidé d'utiliser le Yocto-PWM-Rx car il possède un filtre anti-rebond (debouncing) et il est capable de compter automatiquement le nombre de fermetures du contact.

Les interrupteurs à lames souples ont tous tendance à rebondir lorsqu'ils changent d'état, ce qui génère des impulsions parasites. Le Yocto-PWM-Rx peut être configuré pour filtrer ces rebonds. Si on avait décidé d'utiliser un Yocto-Knob, il aurait fallut gérer ceci de manière logicielle dans notre programme.

Le Yocto-PWM-Rx est aussi capable de compter automatiquement le nombre d'impulsions, c'est-à-dire la transition de ouvert->fermé->ouvert. De nouveau, c'est quelque chose qu'on aurait dû gérer en software si on avait utilisé le Yocto-Knob.

L'ILS étant un élément passif, il faut utiliser le pull up du Yocto-PWM-Rx pour alimenter la boucle. Ce montage en mode open drain est détaillé dans la section 2.2 de la documentation mais voici le branchement à effectuer pour utiliser l'entrée 1:

Le Yocto-PWM-Rx est connecté en mode open drain
Le Yocto-PWM-Rx est connecté en mode open drain



Une fois le branchement effectué, il faut configurer le Yocto-PWM-Rx pour activer les deux fonctionnalités citées plus haut. Dans notre cas, il faut utiliser un filtre anti-rebond de 5ms et que la l'entrée retourne le nombre d'impulsion.

  • debouncePeriod : 5ms
  • pwmReportMode : Pulse count (nombre d'impulsions observées depuis la dernière ré-initialisation du compteur)


Cela peut être fait à l'aide du VirtualHub ou directement dans le code de l'application comme nous le verrons plus bas.

Maintenant que nous savons comment calculer le nombre de tours que la roue a effectué, voyons ce que nous pouvons en faire.

Le compteur


Le choix que nous avons fait pour ce bricolage est d'utiliser le Yocto-PWM-Rx pour compter les tours de roue, un Yocto-MaxiDisplay pour afficher la valeur courante. Nous avons branché ces deux modules sur un YoctoHub-Wireless-g et l'application sera exécutée sur un Raspberry Pi.

.
.



Nous avons préféré déporter le Raspberry Pi et utiliser un YoctoHub-Wireless-g car cela nous permet d'obtenir un montage plus compact. Ce n'est pas vraiment la taille du Raspberry Pi qui pose problème mais les câbles USB qui rendent tout de suite l'assemblage plus volumineux. Grâce à nos divers fixations et câbles, il est possible d’obtenir un montage plus compact.

L'assemblage est relativement compact
L'assemblage est relativement compact



D'un point de vue logiciel, le fait de déporter le Raspberry Pi ne change rien, il faut simplement utiliser l’adresse IP du YoctoHub à la place de usb lors de l'initialisation de l'API.




L'application


Nous avons décidé d'écrire l'application en C#, plus particulièrement en C# .NET Core 2.1 car cet environnement est très facile à déployer sur un Raspberry Pi ou sur n'importe quel autre ordinateur.

Note: Le code de l'application étant relativement long, nous allons détailler uniquement le passage qui calcule la vitesse de la roue.

Avant d’utiliser l'objet YPwmInput, on s'assure que l'input est correctement configuré.

private void configurePWMInput(YPwmInput pwmInput)
{
    pwmInput.set_debouncePeriod(5);
    pwmInput.set_pwmReportMode(YPwmInput.PWMREPORTMODE_PWM_PULSECOUNT);
    pwmInput.get_module().saveToFlash();
}



Ensuite, on initialise nos variables internes et on enregistre un callback de valeur qui sera appelé automatiquement dès que le Yocto-PWM-Rx détecte le passage de l'aimant.

public void runForever()
{
    ...
    log("use PWM " + pwmInput.get_hardwareId());
    configurePWMInput(pwmInput);

    ResetRun(pwmInput.get_pulseCounter());
    pwmInput.registerValueCallback(count_callback);
    string errmsg = "";
    while (true) {
        YAPI.Sleep(1000, ref errmsg);
        ...
    }
}



Cette fonction de callback reçoit en argument le pulse count, c'est-à-dire
le nombre de fois où l'aimant est passé devant l’ISL. On peu ensuite calculer
la vitesse de la roue en calculant le temps entre chaque appel au callback.

private void count_callback(YPwmInput func, string value)
{
    int count = Int32.Parse(value, CultureInfo.InvariantCulture);
    if (count == _initialCount) {
        return;
    }

    ulong now = YAPI.GetTickCount();
    ulong deltaTime = now - _lastTickCount;


    long deltaCount;
    if (_lastCount > count) {
        deltaCount = count + 999999 - _lastCount;
    } else {
        deltaCount = (count - _lastCount);
    }

    double speed = (double) deltaCount / deltaTime;
    Debug.WriteLine(String.Format("count ={0} time={1} speed={2}",
        count, deltaTime, speed));

    //Update Max speed
    if (_maxSpeedCMS < speed) {
        _maxSpeedCMS = speed;
    }

    _totalCount += deltaCount;
    _lastSpeedCMS = speed;
    _lastTickCount = now;
    _lastCount = count;
}



Il faut ensuite convertir cette vitesse en km/h et l'afficher sur l'écran.

public double getCurrentSpeedKmh()
{
    return _lastSpeedCMS * _perimeterKm * 3600000;
}



L'application permet d'afficher bien plus d'informations que la vitesse courante. Elle permet entre autre d'afficher
les informations suivantes:

  • La vitesse instantanée
  • La vitesse maximum
  • La vitesse moyenne
  • La distance parcourue
  • La durée


Ces informations sont disponibles pour la dernière course du hamster ou de manière journalière. Il est aussi possible d'afficher ces valeurs en km/h ou en mph. Les boutons du Yocto-MaxiDisplay peuvent être utilisés pour changer l'information affichée.

De plus, il est possible de sauvegarder chaque course du hamster dans un fichier CSV afin de pouvoir faire des statistiques plus tard.

Comme d'habitude, le code source de l'application est disponible sur GitHub: https://github.com/yoctopuce-examples/hamster_wheel

Lancer l'application


Nous allons passer sur la compilation et l'installation de l’application sur le Raspberry Pi car nous avons déjà un article dédié à ce sujet. Nous allons simplement décrire comment lancer l'application une fois installée sur le Raspberry Pi.

Pour fonctionner, cette application a besoin que quelques informations supplémentaires qu'il est possible de passer sur la ligne de commande.

Le premier est le diamètre de la roue en millimètres. Ce paramètre est obligatoire et est passé à l'aide de l'option --diameter.

La seconde est l'adresse du YoctoHub. Par défaut l'application utilise les modules qui sont connectés sur les ports USB, mais si comme nous vous déportez vos modules à l'aide d'un YoctoHub, il faut spécifier l'URL du YoctoHub à l'aide de l'option --url

Ensuite, l'application utilise l'entrée du Yocto-PWM-Rx qui est nommée wheel, mais si vous désirez utiliser l'identifiant matériel ou un autre nom logique vous pouvez le spécifier à l'aide de l'option --pwmInput. Note: Si vous n'êtes pas au clair avec la notion d'identifiant matériel ou de nom logique sur nos modules, vous pouvez consulter notre article Structure logique des modules Yoctopuce.

De la même manière, il est possible de spécifier l'identifiant matériel de l'écran et des boutons si la configuration par défaut ne vous convient pas.

Dans notre cas nous utilisons une roue qui a un diamètre de 138 mm et l'adresse du YoctoHub est 192.168.2.49 et nous voulons sauver les statistiques dans un fichier /home/pi/hamster_stat.csv.

La commande pour lancer l'application est donc la suivante:

HamsterWheel --diameter 138 --url 192.168.2.49 --export_csv /home/pi/hamster_stat.csv



Nous n'avons pas besoin de spécifier l'identifiant matériel du Yocto-PWM-Rx car nous avons attribué le nom logique "wheel" à l'entrée sur laquelle est branché l'interrupteur à lames souples.

L'hamster en pleine session de jogging:-)
L'hamster en pleine session de jogging:-)



Conclusion


Cette idée a déjà été réalisée par d'autres bricoleurs, mais tous utilisaient des Arduinos. Nous avons voulu montrer qu'il est possible de réaliser un système similaire avec les modules Yoctopuce.

Comme on peut le voir avec notre solution, l'électronique est très simple, la difficulté consiste à faire un boîtier qui ne soit pas trop gros et hors de portée du rongeur.

Commenter aucun commentaire Retour au blog












Yoctopuce, get your stuff connected.