Anneau LED

Ce fichier présente les différentes fonctions, enums, topics et objets disponibles avec l’API de l’anneau led.

Anneau LED - Fonctions de commande

Cette section fait référence à toutes les fonctions existantes pour contrôler l’anneau LED”, qui sont plusieurs animations paramétrables. Toutes les fonctions sont accessibles via une instance de la classe NiryoRobot

robot = NiryoRobot(<robot_ip_address>)

robot.led_ring.solid([255, 255, 255])
...

Liste des fonctions:

LedRing

class LedRing(client)[source]

Fonctions de l’anneau LED du robot

Exemple:

ros_instance = NiryoRos("10.10.10.10") # Hotspot
led_ring_interface = LedRing(ros_instance)

Paramètres: client (NiryoRos) – Client Niryo Ros

status[source]

Renvoie le client d’état de l’anneau LED qui peut être utilisé de manière synchrone ou asynchrone pour obtenir l’état actuel de l’anneau LED (cf LedRingStatusObject).

Exemples:

# Get last value
led_ring.status()
led_ring.status.value

# Subscribe a callback
def status_callback(msg):
    print([msg.r, msg.g, msg.b])

led_ring.status.subscribe(status_callback)
led_ring.status.unsubscribe()

Renvoie: Topic d’état de l’anneau LED.
Type renvoyé: NiryoTopic

get_status()[source]

Obtenez le statut de l’anneau LED.

Exemple:

status = led_ring.get_status()
print(status.animation)

Renvoie: Objet avec le mode de actuel du LED ring, l’animation jouée et la couleur utilisée
Type renvoyé: LedRingStatusObject

solid(color)[source]

Réglez l’ensemble de l’anneau Led sur une couleur fixe.

Exemple:

led_ring.solid([15, 50, 255])

Paramètres: color (list[float]) – Couleur de led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
Type renvoyé: None

turn_off()[source]

Éteignez toutes les LED

Exemple:

led_ring.turn_off()

Type renvoyé: None

flash(color, period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Clignote une couleur selon une fréquence. La fréquence est égale à 1 / période.

Exemples:

# Synchronous use
led_ring.flash([15, 50, 255])  # Non-blocking
led_ring.flash([15, 50, 255], 1, 100, False)  # Non-blocking
led_ring.flash([15, 50, 255], iterations=20, wait=True)  # Wait the end

frequency = 20  # Hz
total_duration = 10 # seconds
led_ring.flash([15, 50, 255], 1./frequency, total_duration * frequency , True)

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.flash([15, 50, 255], iterations=20, wait=True, callback=calibration_callback)

Paramètres

color (list[float]) – Couleur de led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
iterations (int) – Nombre de clignotements consécutifs. Si 0, l’anneau LED clignote en continu.
wait (bool) – Le service attend que l’animation termine toutes les itérations ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

alternate(color_list, period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Plusieurs couleurs sont alternées les unes après les autres.

Exemples:

# Synchronous use
color_list = [
    [15, 50, 255],
    [255, 0, 0],
    [0, 255, 0],
]

led_ring.alternate(color_list) # Non-blocking
led_ring.alternate(color_list, 1, 100, False) # Non-blocking
led_ring.alternate(color_list, iterations=20, wait=True) # Blocking

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.alternate(color_list, iterations=20, wait=True, callback=calibration_callback)

Paramètres

color_list (list[list[float]]) – Liste de couleur de LED sous forme d’une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
iterations (int) – Nombre d’alternances consécutives. Si 0, l’anneau LED alterne sans fin.
wait (bool) – Le service attend que l’animation termine toutes les itérations ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

chase(color, period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Animation de “chase” de style lumière de cinéma.

Exemples:

# Synchronous use
led_ring.chase([15, 50, 255]) # Non-blocking
led_ring.chase([15, 50, 255], 1, 100, False) # Non-blocking
led_ring.chase([15, 50, 255], iterations=20, wait=True) # Blocking

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.chase([15, 50, 255], iterations=20, wait=True, callback=calibration_callback)

Paramètres

color (list[float]) – Couleur de led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
iterations (int) – Nombre de poursuites consécutives. Si 0, l’animation continue indéfiniment. Un chase allume juste une LED toutes les 3 LED.
wait (bool) – Le service attend que l’animation termine toutes les itérations ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

wipe(color, period=0, wait=False, callback=None, timeout=None)[source]

Allumez une Led à la fois autour de l’anneau Led, jusqu’à l’allumer entièrement de la même couleur

Exemples:

# Synchronous use
robot.wipe([15, 50, 255])  # Non-blocking
led_ring.wipe([15, 50, 255], 1, False)  # Non-blocking
led_ring.wipe([15, 50, 255], wait=True)  # Blocking

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.wipe([15, 50, 255], wait=True, callback=calibration_callback)

Paramètres

color (list[float]) – Couleur de led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
wait (bool) – Le service attend que l’animation se termine ou ne réponde pas.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

go_up(color, period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Les LED s’allument comme un cercle de chargement, puis s’éteignent toutes en même temps.

Exemples:

# Synchronous use
led_ring.go_up([15, 50, 255])  # Non-blocking
led_ring.go_up([15, 50, 255], 1, 100, False)  # Non-blocking
led_ring.go_up([15, 50, 255], iterations=20, wait=True)  # Blocking

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.go_up([15, 50, 255], period=2, iterations=20, wait=True, callback=calibration_callback)

Paramètres

color (list[float]) – Couleur de led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
iterations (int) – Nombre de tours consécutifs autour de l’anneau LED. Si 0, l’animation continue indéfiniment.
wait (bool) – Le service attend que l’animation se termine ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

go_up_down(color, period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Les LED s’allument comme un cercle de chargement et s’éteignent de la même manière.

Exemples:

# Synchronous use
led_ring.go_up_down([15, 50, 255])  # Non-blocking
led_ring.go_up_down([15, 50, 255], 1, 100, False)  # Non-blocking
led_ring.go_up_down([15, 50, 255], iterations=20, wait=True)  # Blocking

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.go_up_down([15, 50, 255], period=2, iterations=20, wait=True, callback=calibration_callback)

Paramètres

color (list[float]) – Couleur de led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
iterations (int) – Nombre de tours consécutifs autour de l’anneau LED. Si 0, l’animation continue indéfiniment.
wait (bool) – Le service attend que l’animation se termine ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

breath(color, period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Variation de l’intensité lumineuse de l’anneau LED, similaire à la respiration humaine.

Exemples:

# Synchronous use
led_ring.breath([15, 50, 255])  # Non-blocking
led_ring.breath([15, 50, 255], 1, 100, False)  # Non-blocking
led_ring.breath([15, 50, 255], iterations=20, wait=True)  # Blocking

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.breath([15, 50, 255], period=2, iterations=20, wait=True,
    callback=calibration_callback)

Paramètres

color (list[float]) – Couleur de led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
iterations (int) – Nombre de tours consécutifs autour de l’anneau LED. Si 0, l’animation continue indéfiniment.
wait (bool) – Le service attend que l’animation se termine ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

snake(color, period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Un petit serpent coloré (certainement un python :D ) tourne autour de l’anneau LED.

Exemples:

# Synchronous use
led_ring.snake([15, 50, 255]) # Non-blocking
led_ring.snake([15, 50, 255], 1, 100, True) # Blocking

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.snake([15, 50, 255], period=2, iterations=20, wait=True, callback=calibration_callback)

Paramètres

color (list[float]) – Couleur de led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
period (float) – Temps d’exécution d’un motif en secondes. Si 0, la durée par défaut sera utilisée.
iterations (int) – Nombre de tours consécutifs autour de l’anneau LED. Si 0, l’animation continue indéfiniment.
wait (bool) – Le service attend que l’animation se termine ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

rainbow(period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Dessinez un arc-en-ciel qui s’estompe sur toutes les LED à la fois.

Exemples:

# Synchronous use
led_ring.rainbow()  # Non-blocking
led_ring.rainbow(5, 2, True)  # Blocking
led_ring.rainbow(wait=True)  # Blocking

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.rainbow(period=2, iterations=20, wait=True, callback=calibration_callback)

Paramètres

period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
iterations (int) – Nombre d’arcs-en-ciel consécutifs. Si 0, l’animation continue indéfiniment.
wait (bool) – Le service attend que l’animation se termine ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

rainbow_cycle(period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Dessinez un arc-en-ciel qui se répartit uniformément sur toutes les LED.

Exemples:

# Synchronous use
led_ring.rainbow_cycle()
led_ring.rainbow_cycle(5, 2, True)
led_ring.rainbow_cycle(wait=True)

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.rainbow_cycle(period=2, iterations=20, wait=True, callback=calibration_callback)

Paramètres

period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
iterations (int) – Nombre de cycles arc-en-ciel consécutifs. Si 0, l’animation continue indéfiniment.
wait (bool) – Le service attend que l’animation se termine ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

rainbow_chase(period=0, iterations=0, wait=False, callback=None, timeout=None)[source]

Animation de chasse arc-en-ciel, comme la méthode led_ring_chase.

Exemples:

# Synchronous use
led_ring.rainbow_chase()
led_ring.rainbow_chase(5, 2, True)
led_ring.rainbow_chase(wait=True)

# Asynchronous use
def led_ring_callback(result):
    if result["status"] < RobotErrors.SUCCESS.value:
        print("Failed")
    else:
        print("Completed with success")

led_ring.rainbow_chase(period=2, iterations=20, wait=True, callback=calibration_callback)

Paramètres

period (float) – Temps d’exécution d’un motif en secondes. Si 0, le temps par défaut sera utilisé.
iterations (int) – Nombre de cycles arc-en-ciel consécutifs. Si 0, l’animation continue indéfiniment.
wait (bool) – Le service attend que l’animation se termine ou ne réponde pas. Si itérations vaut 0, le service répond immédiatement.
callback (function) – Rappel invoqué en cas d’exécution réussie.
timeout (float) – Délai d’attente de l’opération, en secondes. Utilisé uniquement en cas de blocage.

Type renvoyé

None

custom(led_colors)[source]

Envoie une commande de couleur à toutes les LED de l’anneau LED. La fonction attend une liste de couleurs pour les 30 LED du robot.

Exemple:

led_list = [[i / 30. * 255 , 0, 255 - i / 30.] for i in range(30)]
led_ring.custom(led_list)

run_flag = True

def french_flag_moving():
    colors = []
    colors += [[255, 255, 255] for _ in range(2)]
    colors += [[0, 0, 255] for _ in range(11)]
    colors += [[255, 255, 255] for _ in range(4)]
    colors += [[255, 0, 0] for _ in range(11)]
    colors += [[255, 255, 255] for _ in range(2)]

    rate = 10
    while run_flag:
        for i in range(len(colors)):
            led_ring.custom(colors[i:] + colors[:i])
            time.sleep(1/rate)
            if not run_flag:
                return

french_flag_moving()

Paramètres: led_colors (list[list[float]]) – Liste de taille 30 de couleur led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.
Type renvoyé: None

set_led_color(led_id, color)[source]

Allume une LED d’une seule couleur. Couleur RVB entre 0 et 255.

Exemple:

robot.set_led_color(5, [15, 50, 255])

Paramètres

led_id (int) – Id de la led : entre 0 et 29
color (list[float]) – Couleur de led dans une liste de taille 3[R, G, B]. Canaux RVB de 0 à 255.

Type renvoyé

None

Anneau Led - Niryo Topics

L’utilisation de ces fonctions est expliquée dans la section NiryoTopics. Ils permettent l’acquisition de données en temps réel par rappels ou par appel direct.

Topic Niryo de l’anneau LED
Nom	Fonction	Type de retour
`/status`	`status`	`LedRingStatusObject`

Anneau Led - Énumérations

Liste des énumérations:

AnimationMode
LedMode

class AnimationMode(value)[source]

Énumération des animations disponibles pour que l’utilisateur contrôle l’anneau LED

NONE = -1

UNKNOWN = 0

SOLID = 1

FLASHING = 2

ALTERNATE = 3

CHASE = 4

COLOR_WIPE = 5

RAINBOW = 6

RAINBOW_CYLE = 7

RAINBOW_CHASE = 8

GO_UP = 9

GO_UP_AND_DOWN = 10

BREATH = 11

SNAKE = 12

CUSTOM = 13

class LedMode(value)[source]

Énumération des modes Led disponibles

NONE = -1

UNKNOWN = 0

ROBOT_STATUS = 1

USER = 2

Anneau Led - Objets

class LedRingStatusObject[source]: Objet utilisé pour stocker l’état de l’anneau LED