Incrémenter des variables avec un Joystick¶

Ce que l'on va faire ici¶

Dans ce programme Micropython, nous allons voir comment incrémenter des variables à l'aide d'un Joystick, ce qui est finalement la base de l'utilisation utile d'un Joystick pour des réglages, etc.

Un joystick est l'association :

de 2 résistances variables, une pour chaque axe X et Y
d'un bouton poussoir.

Matériel¶

une carte Pi Pico flashée avec MicroPython et préparée pour utilisation en vertical sur plaque d'essai

un module "prêt à câbler" Joystick

une petite plaque d'essai

quelques jumpers

Le montage à réaliser¶

On utilise ici la carte Pi Pico en vertical sur la plaque d'essai.

On utilise les broches suivantes :

le bouton poussoir est sur GP22
X est sur ADC0
Y est sur ADC1

Le module est connecté par ailleurs au 3.3V et à GND.

Le code¶

Info

Toute la "difficulté" est d'évaluer rapidement l'état d'un axe... et une façon simple de le faire est de considérer 3 "sections" de la mesure :

si on est entre 0 et 1/3, alors c'est -1
si on est entre 1/3 et 2/3, alors c'est 0
si on est entre 2/3 et 1, alors c'est +1

Une façon simple de faire çà est de réaliser une opération de division entière // entre la mesure et le 1/3 de la pleine échelle à savoir 21845+1=21846. Et de retrancher 1 au résultat, ce qui donnera directement la valeur à ajouter à la variable concernée.

pour chaque axe X et Y, on déclare un objet ADC basé sur la broche ADC0 (X) et ADC1 (Y)
on met en entrée avec rappel au plus la broche sur laquelle est connecté le bouton poussoir
on lit les valeurs à intervalle régulier, à l'aide d'un Timer

La fonction read_u16() renvoie une valeur 16 bits, bien que la mesure soit en 12 bits.

# code Micropython - www.micropython.fr - CC-BY-SA

from machine import Pin, ADC, Timer

bp=Pin(22,Pin.IN, Pin.PULL_UP) # rappel au plus
axisX=ADC(0) # axe X
axisY=ADC(1) # axe Y

x,y,a=0,0,0 # valeurs initiales des variables de comptage

timer=Timer()

def loop(timer):

    global x,y,a # utilise variables globales

    #print("X="+str(axisX.read_u16()))
    #print("Y="+str(axisY.read_u16()))
    #print("BP="+str(bp.value()))

    dx=(axisX.read_u16()//21846)-1 # division entiere
    #print(dx)
    x=x+dx
    print("x:"+str(x))

    dy=(axisY.read_u16()//21846)-1 # division entiere
    #print(dx)
    y=y+dy
    print("y:"+str(y))

    da=bp.value()
    a=a+da
    print("appuis:"+str(a))

timer.init(freq=5, callback=loop)

Résultat¶

Les variables s'incrémentent en fonction de la position du joystick dans chaque axe et si appui sur le BP.

Note

On peut imaginer toutes sortes de variations :

bloquer le comptage / décomptage avec une valeur supérieure/inférieure
prévoir une progression plus fine, avec incrément de 0.5... et du coup en prévoyant 5 "sections" au lieu de 3
etc.

Durée exécution¶

Si on teste la durée d'exécution de ce code en faisant :

from machine import Pin, ADC, Timer
import utime

bp=Pin(22,Pin.IN, Pin.PULL_UP) # rappel au plus
axisX=ADC(0) # axe X
axisY=ADC(1) # axe Y

x,y,a=0,0,0 # valeurs initiales des variables de comptage

timer=Timer()

def loop(timer):

    start=utime.ticks_us()

    global x,y,a # utilise variables globales

    #print("X="+str(axisX.read_u16()))
    #print("Y="+str(axisY.read_u16()))
    #print("BP="+str(bp.value()))

    dx=(axisX.read_u16()//21846)-1 # division entiere
    #print(dx)
    x=x+dx
    #print("x:"+str(x))

    dy=(axisY.read_u16()//21846)-1 # division entiere
    #print(dx)
    y=y+dy
    #print("y:"+str(y))

    da=bp.value()
    a=a+da
    #print("appuis:"+str(a))

    print(utime.ticks_diff(utime.ticks_us(),start)/1000)

timer.init(freq=5, callback=loop)

On trouve :

9ms avec les print
0.1ms sans les print (sauf le timeit... ) ce qui est donc assez rapide, malgré le calcul.