Contrôleur#

Introduction #

La manette VEX IQ (2e génération) est équipée de boutons et de deux joysticks. Ses méthodes permettent de vérifier les appuis sur les boutons, de lire les mouvements des joysticks, d’activer ou de désactiver les actions configurées, ou encore d’exécuter des fonctions lors d’événements survenant sur la manette.

Le module IQ (2e génération) peut se connecter à une manette IQ (2e génération) ou IQ (1re génération). Une manette IQ (1re génération) doit être équipée d’une radio intelligente bleue.

Les actions de contrôleur configurées correspondent aux comportements définis dans le menu Appareils. Utilisez la commande remote_control_code_enabled pour activer ou désactiver temporairement ces actions pendant un projet.

Cette page utilise le contrôleur controller selon vos besoins.

Vous trouverez ci-dessous la liste de toutes les méthodes disponibles :

Action — Activer ou désactiver les actions configurées du contrôleur.

remote_control_code_enabled — Active ou désactive les actions du contrôleur configurées dans le menu Appareils.

Getters — Lire l’état des boutons et la position du joystick.

.pressing — Renvoie si un bouton spécifié est en cours d’appui.
.position — Renvoie la position d’un axe de joystick spécifié.

Rappels — Exécuter des fonctions lorsque l’entrée du contrôleur change.

.pressed — Exécute une fonction lorsqu’un bouton spécifié est pressé.
.released — Exécute une fonction lorsqu’un bouton spécifié est relâché.
.changed — Exécute une fonction lorsque la position du joystick change le long d’un axe spécifié.

Constructeur — Créez manuellement un objet Contrôleur.

Controller — Crée un objet Contrôleur.

Action #

remote_control_code_enabled #

La variable remote_control_code_enabled active ou désactive les actions de la manette configurées dans le menu « Périphériques ». Ces actions sont activées par défaut.

Usage:
remote_control_code_enabled = state

Valeur	Description
`True`	Active les actions configurées par le contrôleur.
`False`	Désactive les actions configurées du contrôleur.

# Use custom controller code, then re-enable configured actions
remote_control_code_enabled = False

while True:
    if controller.axisA.position() > 0:
        drivetrain.drive(FORWARD)
    elif controller.axisA.position() < 0:
        drivetrain.drive(REVERSE)
    elif controller.buttonEUp.pressing():
        break
    else:
        drivetrain.stop()

    wait(20, MSEC)

remote_control_code_enabled = True

Getters #

.pressing #

.pressing renvoie si un bouton spécifique de la manette est actuellement enfoncé. Cette méthode doit être appelée sur un objet bouton spécifique, tel que controller.buttonEUp.

True — Le bouton spécifié est enfoncé.
False — Le bouton spécifié n’est pas enfoncé.

Utilisation :
L’un des objets bouton disponibles peut être utilisé avec cette méthode :

Bouton	Commande
`buttonEDown`	`controller.buttonEDown.pressing()` — Le bouton E ▼
`buttonEUp`	`controller.buttonEUp.pressing()` — Le bouton E ▲
`buttonFDown`	`controller.buttonFDown.pressing()` — Le bouton F ▼
`buttonFUp`	`controller.buttonFUp.pressing()` — Le bouton F ▲
`buttonL3`	`controller.buttonL3.pressing()` — Bouton joystick gauche, manette IQ (2e génération) uniquement
`buttonLDown`	`controller.buttonLDown.pressing()` — Le bouton L ▼
`buttonLUp`	`controller.buttonLUp.pressing()` — Le bouton L ▲
`buttonR3`	`controller.buttonR3.pressing()` — Bouton du joystick droit, manette IQ (2e génération) uniquement
`buttonRDown`	`controller.buttonRDown.pressing()` — Le bouton R ▼
`buttonRUp`	`controller.buttonRUp.pressing()` — Le bouton R ▲

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Turn right while E Up is held
while True:
    if controller.buttonEUp.pressing():
        drivetrain.turn(RIGHT)
    else:
        drivetrain.stop()

    wait(20, MSEC)

.position #

.position renvoie la position d’un axe de joystick sous forme d’un nombre compris entre -100 et 100.

Cette méthode doit être appelée sur un objet axe spécifique, tel que controller.axisA.

Utilisation :
L’un des objets d’axe disponibles peut être utilisé avec cette méthode :

Manette IQ de 2e génération avec les quatre axes du joystick mis en évidence. Sur le joystick gauche, l'axe A est vertical et l'axe B est horizontal. Sur le joystick droit, l'axe C est horizontal et l'axe D est vertical.

Axe	Commande
`axisA`	`controller.axisA.position()` — Axe vertical du joystick gauche
`axisB`	`controller.axisB.position()` — Axe horizontal du joystick gauche
`axisC`	`controller.axisC.position()` — Axe horizontal du joystick droit
`axisD`	`controller.axisD.position()` — Axe vertical du joystick droit

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# Turn with the left joystick
remote_control_code_enabled = False

while True:
    if controller.axisB.position() > 10:
        drivetrain.turn(RIGHT)
    elif controller.axisB.position() < -10:
        drivetrain.turn(LEFT)
    else:
        drivetrain.stop()

    wait(20, MSEC)

Rappels #

.pressed #

La commande .pressed exécute une fonction lorsque le bouton spécifié est enfoncé. Une fois utilisée, cette fonction s’exécutera automatiquement à chaque pression sur ce bouton.

Utilisation :
L’un des objets bouton disponibles peut être utilisé avec cette méthode :

Bouton	Commande
`buttonEDown`	`controller.buttonEDown.pressed(callback, arg)` — Le bouton E ▼
`buttonEUp`	`controller.buttonEUp.pressed(callback, arg)` — Le bouton E ▲
`buttonFDown`	`controller.buttonFDown.pressed(callback, arg)` — Le bouton F ▼
`buttonFUp`	`controller.buttonFUp.pressed(callback, arg)` — Le bouton F ▲
`buttonL3`	`controller.buttonL3.pressed(callback, arg)` — Bouton joystick gauche, manette IQ (2e génération) uniquement
`buttonLDown`	`controller.buttonLDown.pressed(callback, arg)` — Le bouton L ▼
`buttonLUp`	`controller.buttonLUp.pressed(callback, arg)` — Le bouton L ▲
`buttonR3`	`controller.buttonR3.pressed(callback, arg)` — Bouton du joystick droit, manette IQ (2e génération) uniquement
`buttonRDown`	`controller.buttonRDown.pressed(callback, arg)` — Le bouton R ▼
`buttonRUp`	`controller.buttonRUp.pressed(callback, arg)` — Le bouton R ▲

Paramètre	Description
`callback`	Une fonction précédemment définie à exécuter chaque fois que le bouton spécifié est pressé.
`arg`	Facultatif. Un tuple contenant les arguments à transmettre à la fonction de rappel. Voir Utilisation des événements avec des paramètres pour plus d’informations.

# Drive forward when E Up is pressed
def drive_forward():
    drivetrain.drive_for(FORWARD, 100, MM)

controller.buttonEUp.pressed(drive_forward)

.released #

La commande .released exécute une fonction lorsque le bouton spécifié est relâché. Une fois utilisée, cette fonction s’exécutera automatiquement à chaque relâchement de ce bouton.

Utilisation :
L’un des objets bouton disponibles peut être utilisé avec cette méthode :

Bouton	Commande
`buttonEDown`	`controller.buttonEDown.released(callback, arg)` — Le bouton E ▼
`buttonEUp`	`controller.buttonEUp.released(callback, arg)` — Le bouton E ▲
`buttonFDown`	`controller.buttonFDown.released(callback, arg)` — Le bouton F ▼
`buttonFUp`	`controller.buttonFUp.released(callback, arg)` — Le bouton F ▲
`buttonL3`	`controller.buttonL3.released(callback, arg)` — Bouton joystick gauche, manette IQ (2e génération) uniquement
`buttonLDown`	`controller.buttonLDown.released(callback, arg)` — Le bouton L ▼
`buttonLUp`	`controller.buttonLUp.released(callback, arg)` — Le bouton L ▲
`buttonR3`	`controller.buttonR3.released(callback, arg)` — Bouton du joystick droit, manette IQ (2e génération) uniquement
`buttonRDown`	`controller.buttonRDown.released(callback, arg)` — Le bouton R ▼
`buttonRUp`	`controller.buttonRUp.released(callback, arg)` — Le bouton R ▲

Paramètre	Description
`callback`	Une fonction précédemment définie à exécuter chaque fois que le bouton spécifié est relâché.
`arg`	Facultatif. Un tuple contenant les arguments à transmettre à la fonction de rappel. Voir Utilisation des événements avec des paramètres pour plus d’informations.

# Stop driving when E Up is released
def stop_driving():
    drivetrain.stop()

controller.buttonEUp.released(stop_driving)

.changed #

La fonction changed (valeur .changed exécute une fonction lorsque la position du joystick change le long de l’axe spécifié. Une fois utilisée, cette fonction s’exécutera automatiquement à chaque changement de position du joystick le long de cet axe.

Utilisation :
L’un des objets d’axe disponibles peut être utilisé avec cette méthode :

Axe	Commande
`axisA`	`controller.axisA.changed(callback, arg)` — Axe vertical du joystick gauche
`axisB`	`controller.axisB.changed(callback, arg)` — Axe horizontal du joystick gauche
`axisC`	`controller.axisC.changed(callback, arg)` — Axe horizontal du joystick droit
`axisD`	`controller.axisD.changed(callback, arg)` — Axe vertical du joystick droit

Paramètre	Description
`callback`	Une fonction précédemment définie à exécuter chaque fois que la position du joystick change le long de l’axe spécifié.
`arg`	Facultatif. Un tuple contenant les arguments à transmettre à la fonction de rappel. Voir Utilisation des événements avec des paramètres pour plus d’informations.

# Play a sound when the right joystick moves
def beep():
    brain.play_sound(SoundType.TADA)

controller.axisD.changed(beep)

Constructeurs #

Controller #

Controller crée un objet Contrôleur. La création manuelle d’un objet Contrôleur n’est nécessaire que lors de la configuration d’un contrôleur en dehors de VEXcode.

Usage:
Controller()

Paramètres	Description
	Ce constructeur n’a pas de paramètres.

# Create a Controller object
my_controller = Controller()