admin/pizerovoice
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1b1bfcb253471d91f271c8767e6069f56ac2491c
pizerovoice/README.md
admin 1b1bfcb253 README.md aktualisiert
2026-01-28 08:59:47 +00:00

9.8 KiB
Raw Blame History

Pi Zero 2W + ReSpeaker - OPTIMIERT FÜR 3 KOMMANDOS

Lightweight Keyword Spotting statt vollständiges Sprachmodell

TEIL 1-3: Basis-Installation (wie vorher)

Die Schritte zur OS-Installation, SSH-Verbindung und ReSpeaker-Treiber bleiben identisch:

  1. Raspberry Pi OS (Bullseye 32-bit) installieren (TEIL 1)
  2. SSH-Verbindung + raspi-config (TEIL 2)
  3. seeed-voicecard Treiber installieren (TEIL 3)

Folge dazu der ursprünglichen Anleitung bis einschließlich TEIL 3.

TEIL 1: HARDWARE-VORBEREITUNG UND OS-INSTALLATION

1.1 Hardware-Anforderungen

Du benötigst folgende Komponenten:

  • Raspberry Pi Zero 2W (nicht Zero oder Zero W!)
  • Seed Studio ReSpeaker Pi Hat v1.2 mit 2 Mikrofonen
  • microSD-Karte: mindestens 16GB (Class 10 empfohlen)
  • USB-Stromversorgung: 2A Netzteil mit Micro-USB
  • SD-Kartenleser zum Flashen auf deinem PC
  • Computer mit Internetverbindung
  • Optional: HDMI-Monitor, USB-Tastatur/Maus zur Direktverbindung

1.2 Raspberry Pi OS Installation

Schritt 1: Raspberry Pi Imager herunterladen

  1. Öffne https://www.raspberrypi.com/software/
  2. Lade Raspberry Pi Imager für dein Betriebssystem herunter
  3. Installiere die Anwendung

Schritt 2: SD-Karte flashen

  1. Stecke die microSD-Karte in deinen Kartenleser und verbinde ihn mit dem PC
  2. Öffne Raspberry Pi Imager
  3. Klicke auf "Gerät auswählen" und wähle "Raspberry Pi Zero 2"
  4. Klicke auf "Betriebssystem auswählen" und wähle:
    • Raspberry Pi OS (Legacy, 32-Bit) - Bullseye
    • Hinweis: v1.2 des ReSpeaker-Hats ist am besten mit Bullseye kompatibel
  5. Klicke auf "Speicher auswählen" und wähle deine microSD-Karte
  6. Klicke auf das Zahnrad-Symbol (Erweiterte Optionen) und konfiguriere:
    • Hostname: respeaker-pi (oder ein beliebiger Name)
    • SSH aktivieren: Ja (mit Passwort)
    • Benutzername: pi
    • Passwort: Ein sicheres Passwort deiner Wahl (aufschreiben!)
    • WLAN konfigurieren:
      • SSID: Dein WiFi-Netzwerk
      • Passwort: Dein WiFi-Passwort
      • Land: DE (Deutschland)
    • Zeitzone: Europe/Berlin
  7. Klicke "Speichern" und dann "Schreiben"
  8. Warte bis zum Abschluss (5-10 Minuten)
  9. Entnehme die SD-Karte

Schritt 3: Erster Start

  1. Stecke die SD-Karte in den Pi Zero 2W ein
  2. Verbinde den ReSpeaker Hat mit dem Pi:
    • Ausrichten der GPIO-Pins (40-polige Reihe)
    • ReSpeaker sollte fest aufgesetzt sein
  3. Verbinde die USB-Stromversorgung
  4. Warte 1-2 Minuten für den ersten Start

Schritt 4: IP-Adresse ermitteln

Methode A (über Router):

  1. Öffne die Verwaltungsoberfläche deines WLAN-Routers
  2. Suche nach verbundenen Geräten
  3. Notiere die IP-Adresse von respeaker-pi

Methode B (mit arp-scan auf Linux/Mac):

sudo arp-scan -l | grep -i "raspberry\|b8:27"

Methode C (mit Advanced IP Scanner auf Windows):

  1. Lade Advanced IP Scanner herunter
  2. Scanne dein Netzwerk
  3. Suche nach respeaker-pi

Beispiel-IP: 192.168.1.100

TEIL 2: RASPBERRY PI KONFIGURATION

2.1 SSH-Verbindung herstellen

Auf Linux/Mac (Terminal):

ssh pi@192.168.1.100
# Gib dein Passwort ein

Auf Windows: Nutze PuTTY

  1. Lade PuTTY herunter
  2. Öffne PuTTY
  3. Host: 192.168.1.100
  4. Port: 22
  5. Klicke "Open"
  6. Login: pi
  7. Passwort: (dein gesetztes Passwort)

2.2 System aktualisieren

sudo apt update
sudo apt upgrade -y
sudo apt install -y git python3-pip python3-dev libatlas-base-dev

Dieser Prozess dauert 10-15 Minuten. Warte ab.

2.3 Audio- und I2C-Konfiguration

sudo raspi-config

Navigiere zu:

  1. Schnittstellen → I2C → Aktivieren
  2. Schnittstellen → SPI → Aktivieren
  3. Lokalisierungsoptionen → Zeitzone → Europa → Berlin
  4. Lokalisierungsoptionen → Sprache → de_DE.UTF-8
  5. Bestätige alle Änderungen und Starten Sie neu.

Nach dem Reboot erneut verbinden:

ssh pi@192.168.1.100

TEIL 3: RESPEAKER HAT INSTALLATION

3.1 seeed-voicecard Treiber installieren

Der ReSpeaker benötigt die speziellen Seeed-Treiber. Diese können aus dem Rhasspy-Repo gezogen werden oder als install-respeaker-drivers.sh dieses Verzeichnisses genutzt werden.

cd ~
wget 'https://raw.githubusercontent.com/rhasspy/wyoming-satellite/refs/heads/master/etc/install-respeaker-drivers.sh'
sudo chmod 755 install-respeaker-drivers.sh
sudo ./install-respeaker-drivers.sh

Dies dauert 5-10 Minuten. Wenn es fertig ist:

sudo reboot now

Nach dem Reboot wieder verbinden:

ssh pi@192.168.1.100

3.2 ReSpeaker-Installation verifizieren

Überprüfe, ob die Sound-Karte erkannt wurde:

aplay -l

Du solltest folgende Ausgabe sehen:

**** PLAYBACK hardware devices ****
card 0: ALSA [bcm2835 ALSA], device 0: bcm2835 ALSA [bcm2835 ALSA]
card 1: seeed2miccard [seeed-2mic-voicecard], device 0: ...

Überprüfe auch die Aufnahmegeräte:

arecord -l

Du solltest auch hier seeed-2mic-voicecard sehen.

3.3 Ton-Tests

Lautsprecher testen:

speaker-test -l 1 -c 2 -t sine -f 1000 -r 48000

Du solltest einen Ton hören (drücke Ctrl+C zum Beenden).

Mikrofon testen:

arecord -D hw:1,0 -f S16_LE -c 2 -r 48000 test_recording.wav

Sprich kurz ins Mikrofon und stoppe mit Ctrl+C. Dann abspielen:

aplay -D hw:1,0 test_recording.wav

installieren mit

pip3 install vosk --break-system-packages

mkdir ~/vosk-models cd ~/vosk-models wget https://alphacephei.com/vosk/models/vosk-model-small-de-0.15.zip unzip vosk-model-small-de-0.15.zip mv vosk-model-small-de-0.15 model

aufnehmen mit

arecord -D plughw:1,0 --format S16_LE --rate 16000 --channels 1 --duration 5 test_mono.wav

ausfuehren mit

python3 test_simple.py test_mono.wav

test_simple.py

#!/usr/bin/env python3

import wave
import sys

from vosk import Model, KaldiRecognizer, SetLogLevel

# You can set log level to -1 to disable debug messages
SetLogLevel(0)

wf = wave.open(sys.argv[1], "rb")
if wf.getnchannels() != 1 or wf.getsampwidth() != 2 or wf.getcomptype() != "NONE":
    print("Audio file must be WAV format mono PCM.")
    sys.exit(1)

model = Model("model") #lang="en-us")

# You can also init model by name or with a folder path
# model = Model(model_name="vosk-model-en-us-0.21")
# model = Model("models/en")

rec = KaldiRecognizer(model, wf.getframerate())
rec.SetWords(True)
rec.SetPartialWords(True)

while True:
    data = wf.readframes(4000)
    if len(data) == 0:
        break
    if rec.AcceptWaveform(data):
        print(rec.Result())
    else:
        print(rec.PartialResult())

print(rec.FinalResult())

microphone.py

#!/usr/bin/env python3

# prerequisites: as described in https://alphacephei.com/vosk/install and also python module `sounddevice` (simply run command `pip install sounddevice`)
# Example usage using Dutch (nl) recognition model: `python test_microphone.py -m nl`
# For more help run: `python test_microphone.py -h`

import argparse
import queue
import sys
import sounddevice as sd

from vosk import Model, KaldiRecognizer

q = queue.Queue()

def int_or_str(text):
    """Helper function for argument parsing."""
    try:

        return int(text)
    except ValueError:
        return text

def callback(indata, frames, time, status):
    """This is called (from a separate thread) for each audio block."""
    if status:
        print(status, file=sys.stderr)
    q.put(bytes(indata))

parser = argparse.ArgumentParser(add_help=False)
parser.add_argument(
    "-l", "--list-devices", action="store_true",
    help="show list of audio devices and exit")
args, remaining = parser.parse_known_args()
if args.list_devices:
    print(sd.query_devices())
    parser.exit(0)
parser = argparse.ArgumentParser(
    description=__doc__,
    formatter_class=argparse.RawDescriptionHelpFormatter,
    parents=[parser])
parser.add_argument(
    "-f", "--filename", type=str, metavar="FILENAME",
    help="audio file to store recording to")
parser.add_argument(
    "-d", "--device", type=int_or_str,
    help="input device (numeric ID or substring)")
parser.add_argument(
    "-r", "--samplerate", type=int, help="sampling rate")
parser.add_argument(
    "-m", "--model", type=str, help="language model; e.g. en-us, fr, nl; default is en-us")
args = parser.parse_args(remaining)

try:
    if args.samplerate is None:
        device_info = sd.query_devices(args.device, "input")
        # soundfile expects an int, sounddevice provides a float:
        args.samplerate = int(device_info["default_samplerate"])

    if args.model is None:
        model = Model(lang="de") #"en-us")
    else:
        model = Model(lang=args.model)

    if args.filename:
        dump_fn = open(args.filename, "wb")
    else:
        dump_fn = None

    with sd.RawInputStream(samplerate=args.samplerate, blocksize = 8000, device=args.device,
            dtype="int16", channels=1, callback=callback):
        print("#" * 80)
        print("Press Ctrl+C to stop the recording")
        print("#" * 80)

        rec = KaldiRecognizer(model, args.samplerate)
        while True:
            data = q.get()
            if rec.AcceptWaveform(data):
                print(rec.Result())
            else:
                partialPrint = rec.PartialResult()
                print(partialPrint)
                if "licht" in partialPrint and "an" in partialPrint and "hex" in partialPrint:
                    print("SCHALTER EIN!")
                if "licht" in partialPrint and "aus" in partialPrint and "hex" in partialPrint:
                    print("SCHALTER AUS!")
            if dump_fn is not None:
                dump_fn.write(data)

except KeyboardInterrupt:
    print("\nDone")
    parser.exit(0)
except Exception as e:
    parser.exit(type(e).__name__ + ": " + str(e))
Reference in New Issue View Git Blame Copy Permalink