A Hearing Jumping Jack, Google Coral TPU Accelerator-versie - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

Het beweegt zijn ledematen, het luistert naar uw bevelen, het wordt aangedreven door de nieuwste machine learning-technologie

De "Hearing Jumping Jack" is een eenvoudige elektromechanische Jumping Jack, aangedreven door twee microservo's en een zeer eenvoudige versnelling, met LED's als "ogen". Het wordt bestuurd door eenvoudige spraakopdrachten die aangeven welke van de negen vooraf gedefinieerde posities het moet innemen, of de LED moet worden in- of uitgeschakeld, of dat het een vooraf gedefinieerde "dans" of willekeurige reeks bewegingen moet uitvoeren.

Het kernelement van het systeem is de Google Coral TPU-versneller, waarmee Tensorflow Lite-modellen met zeer hoge snelheid offline kunnen worden uitgevoerd, zelfs op een "zwakke" computer als de Raspberry Pi. Hierdoor kan b.v. snelle objectidentificatie en classificatie met behulp van de RPi-camera, maar ook om op machine learning gebaseerde spraakherkenningsfuncties lokaal uit te voeren.

Voor zover ik weet is dit het eerste gepubliceerde voorbeeld voor een door Coral Accelerator spraakdetectiegestuurd fysiek doe-het-zelf-apparaat, en het bijgevoegde codevoorbeeld kan ook worden gebruikt voor andere, meer complexe projecten.

De spraakbesturing is gebaseerd op het voorbeeld “de horende slang” in het “project keyword spotter” (https://github.com/google-coral/project-keyword-spotter) die recent (september 2019) op GitHub is geplaatst. In mijn configuratie bestaat het systeem uit een Raspberry Pi 4 uitgerust met een Adafruit 16-kanaals servomotorkap, een Google Coral TPU Accelerator en een webcam, hier gebruikt als microfoon. De Jumping Jack was eerder beschreven in een eerdere instructable, waar hij werd aangedreven door de Google Voice-kit om spraakopdrachten te lezen, is bevestigd aan de Servo Bonnet in de versie 2.0 die hieronder wordt beschreven.

De vorige versie van Google Voice Kit had drie centrale beperkingen: het was afhankelijk van de webgebaseerde spraakherkenningsservices van Google en de installatie was relatief ingewikkeld, er moest een soort knop worden ingedrukt voordat je een opdracht kon geven en er was een ernstige vertraging tussen het zeggen van de opdracht en de reactie van het systeem. Het gebruik van de Google Coral-accelerator verkort de reactietijd tot seconden, is onafhankelijk van een internetverbinding en luistert de hele tijd. Met enkele aanpassingen kun je het gebruiken om apparaten te besturen die veel complexer zijn, zoals een Jumping Jack, als robots of auto's, of wat je ook kunt bouwen en besturen met een Raspberry Pi.

In de huidige versie begrijpt de Keyword Spotter een set van ongeveer 140 korte trefwoorden/sleutelzinnen, gedefinieerd in het bijbehorende modelbestand (“voice_commands_v0.7_egetpu.tflite”) en beschreven in een apart labelbestand (“labels_gc2.raw.txt”). Gedefinieerd door een vrij aanpasbaar bestand ("commands_v2_hampelmann.txt"), worden de trefwoorden die specifiek door ons script worden gebruikt, vervolgens toegewezen aan toetsaanslagen op een virtueel toetsenbord, b.v. voor letters, cijfers, omhoog/omlaag/links/rechts, crtl+c, et cetera.

Dan, bijv. met behulp van pygame.key worden deze "toetsaanslagen" gelezen en gebruikt om te bepalen welke acties een apparaat, hier de springjack, moet uitvoeren. In ons geval betekent dit om de twee servo's naar vooraf gedefinieerde posities te sturen, of om de LED's aan of uit te zetten. Omdat de zoekwoordspotter in een apart loopvlak loopt, kan deze permanent naar uw bestellingen luisteren.

Versie 21 sep. 2019

Benodigdheden

Raspberry Pi 4, via Pimoroni

Google Coral TPU Accelerator, via Mouser Duitsland, 72€

Adafruit 16 Servo Bonnet, via Pimoroni, ongeveer 10 €

www.adafruit.com/product/3416

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

Stapelaarkop (indien nodig)

www.adafruit.com/product/2223

4x AA-batterijpakket (of andere 5-6V-voedingsbron) voor Servo Bonnet

Oude webcam, als microfoon

Servo aangedreven Jumping Jack, zoals beschreven in een eerdere instructable. Lay-outtekeningen zijn bij de volgende stap gevoegd, maar kunnen aanpassingen vereisen.

Benodigde onderdelen voor de Jumping Jack:

- Forex plaat van 3 mm

- 2 micro-servo's

- 2 en 3 mm schroeven en moeren

- 2 witte LED's en een weerstand

- een stukje kabel

Stap 1: Het apparaat instellen

Volg de aanwijzingen in een vorige instructable om de Jumping Jack te bouwen. Ik heb Forex gebruikt voor mijn prototype, maar je mag lasergesneden acryl- of multiplexplaten gebruiken. Mogelijk moet u de lay-out aanpassen aan de grootte van uw servo's enz. Test of de ledematen en uitrusting zonder wrijving kunnen bewegen.

Stel uw Raspberry Pi in. Op de Coral Github-site is een Raspian-afbeelding beschikbaar die alles bevat wat nodig is om de Coral-accelerator op de Pi te laten werken en veel projecten bevat, met alle instellingen al op hun plaats.

Download de projectzoekwoordspotter van de Google Coral GitHub-pagina. Installeer alle benodigde software zoals aangegeven.

Installeer de meegeleverde bestanden. Plaats het jumping jack python-script in de project trefwoord spotter map en het corresponderende commando-bestand in de config submap.

Bevestig de Adafruit Servo Bonnet aan de Pi. Omdat ik een RPI-behuizing met een ventilator gebruik, moest ik GPIO-stackers gebruiken (bijvoorbeeld verkrijgbaar bij Pimoroni) om verbinding mogelijk te maken. Installeer alle benodigde bibliotheken, zoals aangegeven in de Adafruit-instructies voor de servo-kap.

Bevestig een 5-6V stroombron aan de servokap. Bevestig servo's en LED's. In mijn geval gebruikte ik poort 0 voor de LED's en poorten 11 en 15 voor de servo's.

Om alles te controleren, raad ik aan om eerst het project keyword spotter "hearing snake" voorbeeld en de Adafruit servo bonnet voorbeelden te proberen.

Stap 2: De Jumping Jack uitvoeren

Als alle onderdelen zijn ingesteld en werken, probeer het dan te gebruiken. U kunt het script uitvoeren in de IDE of vanaf de opdrachtregel.

Door "positie 0" tot "positie 9" te roepen, zal de Jumping Jack een van de vooraf gedefinieerde posities innemen. Ik definieerde "1" als beide armen omhoog (uu), "3" als links omhoog, rechts omlaag (ud), "9" als beide armen omlaag (dd) en "5" als beide armen gecentreerd (cc).

uu uc ud = 1 2 3

cu cc cd = 4 5 6

du dc dd = 7 8 9

"0" is identiek aan "5". "3" en "8" worden niet goed herkend door de zoekwoordspotter en moeten mogelijk worden herhaald.

Mogelijk moet u de minimum- en maximumwaarden voor elke servo/zijde aanpassen, zodat de servo's niet worden geblokkeerd en dan te veel stroom trekken.

"volgende game" zal de "dans" starten, d.w.z. een gedefinieerde reeks posities, terwijl "willekeurige game" de Jumping Jack zal starten om een willekeurige reeks bewegingen uit te voeren. In beide gevallen zullen ze voor altijd lopen, dus het kan zijn dat u bewegingen moet stoppen, b.v. met een "positie nul" commando.

"stop game" roept een "ctrl + c" op en stopt het proces.

"inschakelen" en "uitschakelen" kunnen worden gebruikt om de LED's aan en uit te zetten.

Door de time.sleep-waarden te wijzigen, kunt u de snelheid van bewegingen aanpassen.

Stap 3: De code en het opdrachtenbestand

De code die hier wordt gepresenteerd, is een wijziging van de "hoorslang"-code die deel uitmaakt van het projectsleutelwoordspotterpakket. Ik heb zojuist alles verwijderd wat niet nodig was voor mijn toepassing, zonder echt begrip van de details. Eventuele verbeteringen zijn welkom.

Vervolgens heb ik de benodigde onderdelen voor de Adafruit Servo Bonnet toegevoegd, op basis van hun voorbeeldbestanden.

Ik wil graag de programmeurs van beide delen bedanken.

De code is als bijlage bijgevoegd te vinden. Gebruik het op eigen risico, pas het aan, verbeter het, speel ermee.

# Copyright 2019 Google LLC

# # Gelicentieerd onder de Apache-licentie, versie 2.0 (de "licentie"); # u mag dit bestand alleen gebruiken in overeenstemming met de licentie. # U kunt een kopie van de Licentie verkrijgen op # # https://www.apache.org/licenses/LICENSE-2.0 # # Tenzij vereist door de toepasselijke wetgeving of schriftelijk overeengekomen, wordt software # gedistribueerd onder de Licentie verspreid op een "AS IS" BASIS, # ZONDER ENIGE GARANTIE OF VOORWAARDEN, expliciet of impliciet. # Zie de Licentie voor de specifieke taal die machtigingen en # beperkingen onder de Licentie regelt. uit _future_ import absolute_import uit _future_ import divisie uit _future_ import print_function import argparse import os uit willekeurige import randint uit threading import Thread import tijd uit edgetpu.basic.basic_engine import BasicEngine import model import pygame uit pygame.locals import * import wachtrij uit willekeurige import randrange from 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.frequency = 60 kit = ServoKit(channels=16) # set number van kanalen #kit.servo[0].actuation_range = 160 #kit.servo[0].set_pulse_width_range(1000, 2000) # instellingen voor omhoog, midden en omlaag voor linker- en rechterarm up_l = 35 md_l = 90 dn_l = 160 up_r = 160 md_r = 90 dn_r = 35

lft= 15 # aantal servopoorten, linker servo (0-8)

rgt= 11 # aantal servopoorten, rechter servo (0-8) led_channel_0 = hat.channels[0] # LED ingesteld op poort 0 led_channel_0.duty_cycle = 0 #turn on LED 100% #lijst met arminstellingen voor negen posities positie = [(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)] # definieert 9 JumpingJack-posities, aangegeven door gehele getallen 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 "dance" class Controler(object): #Callback function def _init_(self, q): self._q = q def callback(self, commando): 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): # controls Jumping Jack, keywords: "position x" key = int(keys) p = position [toets] a = p[0] b = p[1] print ("Positie:", toets, " links /rechts: ", a, "/", b, "graad") # sys.stdout.write("Positie:", toets, " links/rechts:", a, "/", b, "graad") kit.servo[lft].angle = a kit.servo[rgt].angle = b time.sleep(0.1) def JumpingJack1(self): # controls Jumping Jack dance, trefwoord: "volgende game" dnce = dance1 sp=(len(dnce)) voor r in bereik (sp): #dansvolgorde van posities, sp stappen dc = dnce[r] if (dc niet in bereik(10)): # print ("invoerfout op positie", sp) dc=4 p = positie[dc] a = p[0] b = p[1] kit.servo[lft].angle = a kit.servo[rgt].angle = b time.sleep(0.25) # stelt snelheid in aantal bewegingen def JumpingJack2(self, keys): # controls Jumping Jack LEDs, keywords: "switch on/off" led = int(keys) if led == 1: led_channel_0.duty_cycle = 0xffff #turn on LED 100% time.sleep (0.1) if led == 0: led_channel_0.duty_cycle = 0 # turn off 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 #turn on LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0xffff #turn on LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0 #turn on LED 100% time.sleep (0.5) led_channel_0.duty_cycle = 0xffff #turn on LED 100% time.sleep (0.1) def JumpingJack3(self): # controls Jumping Jack dance, trefwoord: "willekeurig spel" # voor h binnen bereik (10): dr= randbereik (9) p = position[dr] a = p[0] b = p[1] kit.servo [lft].angle = a kit.servo[rgt].angle = b time.sleep(0.25) # zet snelheid van bewegingen def spotter(self, args): engine = BasicEngine(args.model_file) mic = args.mic if args.mic is Geen anders 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(zelf, argumenten):

if not self.on_init(): self._running = False q = model.get_queue() self._controler = Controler(q) if not 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) behalve wachtrij. Empty: new_item = Geen als new_item niet Geen is: item = new_item if (args.debug_keyboard and keys[pygame. K_ESCAPE]) of item == "stop": self._running = False # if (args.debug_keyboard and keys[pygame. K_SPACE]) of item == "go": # self. JumpingJack0(7) # if (args.debug_keyboard and keys[pygame. K_RIGHT]) of item == "right": self. JumpingJack0(6) if (args.debug_keyboard and keys[pygame. K_LEFT]) of item == "left": self. JumpingJack0(4) if (args.debug_keyboard and keys[pygame. K_UP]) of item == " up": self. JumpingJack0(1) if (args.debug_keyboard and keys[pygame. K_DOWN]) of item == "down": self. JumpingJack0(9) if (args.debug_keyboard and keys[pygam e. K_0]) of item == "0": self. JumpingJack0(0) if (args.debug_keyboard and keys[pygame. K_1]) of item == "1": self. JumpingJack0(1) if (args. debug_keyboard and keys[pygame. K_2]) of item == "2": self. JumpingJack0(2) if (args.debug_keyboard and keys[pygame. K_3]) of item == "3": self. JumpingJack0(3) if (args.debug_keyboard and keys[pygame. K_4]) of item == "4": self. JumpingJack0(4) if (args.debug_keyboard and keys[pygame. K_5]) of item == "5": self. JumpingJack0(5) if (args.debug_keyboard and keys[pygame. K_6]) of item == "6": self. JumpingJack0(6) if (args.debug_keyboard and keys[pygame. K_7]) of item == "7 ": self. JumpingJack0(7) if (args.debug_keyboard and keys[pygame. K_8]) of item == "8": self. JumpingJack0(8) if (args.debug_keyboard and keys[pygame. K_9]) of item == "9": self. JumpingJack0(9) if (args.debug_keyboard and keys[pygame. K_a]) of item == "d": self. JumpingJack1() #dancing Jack, op "next_game" if (args. debug_keyboard en toetsen [pygame. K_j]) of item == "j": self. JumpingJack2(0) #LED aan, AAN " switch_on" if (args.debug_keyboard and keys[pygame. K_k]) of item == "k": self. JumpingJack2(1) #LED uit, aan "swithch off" if (args.debug_keyboard and keys[pygame. K_l]) of item == "l": self. JumpingJack2(1) #LED knippert "target" if (args.debug_keyboard and keys[pygame. K_r]) of 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='Gebruik het toetsenbord om de JumpingJack te besturen.', action='store_true', default=False) model.add_model_flags(parser) args = parser.parse_args() the_app = App() the_app.on_execute(args)

Er is ook het opdrachtconfiguratiebestand "commands_v2_hampelmann.txt". Pas aan zoals je wilt. Het is slechts een lijst van "command, key, (strength,)" combinaties, gebaseerd op het label-bestand.

positie_nul, 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, down, move_backwards, left, move_forwards, right, go_backwards, left, go_forwards, right, 0.8 target, l, mute, z, yes, y, no, n, switch_on, j, switch_off, k, volume_up, up, volume_down, down, next_game, d, random_game, r, start_game, s, stop_game, ctrl+c,

Stap 4: Verdere ideeën en andere voorbeelden

Het ligt voor de hand dat deze instelling ook gebruikt kan worden om robots of andere apparaten aan te sturen. Eigenlijk alles wat door een Raspberry Pi kan worden bestuurd.

Ik werk aan een uitbreiding van het script om een MeArm te besturen en hoop deze in oktober 2019 te kunnen presenteren.

Ik overweeg ook om de Jumping Jack als een semafoor te gebruiken, en om het ledemaatpositieherkenningsprogramma "project posenet" te gebruiken als een hulpmiddel om de posities van de Jumping Jack te lezen en terug te vertalen naar een getal. Op deze manier kan het zelfs tekst communiceren, gegeven 2x 8 posities kunnen 64 verschillende cijfers worden aangegeven, ruim voldoende voor alfabet, cijfers en tekens. Dit zou, hoewel enigszins gewijzigd, een fysieke realisatie mogelijk kunnen maken voor de voorgestelde IETF "The Transmission of IP Datagrams over the Semaphore Flag Signaling System (SFSS)" (https://tools.ietf.org/html/rfc4824).

Maar dit zal een andere instructable zijn. En zoals de eerste experimenten aangaven dat de jumping jack aanzienlijke aanpassingen nodig heeft voordat hij door het AI-systeem als mens wordt herkend, kan het enige tijd duren.

Ik wil graag uw aandacht vestigen op de volgende instructable: Object-Finding-Personal-Assistant-Robot-Ft-Raspberry, waar een robot voor het vinden van objecten wordt beschreven die een combinatie van een Raspberry Pi en Google Coral TPU gebruikt.