Micropython-neotrellis-test

Exemple key_pressed

L'exemple key_pressed.py ci-dessus propose de lier l'action du bouton #5 (2ieme ligne, 1iere colonne) pour activer/désactiver une broche du microcontrôleur.

Pour rappel, sur la carte NeoTrellis les boutons sont numéroté de 1 à 16 mais le code Python utilise un index de 0 à 15. Le bouton numéro #5 se trouve donc à l'index numéro 4.

Le broche commandée sera GP25 qui est raccordée sur la LED utilisateur du Pico (à côté de la fiche micro-USB). En modifiant la broche de sortie (ex: GP16) il possible de commander un module relais (ou autre périphériques).

Une pression sur le bouton NeoTrellis et la sortie est activée (le bouton NéoTrellis devient vert).

Une seconde pression sur le bouton NeoTrellis set la sortie est désactivée (le bouton NéoTrellis devient rouge).

Commençons par initialiser les éléments matériels et quelques constantes:

• Création d'une instance du bus I2C.
• Création d'une instance de NeoTrellis (sur l'adresse par défaut 0x2E).
• La luminosité (brightness) des NeoPixel est réduite de moitié pour éviter d'éblouir l'utilisateur.

import time
from machine import I2C, Pin
from neotrellis import NeoTrellis

# Définition de couleurs RGB (rouge, vert, bleu)
# Chaque couleur fondamentale varie entre 0 et 255.
OFF = (0, 0, 0)
RED = (255, 0, 0)   # Rouge
GREEN = (0, 255, 0) # Vert

i2c = I2C( 1, sda=Pin.board.GP6, scl=Pin.board.GP7 )
trellis = NeoTrellis(i2c)
trellis.brightness = 0.5

Passer en revue chaque LED (de 0 à 15) et l'éteindre (en lui assignant la couleur noir).

for i in range(16): 
    trellis.pixels[i] = OFF

Initialiser la broche en sortie (GP25=LED utilisateur), donc niveau bas.

Indiquer que la broches est au niveau bas en passant la LED du bouton #5 en ROUGE (donc à l'index 4 puisque la numérotation démarre à zéro).

relay = Pin( Pin.board.GP25, Pin.OUT, value=False )
trellis.pixels[4] = RED

Définition d'une fonction de rappel toggle_relais() qui sera appelée lorsque le bouton #5 sera pressé.

Les fonctions de rappel sont également dites "callback" en anglais.

def toggle_relay( event ):
    # Accès aux variable globales
    global relay, trellis 
    # Lire état de la broche et inverser le résultat
    new_state = not( relay.value() ) 
    # Application du nouvel état sur la broche
    relay.value( new_state )
    # Placer la LED du bouton 5 en fonction de l'état
    if new_state==True:
        trellis.pixels[4] = GREEN # Vert
    else:
        trellis.pixels[4] = RED   # Rouge

Il faut maintenant associer le bouton #5 (index n° 4) à la fonction de rappel.

# Activer la détection du Flan montage sur le bouton 5 (lorsqu'il est pressé)
trellis.activate_key( 4, NeoTrellis.EDGE_RISING ) 
# Association de la fonction de rappel sur le bouton 5
trellis.callbacks[4] = toggle_relay

Le corps principal du script est exécute dans cette dernière section.

D'une façon générale, cela concerne le script utilisateur ainsi qu'un appel régulier à trellis.sync() .

La méthode sync() interroge le composant SeeSaw afin de détection l'éventualité d'un flan montant/descendant sur une entrée (l'un des "boutons Trellis").

while True:
    # Appel de sync() pour déclencher les fonctions de rappel
    trellis.sync()
    # Intervalle minimum de 17ms entre deux requêtes sur NeoTrellis.
    time.sleep(0.02)

Exemple simpletest

Le second exemple simpletest.py est une adaptation direct de l'exemple fournit par Adafruit Industrie (pour circuitpython).

Cet exemple allume le bouton NeoTrellis pendant que l'utilisateur le maintient enfoncé.

Le script débute par la création de l'instance du bus I2C et du NeoTrellis.

Le script se poursuit par la définition de couleurs

import time
from machine import I2C, Pin
from neotrellis import NeoTrellis

i2c = I2C( 1, sda=Pin.board.GP6, scl=Pin.board.GP7 )
trellis = NeoTrellis(i2c)
trellis.brightness = 0.5 # Luminosité entre 0 et 1.0

# définition de quelques couleurs
OFF = (0, 0, 0)        # Noir = éteind
RED = (255, 0, 0)      # Rouge
YELLOW = (255, 150, 0) # Jaune
GREEN = (0, 255, 0)    # Vert
CYAN = (0, 255, 255)   # Cyan
BLUE = (0, 0, 255)     # Bleu
PURPLE = (180, 0, 255) # Pourpre

Définition de la fonction de rappel appelée lorsqu'un bouton est pressé.

La fonction est la même pour tous les boutons du NeoTrellis, il faudra donc exploiter les propriétés de l'objet event passé en paramètre de la fonction de rappel.

• event.edge : indique l'évènement qui a déclenché le fonction de rappel ( NeoTrellis.EDGE_FALLING ou NeoTrellis.EDGE_RISING).
• event.number : indique l'index du bouton ayant déclenché l'événement.

def blink(event):
    # Allumer la LED lorsque le bouton est enfoncé 
    # (donc sur flan montant).
    if event.edge == NeoTrellis.EDGE_RISING:
        trellis.pixels[event.number] = CYAN
    # Eteindre la LED lorsque le bouton est relâché
    # (donc sur un flan descendant)
    elif event.edge == NeoTrellis.EDGE_FALLING:
        trellis.pixels[event.number] = OFF

Le code ci-dessous active la détection des flan montant et descendant sur chacune des 16 boutons.

Il effectue également l'affection de la fonction de rappel blink() sur chacun des boutons.

Les boutons sont éclairés en pourpre juste après chaque affectation.

for i in range(16): # de 0 à 15
    trellis.activate_key(i, NeoTrellis.EDGE_RISING)
    trellis.activate_key(i, NeoTrellis.EDGE_FALLING)
    trellis.callbacks[i] = blink
    trellis.pixels[i] = PURPLE
    time.sleep(0.05)

Eteindre tous les LEDs

for i in range(16):
    trellis.pixels[i] = OFF
    time.sleep(0.05)

Comme dans l'exemple précédent, le corps principal du script fait un appel régulier à trellis.sync() pour rapatrier les évènements depuis la carte NeoTrellis et appeler les fonctions de rappel.

while True:
    trellis.sync()
    time.sleep(0.02)

---

Traduction augmentée réalisée par Meurisse. D pour shop.MCHobby.be - Licence CC-BY-SA.