Sluchový skákajúci jack, verzia Google Coral TPU Accelerator: 4 kroky

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 11:57

Hýbe končatinami, počúva vaše príkazy, poháňa ju najnovšia technológia strojového učenia

„Hearing Jumping Jack“je jednoduchý elektromechanický skokanský zdvihák poháňaný dvoma mikro servami a veľmi jednoduchým prevodom s LED diódami ako „očami“. Ovláda sa jednoduchými hlasovými príkazmi, ktoré naznačujú, ktorú z deviatich preddefinovaných polôh má zaujať, alebo či má dióda LED zapnúť alebo vypnúť, alebo či má vykonať preddefinovaný „tanec“alebo náhodnú sadu pohybov.

Základným prvkom systému je akcelerátor Google Coral TPU, ktorý umožňuje prevádzkovať modely Tensorflow Lite offline veľmi vysokou rýchlosťou, a to dokonca aj na „slabom“počítači, akým je Raspberry Pi. To umožňuje napr. rýchla identifikácia a klasifikácia objektov pomocou kamery RPi, ale aj lokálne spustenie funkcií rozpoznávania hlasu založeného na strojovom učení.

Pokiaľ je mi známe, toto je prvý publikovaný príklad fyzického zariadenia DIY poháňaného detekciou hlasu Coral Accelerator a priložený príklad kódu je možné použiť aj na iné, komplexnejšie projekty.

Ovládanie hlasom je založené na príklade „sluchový had“v „vyhľadávači kľúčových slov projektu“(https://github.com/google-coral/project-keyword-spotter), ktorý bol nedávno (september 2019) umiestnený na GitHub. V mojej konfigurácii je systém tvorený Raspberry Pi 4 vybaveným 16 -kanálovou servo kapotou Adafruit, akcelerátorom Google Coral TPU a webovou kamerou, ktorá sa tu používa ako mikrofón. Jumping Jack bol popísaný predtým v predchádzajúcom návode, kde ho poháňala súprava Google Voice na čítanie hlasových príkazov, je pripevnený k servo kapote vo verzii 2.0, ktorá je popísaná v nasledujúcom texte.

Predchádzajúca verzia súpravy Google Voice Kit mala tri hlavné obmedzenia: záviselo to od webových služieb Googlu na rozpoznávanie hlasu a nastavenie bolo pomerne komplikované, pred zadaním príkazu bolo potrebné stlačiť nejaké tlačidlo a došlo k vážnemu oneskoreniu. medzi vyslovením príkazu a reakciou systému. Použitie akcelerátora Google Coral skracuje reakčný čas na sekundy, je nezávislý na internetovom pripojení a neustále počúva. S určitými úpravami ho môžete použiť na ovládanie zariadení oveľa zložitejších ako skákací zdvihák, ako roboty alebo autá alebo čokoľvek, čo môžete pomocou Raspberry Pi stavať a ovládať.

V aktuálnej verzii nástroj na vyhľadávanie kľúčových slov rozumie súboru asi 140 krátkych kľúčových slov/kľúčových fráz, definovaných v sprievodnom modelovom súbore („voice_commands_v0.7_egetpu.tflite“) a popísaných v samostatnom súbore štítkov („labels_gc2.raw.txt“). Definované voľne upraviteľným súborom („commands_v2_hampelmann.txt“), kľúčové slová používané konkrétne našim skriptom sa potom mapujú na stlačenia klávesov na virtuálnej klávesnici, napr. pre písmena, číslice, hore/dole/vľavo/vpravo, crtl+c, atď.

Potom napr. pomocou pygame.key sa tieto „stlačenia klávesov“načítajú a používajú sa na ovládanie, aké akcie bude zariadenie, tu skákací zdvihák, vykonávať. V našom prípade to znamená presunúť dve servá do preddefinovaných polôh alebo zapnúť alebo vypnúť LED diódy. Pretože vyhľadávač kľúčových slov beží v samostatnom dezéne, môže trvalo počúvať vaše objednávky.

Verzia 21. septembra 2019

Zásoby

Raspberry Pi 4, cez Pimoroni

Google Coral TPU Accelerator, cez Mouser Germany, 72 €

Servo kapota Adafruit 16, cez Pimoroni, asi 10 €

www.adafruit.com/product/3416

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

Hlavička stohovača (ak je to potrebné)

www.adafruit.com/product/2223

Batéria 4x AA (alebo iný zdroj napájania 5-6 V) pre servopohon

Stará webová kamera ako mikrofón

Servo poháňaný skákací zdvihák, ako je popísané v predchádzajúcom návode. Výkresy rozloženia sú priložené k ďalšiemu kroku, ale môžu vyžadovať úpravy.

Požadované diely pre skákací zdvihák:

- Forexová doska 3 mm

- 2 mikro servá

- 2 a 3 mm skrutky a matice

- 2 biele LED diódy a rezistor

- trochu kábla

Krok 1: Nastavenie zariadenia

Pri stavbe skákacieho zdviháka dodržujte pokyny uvedené v predchádzajúcom návode. Pre svoj prototyp som použil Forex, ale môžete použiť laserom rezané akrylové alebo preglejkové dosky. Možno budete musieť upraviť rozloženie podľa veľkosti vašich serv a pod. Otestujte, či sa končatiny a prevodový stupeň môžu pohybovať bez trenia.

Nastavte si Raspberry Pi. Na webe Coral Github je k dispozícii obrázok Raspian, ktorý obsahuje všetko potrebné na spustenie akcelerátora Coral na Pi a obsahuje množstvo projektov so všetkými nastaveniami, ktoré sú už k dispozícii.

Získajte vyhľadávač kľúčových slov projektu zo stránky Google Coral GitHub. Nainštalujte všetok požadovaný softvér podľa pokynov.

Nainštalujte poskytnuté súbory. Umiestnite skript jumping jack python do priečinka spotter kľúčových slov projektu a súbor zodpovedajúcich príkazov do podpriečinka config.

Pripojte servo kapotu Adafruit k Pi. Keďže používam kryt RPI s ventilátorom, na povolenie pripojenia som potreboval použiť stohovače GPIO (napr. Dostupné od spoločnosti Pimoroni). Nainštalujte všetky požadované knižnice tak, ako je to uvedené v pokynoch Adafruit k kapote servo.

K servo kapote pripojte zdroj 5-6V. Pripojte serva a LED diódy. V mojom prípade som použil port 0 pre LED diódy a porty 11 a 15 pre serva.

Ak chcete skontrolovať všetko, odporučil by som najskôr vyskúšať príklad zameriavača kľúčových slov projektu „počujúci had“a príklady servo kapoty Adafruit.

Krok 2: Spustenie skákacieho zdviháka

Ak sú všetky diely nastavené a fungujú, pokúste sa ich použiť. Skript môžete spustiť v IDE alebo z príkazového riadka.

Kričanie „polohy 0“na „pozíciu 9“vyvolá skákajúceho zdviháka, ktorý zaujal jednu z preddefinovaných pozícií. Definoval som „1“ako obe ruky hore (uu), „3“ako vľavo hore, vpravo dole (ud), „9“ako obe ruky dole (dd) a „5“ako obe ramená v strede (cc).

uu uc ud = 1 2 3

cu cc cd = 4 5 6

du dc dd = 7 8 9

„0“je totožné s „5“. „3“a „8“nie sú veľmi dobre rozpoznané nástrojom na vyhľadávanie kľúčových slov a možno bude potrebné ich zopakovať.

Možno budete musieť nastaviť minimálne a maximálne hodnoty pre každé servo/stranu, aby serva neboli zablokované a potom čerpali príliš veľa energie.

„ďalšou hrou“sa začne „tanec“, t. j. definovaná postupnosť pozícií, zatiaľ čo „náhodná hra“spustí skákajúceho zdviháka, aby vykonal náhodnú sekvenciu ťahov. V oboch prípadoch budú bežať navždy, takže možno budete musieť zastaviť pohyby, napr. príkazom „poloha nula“.

„Stop game“vyvolá „ctrl + c“a zastaví proces.

„zapnúť“a „vypnúť“je možné použiť na zapnutie a vypnutie diód LED.

Úpravou hodnôt času a spánku môžete nastaviť rýchlosť pohybov.

Krok 3: Kód a súbor príkazov

Tu uvedený kód je modifikáciou kódu „počujúci had“, ktorý je súčasťou balíka spotter kľúčových slov projektu. Práve som odstránil všetko, čo nebolo potrebné pre moju aplikáciu, bez skutočného porozumenia podrobností. Akékoľvek vylepšenia sú vítané.

Potom som pridal diely potrebné pre servo kapotu Adafruit na základe ich vzorových súborov.

Chcel by som sa poďakovať programátorom oboch častí.

Kód nájdete v prílohe ako súbor. Používajte ho na vlastné riziko, upravujte ho, vylepšujte, hrajte sa s ním.

# Copyright 2019 Google LLC

# # Licencované pod licenciou Apache, verzia 2.0 („licencia“); # Tento súbor nemôžete používať, pokiaľ nie je v súlade s licenciou. # Kópiu licencie môžete získať na # # https://www.apache.org/licenses/LICENSE-2.0 # # Pokiaľ to nevyžaduje príslušný zákon alebo to nie je písomne dohodnuté, softvér # distribuovaný podľa licencie je distribuovaný na ZÁKLAD „TAK, AKÝ JE“, # BEZ ZÁRUK ALEBO PODMIENOK AKÉHOKOĽVEK DRUHU, či už výslovného alebo implikovaného. # Pozrite si Licenciu pre konkrétny jazyk, ktorým sa riadia povolenia a # obmedzenia v rámci Licencie. from _future_ import absolute_import from _future_ import division from _future_ import print_function import argparse import os from random import randint from threading import Thread import time from edgetpu.basic.basic_engine import BasicEngine import model import pygame from pygame.locals import * import queue from random import randrange z adafruit_servokit import ServoKit import doska import busio import adafruit_pca9685 čas importu i2c = busio. I2C (board. SCL, board. SDA) hat = adafruit_pca9685. PCA9685 (i2c) hat.frequency = 60 kit = ServoKit (kanály = 16) # set number kanálov #kit.servo [0].actuation_range = 160 #kit.servo [0].set_pulse_width_range (1000, 2000) #nastavenie hore, dole a dole pre ľavé a pravé rameno hore_l = 35 md_l = 90 dn_l = 160 hore_r = 160 md_r = 90 dn_r = 35

lft = 15 # počet servo portov, ľavé servo (0-8)

rgt = 11 # počet servo portov, pravé servo (0-8) led_channel_0 = hat.channels [0] # LED nastavená na porte 0 led_channel_0.duty_cycle = 0 # zapnúť LED 100% # zoznam nastavení ramena pre deväť pozícií = [(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)] # definuje 9 pozícií JumpingJack označených celými číslami 0-9 dance1 = (0, 8, 7, 4, 1, 2, 3, 6, 9, 8, 5, 2, 1, 4, 7, 8, 9, 6, 3, 2, 0) # a „tanečná“trieda Ovládač (objekt): #Callback funkcia def _init _ (self, q): self._q = q def callback (self, príkaz): self._q.put (príkaz) trieda Aplikácia: 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): # controls Jumping Jack, keywords: "position x" key = int (keys) p = position [kláves] a = p [0] b = p [1] tlač („Poloha:“, kľúč, „vľavo /right: ", a,"/", b," degree ") # sys.stdout.write (" Pozícia: ", kľúč," vľavo/vpravo: ", a,"/", b," stupeň ") kit.servo [lft].angle = a kit.servo [rgt].angle = b time.sleep (0,1) def JumpingJack1 (self): # controls Jumping Jack dance, keyword: "next game" dnce = dance1 sp = (len (dnce)) pre r v rozsahu (sp): # poradie tancovania polôh, sp kroky dc = dnce [r] if (dc nie je v rozsahu (10)): # print ("chyba vstupu na pozícii", sp) dc = 4 p = poloha [dc] a = p [0] b = p [1] kit.servo [lft].angle = a kit.servo [rgt].angle = b time.sleep (0.25) # sets speed pohybov def JumpingJack2 (self, keys): # controls Jumping Jack LED diódy, kľúčové slová: „zapnutie/vypnutie“led = int (klávesy) ak led == 1: led_channel_0.duty_cycle = 0xffff #turn on LED 100% time.sleep (0,1) ak led == 0: led_channel_0.duty_cycle = 0 # vypne LED time.sleep (0,1) if led == 2: # blink led_channel_0.duty_cycle = 0xffff #turn on LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0 #zapnite LED 100% času. spánok (0,5) led_channel_0.duty_cycle = 0xffff #zapnúť LED 100% čas.spánok (0,5) led_channel_0.duty_cycle = 0 #zapnúť LED 100% čas.spánok (0,5) led_channel_0.duty_cycle = 0xffff #turn LED 100% time.sleep (0,1) def JumpingJack3 (self): # kontroly Jumping Jack dance, kľúčové slovo: „náhodná hra“# na h v rozsahu (10): dr = randrange (9) p = poloha [dr] a = p [0] b = p [1] kit.servo [lft].angle = a kit.servo [rgt].angle = b time.sleep (0.25) # sets the speed of hnutí def def spotter (self, args): engine = BasicEngine (args.model_file) mic = args.mic if args.mic is None else int (args.mic) model.classify_audio (mic, engine, labels_file = "config/labels_gc2.raw.txt", commands_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):

ak nie self.on_init (): self._running = False q = model.get_queue () self._controler = Ovládač (q) ak nie 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 (Pravda, 0,1) okrem queue. Empty: new_item = None if new_item is not None: item = new_item if (args.debug_keyboard and keys [pygame. K_ESCAPE]) or item == "stop": self._running = False # if (args.debug_keyboard and keys [pygame. K_SPACE]) or item == "go": # self. JumpingJack0 (7) # if (args.debug_keyboard and keys [pygame. K_RIGHT]) or item == "right": self. JumpingJack0 (6) if (args.debug_keyboard and keys [pygame. K_LEFT]) or item == "left": self. JumpingJack0 (4) if (args.debug_keyboard and keys [pygame. K_UP]) or item == " hore ": self. JumpingJack0 (1) if (args.debug_keyboard and keys [pygame. K_DOWN]) alebo item ==" down ": self. JumpingJack0 (9) if (args.debug_keyboard and keys [pygam e. K_0]) alebo položka == "0": self. JumpingJack0 (0) if (args.debug_keyboard and keys [pygame. K_1]) alebo item == "1": self. JumpingJack0 (1) if (args. klávesnica ladenia a kľúče [pygame. K_2]) alebo položka == "2": self. JumpingJack0 (2) if (args.debug_keyboard and keys [pygame. K_3]) alebo 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]) or item == "6": self. JumpingJack0 (6) if (args.debug_keyboard and keys [pygame. K_7]) or 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]) or item == "d": self. JumpingJack1 () #dancing Jack, on "next_game" if (args. klávesnica ladenia a klávesy [pygame. K_j]) alebo položka == "j": self. JumpingJack2 (0) #LED zapnuté, ZAPNUTÉ " switch_on "if (args.debug_keyboard and keys [pygame. K_k]) or item ==" k ": self. JumpingJack2 (1) #LED off, on" swithch off "if (args.debug_keyboard and keys [pygame. K_l]) alebo položka == "l": self. JumpingJack2 (1) #LED bliká "target" if (args.debug_keyboard and keys [pygame. K_r]) alebo item == "r": self. JumpingJack3 () #random dance „random game“time.sleep (0,05) self.on_cleanup () if _name_ == '_main_': parser = argparse. ArgumentParser () parser.add_argument ('-debug_keyboard', help = 'Ovládanie JumpingJacku pomocou klávesnice. ', action =' store_true ', default = False) model.add_model_flags (parser) args = parser.parse_args () the_app = App () the_app.on_execute (args)

K dispozícii je tiež konfiguračný súbor príkazu "commands_v2_hampelmann.txt". Upravujte, ako sa vám páči. Je to len zoznam kombinácií „príkaz, kľúč, (sila,)“na základe súboru štítkov.

pozícia_zero, 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, dole, posunúť_ dozadu, vľavo, posunúť dopredu, vpravo, ísť_ dozadu, vľavo, ísť_pred, vpravo, 0,8 cieľa, l, stlmiť zvuk, z, áno, y, nie, n, zapnutie_, j, vypnutie_, k, zvýšenie hlasitosti, hore, zníženie hlasitosti, nadol, next_game, d, random_game, r, start_game, s, stop_game, ctrl+c,

Krok 4: Ďalšie nápady a ďalšie príklady

Je celkom zrejmé, že toto nastavenie je možné použiť aj na ovládanie robotov alebo iných zariadení. V podstate všetko, čo by mohlo byť ovládané Raspberry Pi.

Pracujem na rozšírení skriptu na riadenie MeArm a dúfam, že ho budem môcť predstaviť v októbri 2019.

Uvažujem tiež o použití skákacieho zdviháka ako semaforu a programu rozpoznávania polohy končatín "projekt posenet" ako nástroja na čítanie pozícií skákajúceho zdviháka a jeho preklad na číslo. Týmto spôsobom môže dokonca komunikovať text, pretože 2 x 8 polôh môže indikovať 64 rôznych čísel, viac ako postačujúcich na abecedu, čísla a znaky. To by mohlo umožniť, aj keď je mierne upravený, fyzickú realizáciu pre navrhovaný IETF „Prenos IP datagramov cez signalizačný systém vlajkového semaforu (SFSS)“(https://tools.ietf.org/html/rfc4824).

Ale toto bude ďalší návod. A pretože prvé experimenty naznačili, že skokanský zdvihák bude potrebovať značné úpravy, kým ho systém AI rozpozná ako človeka, môže to nejaký čas trvať.

Chcel by som vás upozorniť na nasledujúci návod: Objekt na hľadanie osôb-osobný asistent-robot-Ft-malina, kde je popísaný robot na vyhľadávanie predmetov využívajúci kombináciu TPU Raspberry Pi a Google Coral.