Un Jumping Jack auditif, version Google Coral TPU Accelerator : 4 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Il bouge ses membres, il écoute vos ordres, il est piloté par la dernière technologie d'apprentissage automatique

Le « Hearing Jumping Jack » est un simple Jumping Jack électromécanique, entraîné par deux micro servos et un engrenage très simple, ayant des LED comme « yeux ». Il est contrôlé par de simples commandes vocales indiquant laquelle des neuf positions prédéfinies il doit prendre, ou si la LED doit être allumée ou éteinte, ou s'il doit effectuer une "danse" prédéfinie ou un ensemble aléatoire de mouvements.

L'élément central du système est l'accélérateur Google Coral TPU, qui permet d'exécuter des modèles Tensorflow Lite hors ligne à très haute vitesse, même sur un ordinateur "faible" comme le Raspberry Pi. Cela permet par ex. identification et classification rapides d'objets à l'aide de la caméra RPi, mais aussi pour exécuter localement des fonctions de reconnaissance vocale basées sur l'apprentissage automatique.

À ma connaissance, il s'agit du premier exemple publié d'un dispositif de bricolage physique basé sur la détection vocale Coral Accelerator, et l'exemple de code ci-joint pourrait également être utilisé pour d'autres projets plus complexes.

La commande vocale est basée sur l'exemple "le serpent auditif" dans le "project keyword spotter" (https://github.com/google-coral/project-keyword-spotter) qui a récemment (septembre 2019) été placé sur GitHub. Dans ma configuration, le système est composé d'un Raspberry Pi 4 équipé d'un servo bonnet Adafruit 16 canaux, d'un Google Coral TPU Accelerator et d'une webcam, ici utilisée comme micro. Le Jumping Jack avait déjà été décrit dans un précédent instructable, où il était piloté par le kit Google Voice pour lire les commandes vocales, est attaché au Servo Bonnet dans la version 2.0 décrite ci-dessous.

La version précédente de Google Voice Kit avait trois limitations centrales: elle dépendait des services de reconnaissance vocale basés sur le Web de Google et la configuration était relativement compliquée, il fallait appuyer sur une sorte de bouton avant de pouvoir donner une commande, et il y avait un sérieux retard entre dire la commande et la réponse du système. L'utilisation de l'accélérateur Google Coral réduit le temps de réponse à quelques secondes, est indépendante d'une connexion Internet et écoute tout le temps. Avec quelques modifications, vous pouvez l'utiliser pour contrôler des appareils beaucoup plus complexes comme un Jumping Jack, des robots ou des voitures, ou tout ce que vous pouvez construire et contrôler avec un Raspberry Pi.

Dans sa version actuelle, le Keyword Spotter comprend un ensemble d'environ 140 mots-clés/phrases-clés courts, définis dans le fichier modèle d'accompagnement ("voice_commands_v0.7_egetpu.tflite") et décrits dans un fichier d'étiquette séparé ("labels_gc2.raw.txt"). Défini par un fichier librement modifiable (« commands_v2_hampelmann.txt »), les mots-clés utilisés spécifiquement par notre script sont ensuite mappés sur des frappes sur un clavier virtuel, par ex. pour les lettres, les chiffres, haut/bas/gauche/droite, crtl+c, et cetera.

Ensuite, par ex. en utilisant pygame.key, ces « frappes » sont lues et utilisées pour contrôler les actions qu'un appareil, ici le jumping jack, doit effectuer. Dans notre cas, cela signifie conduire les deux servos vers des positions prédéfinies, ou allumer ou éteindre les LED. Comme l'observateur de mots clés fonctionne dans une bande de roulement distincte, il peut écouter en permanence vos commandes.

Version 21 septembre 2019

Fournitures

Raspberry Pi 4, via Pimoroni

Accélérateur Google Coral TPU, via Mouser Allemagne, 72€

Adafruit 16 Servo Bonnet, via Pimoroni, environ 10 €

www.adafruit.com/product/3416

learn.adafruit.com/adafruit-16-channel-pwm…

En-tête d'empileur (si nécessaire)

www.adafruit.com/product/2223

4x piles AA (ou autre source d'alimentation 5-6V) pour Servo Bonnet

Ancienne webcam, comme microphone

Jumping Jack à servomoteur, comme décrit dans un précédent instructable. Les dessins d'implantation sont joints à l'étape suivante, mais peuvent nécessiter des ajustements.

Pièces requises pour le Jumping Jack:

- Plaque Forex 3 mm

- 2 micro servos

- Vis et écrous de 2 et 3 mm

- 2 LED blanches et une résistance

- un peu de câble

Étape 1: configuration de l'appareil

Pour construire le Jumping Jack, veuillez suivre les indications données dans une précédente instructable. J'ai utilisé le Forex pour mon prototype, mais vous pouvez utiliser des plaques d'acrylique ou de contreplaqué découpées au laser. Vous devrez peut-être ajuster la disposition en fonction de la taille de vos servos, etc. Testez si les membres et l'équipement peuvent bouger sans friction.

Configurez votre Raspberry Pi. Sur le site Coral Github, une image Raspian est disponible qui contient tout le nécessaire pour exécuter l'accélérateur Coral sur le Pi et contient de nombreux projets, avec tous les paramètres déjà en place.

Obtenez l'outil d'identification des mots clés du projet sur la page Google Coral GitHub. Installez tous les logiciels requis comme indiqué.

Installez les fichiers fournis. Placez le script python jumping jack dans le dossier de recherche de mots-clés du projet et le fichier de commandes correspondant dans le sous-dossier config.

Fixez le capot de servomoteur Adafruit au Pi. Comme j'utilise un boîtier RPI avec un ventilateur, j'ai dû utiliser des empileurs GPIO (par exemple disponibles chez Pimoroni) pour permettre la connexion. Installez toutes les bibliothèques requises, comme indiqué sur les instructions Adafruit pour le capot du servo.

Fixez une source d'alimentation 5-6V au capot du servo. Fixez les servos et les LED. Dans mon cas, j'ai utilisé le port 0 pour les LED et les ports 11 et 15 pour les servos.

Pour tout vérifier, je recommanderais d'essayer d'abord l'exemple du mot-clé spotter "hearing snake" et les exemples de servo bonnet Adafruit.

Étape 2: exécuter le Jumping Jack

Si toutes les pièces sont configurées et fonctionnent, essayez de l'utiliser. Vous pouvez exécuter le script dans l'IDE ou à partir de la ligne de commande.

Crier "position 0" à "position 9" incitera le Jumping Jack à prendre l'une des positions prédéfinies. J'ai défini "1" comme les deux bras levés (uu), "3" comme gauche vers le haut, droite vers le bas (ud), "9" comme les deux bras vers le bas (dd) et "5" comme les deux bras centrés (cc).

uu uc ud = 1 2 3

cu cc cd = 4 5 6

du dc dd = 7 8 9

"0" est identique à "5". "3" et "8" ne sont pas très bien reconnus par le mot-clé spotter et peuvent devoir être répétés.

Vous devrez peut-être ajuster les valeurs minimales et maximales pour chaque servo/côté afin que les servos ne soient pas bloqués et consomment alors trop de puissance.

"next game" lancera la "dance", c'est-à-dire une séquence définie de positions, tandis que "random game" lancera le Jumping Jack pour effectuer une séquence aléatoire de mouvements. Dans les deux cas, ils fonctionneront pour toujours, vous devrez donc peut-être arrêter les mouvements, par ex. avec une commande "position zéro".

"stop game" évoquera un "ctrl + c" et arrêtera le processus.

"switch on" et "switch off" peuvent être utilisés pour allumer et éteindre les LED.

En modifiant les valeurs time.sleep vous pouvez ajuster la vitesse des mouvements.

Étape 3: Le code et le fichier de commandes

Le code présenté ici est une modification du code "hearing snake" qui fait partie du package de recherche de mots-clés du projet. J'ai juste supprimé tout ce qui n'était pas nécessaire pour ma candidature, sans aucune réelle compréhension des détails. Toute amélioration est la bienvenue.

J'ai ensuite ajouté les pièces requises pour le Adafruit Servo Bonnet, en fonction de leurs fichiers d'exemple.

Je tiens à remercier les programmeurs des deux parties.

Le code peut être trouvé en pièce jointe sous forme de fichier. Utilisez-le à vos risques et périls, modifiez-le, améliorez-le, jouez avec.

# Copyright 2019 Google LLC

# # Sous licence Apache, version 2.0 (la « Licence »); # vous ne pouvez pas utiliser ce fichier sauf en conformité avec la Licence. # Vous pouvez obtenir une copie de la Licence à l'adresse # # https://www.apache.org/licenses/LICENSE-2.0 # # Sauf si requis par la loi applicable ou convenu par écrit, le logiciel # distribué sous la Licence est distribué sur un BASE « EN L'ÉTAT », # SANS GARANTIE NI CONDITIONS D'AUCUNE SORTE, expresses ou implicites. # Consultez la licence pour connaître les autorisations et les # limitations spécifiques à la langue en vertu de la licence. de _future_ importer Absolute_import de _future_ import division de _future_ import print_function importer argparse importer os d'import aléatoire randint à partir du threading import Temps d'import de thread depuis edgetpu.basic.basic_engine import BasicEngine import model import pygame depuis pygame.locals import * file d'attente d'import aléatoire randrange de adafruit_servokit import ServoKit import board import busio import adafruit_pca9685 import time i2c = busio. I2C(board. SCL, board. SDA) hat = adafruit_pca9685. PCA9685(i2c) hat.fréquence = 60 kit = ServoKit(channels=16) # set number des canaux #kit.servo[0].actuation_range = 160 #kit.servo[0].set_pulse_width_range(1000, 2000) # réglages haut, milieu et bas pour les bras gauche et droit up_l = 35 md_l = 90 dn_l = 160 up_r = 160 md_r = 90 dn_r = 35

lft= 15 # numéro de port servo, servo gauche (0-8)

rgt= 11 # numéro de port servo, servo droit (0-8) led_channel_0 = hat.channels[0] # LED réglée sur le port 0 led_channel_0.duty_cycle = 0 #allumer la LED 100% #liste des réglages du bras pour la position neuf positions = [(md_l, md_r), (up_l, up_r), (up_l, md_r), (up_l, dn_r), (md_l, up_r), (md_l, md_r), (md_l, dn_r), (dn_l, up_r), (dn_l, md_r), (dn_l, dn_r)] # définit 9 positions JumpingJack, indiquées par des entiers 0-9 dance1 =(0, 8, 7, 4, 1, 2, 3, 6, 9, 8, 5, 2, 1, 4, 7, 8, 9, 6, 3, 2, 0) # une classe "dance" Contrôleur(objet): #Callback function def _init_(self, q): self._q = q def callback(self, commande): self._q.put(command) class App: def _init_(self): self._running = True def on_init(self): pygame.init() self.game_started = True self._running = True return True def on_event(self, event): if event.type == pygame. QUIT: self._running = False def JumpingJack0(self, keys): # contrôles Jumping Jack, mots-clés: "position x" key = int(keys) p = position [touche] a = p[0] b = p[1] imprimer ("Position: ", touche, " gauche /right: ", a, "/", b, "degree") # sys.stdout.write("Position: ", key, " left/right: ", a, "/", b, "degree") kit.servo[lft].angle = a kit.servo[rgt].angle = b time.sleep(0.1) def JumpingJack1(self): # contrôle Jumping Jack dance, mot-clé: "prochain jeu" dnce = dance1 sp=(len(dnce)) for r in range (sp): #dancing order of positions, sp steps dc = dnce[r] if (dc not in range(10)): # print ("erreur d'entrée à la position ", sp) dc=4 p = position[dc] a = p[0] b = p[1] kit.servo[lft].angle = a kit.servo[rgt].angle = b time.sleep(0.25) # définit la vitesse de mouvements def JumpingJack2(self, keys): # contrôle les LED Jumping Jack, mots-clés: "switch on/off" led = int(keys) if led == 1: led_channel_0.duty_cycle = 0xffff #allumer la LED 100% time.sleep (0.1) if led == 0: led_channel_0.duty_cycle = 0 # éteindre la LED time.sleep (0.1) if led == 2: # clignoter led_channel_0.duty_cycle = 0xffff #allumer la LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0 #allumer la LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0xffff #allumer la LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0 #allumer la LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0xffff #allumer la LED 100% time.sleep (0.1) def JumpingJack3(self): # contrôle la danse Jumping Jack, mot-clé: "random game" # pour h dans la plage (10): dr= randrange (9) p = position[dr] a = p[0] b = p[1] kit.servo [lft].angle = a kit.servo[rgt].angle = b time.sleep(0.25) # définit la vitesse des mouvements def spotter(self, args): engine = BasicEngine(args.model_file) mic = args.mic if args.mic est None else int(args.mic) model.classify_audio(mic, engine, labels_file="config/labels_gc2.raw.txt", command_file="config/commands_v2_hampelmann.txt", dectection_callback=self._controler.callback, sample_rate_hz=int(args.sample_rate_hz), num_frames_hop=int(args.num_frames_hop))

def on_execute(self, args):

sinon self.on_init(): self._running = False q = model.get_queue() self._controler = Controler(q) sinon args.debug_keyboard: t = Thread(target=self.spotter, args=(args,)) t.daemon = True t.start() item = -1 while self._running: pygame.event.pump() if args.debug_keyboard: keys = pygame.key.get_pressed() else: try: new_item = q.get (True, 0.1) sauf queue. Empty: new_item = None si new_item n'est pas None: item = new_item if (args.debug_keyboard and keys[pygame. K_ESCAPE]) ou item == "stop": self._running = False # if (args.debug_keyboard and keys[pygame. K_SPACE]) ou item == "go": # self. JumpingJack0(7) # if (args.debug_keyboard and keys[pygame. K_RIGHT]) ou item == "right": self. JumpingJack0(6) if (args.debug_keyboard and keys[pygame. K_LEFT]) ou item == "left": self. JumpingJack0(4) if (args.debug_keyboard and keys[pygame. K_UP]) ou item == " up": self. JumpingJack0(1) if (args.debug_keyboard and keys[pygame. K_DOWN]) ou item == "down": self. JumpingJack0(9) if (args.debug_keyboard and keys[pygam e. K_0]) ou item == "0": self. JumpingJack0(0) if (args.debug_keyboard and keys[pygame. K_1]) ou item == "1": self. JumpingJack0(1) if (args. debug_keyboard et keys[pygame. K_2]) ou item == "2": self. JumpingJack0(2) if (args.debug_keyboard and keys[pygame. K_3]) ou item == "3": self. JumpingJack0(3) if (args.debug_keyboard and keys[pygame. K_4]) or item == "4": self. JumpingJack0(4) if (args.debug_keyboard and keys[pygame. K_5]) or item == "5": self. JumpingJack0(5) if (args.debug_keyboard and keys[pygame. K_6]) ou item == "6": self. JumpingJack0(6) if (args.debug_keyboard and keys[pygame. K_7]) ou item == "7 ": self. JumpingJack0(7) if (args.debug_keyboard and keys[pygame. K_8]) or item == "8": self. JumpingJack0(8) if (args.debug_keyboard and keys[pygame. K_9]) or item == "9": self. JumpingJack0(9) if (args.debug_keyboard and keys[pygame. K_a]) ou item == "d": self. JumpingJack1() #dancing Jack, on "next_game" if (args. debug_keyboard et keys[pygame. K_j]) ou item == "j": self. JumpingJack2(0) #LED on, ON " switch_on" if (args.debug_keyboard and keys[pygame. K_k]) ou item == "k": self. JumpingJack2(1) #LED éteinte, on "swithch off" if (args.debug_keyboard and keys[pygame. K_l]) ou item == "l": self. JumpingJack2(1) #LED clignoter "target" if (args.debug_keyboard and keys[pygame. K_r]) ou item == "r": self. JumpingJack3() #random dance "jeu aléatoire" time.sleep(0.05) self.on_cleanup() if _name_ == '_main_': parser = argparse. ArgumentParser() parser.add_argument('--debug_keyboard', help='Utilisez le clavier pour contrôler le JumpingJack.', action='store_true', default=False) model.add_model_flags(parser) args = parser.parse_args() the_app = App() the_app.on_execute(args)

Il existe également le fichier de configuration de commande "commands_v2_hampelmann.txt". Modifiez à votre guise. C'est juste une liste de combinaisons "commande, clé, (force,)", basée sur le fichier d'étiquette.

position_zéro, 0, position_one, 1, position_two, 2, position_three, 3, position_four, 4, position_five, 5, position_six, 6, position_seven, 7, position_eight, 8, position_nine, 9, move_up, up, go_up, up, move_down, down, go_down, bas, move_backwards, gauche, move_forwards, droite, go_backwards, gauche, go_forwards, droite, 0.8 cible, l, muet, z, oui, y, non, n, switch_on, j, switch_off, k, volume_up, haut, volume_down, bas, next_game, d, random_game, r, start_game, s, stop_game, ctrl+c,

Étape 4: Autres idées et autres exemples

Il est bien évident que ce paramètre peut également être utilisé pour contrôler des robots ou d'autres appareils. En gros, tout ce qui peut être contrôlé par un Raspberry Pi.

Je travaille sur une extension du script pour piloter un MeArm, et j'espère pouvoir la présenter en octobre 2019.

J'envisage également d'utiliser le Jumping Jack comme sémaphore et d'utiliser le programme de reconnaissance de position des membres "project posenet" comme outil pour lire les positions du Jumping Jack et les traduire en nombre. De cette façon, il peut même communiquer du texte, étant donné que 2x 8 positions peuvent indiquer 64 chiffres différents, plus que suffisant pour l'alphabet, les chiffres et les signes. Cela pourrait permettre, bien que légèrement modifié, une réalisation physique pour le projet IETF "La transmission de datagrammes IP sur le système de signalisation de drapeau de sémaphore (SFSS)" (https://tools.ietf.org/html/rfc4824).

Mais ce sera un autre instructable. Et, comme les premières expériences l'ont indiqué, le jumping jack aura besoin d'importantes modifications avant qu'il ne soit reconnu comme humain par le système d'IA, cela peut prendre un certain temps.

Je voudrais attirer votre attention sur l'instructable suivante: Object-Finding-Personal-Assistant-Robot-Ft-Raspberry, où un robot de recherche d'objets utilisant une combinaison de Raspberry Pi et Google Coral TPU est décrit.