Pico : Radio RC & détection de longueur d'impulsion sous MicroPython

Peut-être vous souvenez-vous du projet "PYBStick : Projet Zumo" permettant de créer un robot à l'aide de moteurs continu a commande servo.

Source: PYBStick : Projet Zumo

Télécommander comme un Tank

C'est justement le mode de contrôle des moteurs qui m'intéresse puisque, depuis peu, j'ai une télécommande RC (pour contrôle de modèle réduit) que je vais utiliser pour créer des projets robotiques plus avancés.

Commande Carson à 14 canaux

La télécommande propose 14 canaux répartis comme suit

Pour contrôler un mobile, il ne faut que deux canaux:

1 canal pour la direction et
1 canal pour les gaz (commande moteur).

De là à imaginer son utilisation avec les moteurs à commande servo, il n'y a qu'un pas!

Voici donc la plateforme Zumo à moteur continu (commande RC) branché sur le récepteur RC.

Il ne s'agit pas ici d'une motorisation standard (un servo pour la direction et un pour les gaz... ) alors le montage standard ,tel que repris ci-dessous, des canaux 1 & 2 (ou 1 & 3) ne s'applique pas.

Source: Pulse-In en MicroPython

Dans le cas présent, il faut commander les deux moteurs en marche avant, marche arrière... comme un Tank!

Le mieux est d'utiliser les canaux 2 et 3 pour créer une commande type Tank... mais attention, il faut paramétrer la télécommande pour inverser le contrôle d'un des canaux (puisque l'un des deux moteurs est monté à l'envers par rapport à l'autre).

Utilisation des canaux 2 & 3 (commande type Tank).

Conclusion

C'est très amusant mais pas vraiment pratique en toute circonstances.

Pour autant que l'on se trouve à l'arrière du mobile, c'est assez commode a contrôler.
Face à soi: la commande des chenilles n'est pas très intuitif... et c'est encore plus difficile s'il faut tourner à droite ou à gauche dans cette condition.

De la nécessiter de mesurer la longueur d'impulsion

Ce qui serait plus facile, c'est de pouvoir commander les moteurs/chenilles avec les canaux 1 & 3.

Avant/Arrière: pour la vitesse.
Droite/Gauche: courber le déplacement vers la droite ou vers la gauche (ralentissant un moteur par rapport à l'autre)

Cela nécessitera de placer un microcontrôleur (un Raspberry-Pi Pico par exemple) entre le récepteur RC et les moteurs. De sorte à lire les canaux 1 & 3.... puis convertir ces signaux pour commander un moteurs.

Il faudra donc pouvoir décodé les signaux du récepteur RC avec MicroPython.

Source: Tutoriel Pulse-In sur le Pico avec MicroPico

En manipulant le levier, on s’aperçoit que le signal 5V à une fréquence de 50Hz et une largeur d'impulsion de 0.850ms (850µSec) à 2.15ms (2150µSec). La largeur d'impulsion correspond au niveau haut du signal.

Lecture du signal avec MicroPython

Il ne reste plus qu'à brancher le signal la carte MicroPython. Mais attention, le signal est en 5V et la carte MicroPython en logique 3.3V ... nous allons donc utiliser une petite astuce reposant sur la diode de protection interne de l'entrée du Pico. La résistance de 10K protège l'entrée ;-)

Source: Tutoriel Pulse-In sur le Pico avec MicroPicon

La classe PWMCounter (voyez le tutoriel) permet de réaliser la mesure. Il exploite le un compteur PWM à 125 Mhz.

from machine import Pin
from PWMCounter import PWMCounter

# Initialise la broche en entrée
in_pin = Pin(13, Pin.IN)
# Compter lorsque le signal est au niveau haut
counter = PWMCounter(13, PWMCounter.LEVEL_HIGH)
# Fixer le diviseur du compteur à 16 (pour éviter le dépassement du compteur)
counter.set_div(16)
# Démarrer le compteur
counter.start()

last_state = 0
while True:
    x = in_pin.value()
    if ~(x) & last_state:
        # Longueur d'impulsion en micro-secondes
        print((counter.read_and_reset() * 16) / 125)
    last_state = x

Ce script produit les réponses respectives de 2131 µSec et 861 µSec.