pizerovoice/README.md

# 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/](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):
```bash
sudo arp-scan -l | grep -i "raspberry\|b8:27"
```

Methode C (mit Advanced IP Scanner auf Windows):
1. Lade [Advanced IP Scanner](https://www.advanced-ip-scanner.com/) 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):
```bash
ssh pi@192.168.1.100
# Gib dein Passwort ein
```

Auf Windows: Nutze PuTTY
1. Lade [PuTTY](https://www.putty.org/) 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

```bash
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

```bash
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:
```bash
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.

```bash
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
sudo apt-get install libportaudio2
pip3 install sounddevice --break-system-packages
```

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

```bash
sudo reboot now
```

Nach dem Reboot wieder verbinden:
```bash
ssh pi@192.168.1.100
```

### 3.2 ReSpeaker-Installation verifizieren

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

```bash
aplay -l
```

Du solltest eine ähnliche 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:
```bash
arecord -l
```

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

### 3.3 Ton-Tests

**Lautsprecher testen:**
```bash
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:**
```bash
arecord -D hw:1,0 -f S16_LE -c 2 -r 48000 test_recording.wav
```
Hierbei sind hw:1,0 so zu wählen, dass 1 für die Karte steht - kann auch 3 o.Ä. sein und 0 der Device-Index der Karte.

---

# installieren mit lokalem Modell:
```bash
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

# vorbereitungen
```
mkdir ~/vosk-models
```
Dort alle `*.py`-Dateien und die per `chmod 755` ausführbar gemachte `start_voice.sh` aus diesem Repo einfügen.
Damit ohne weitere Interaktion gestartet wird, muss außerdem per `sudo nano /etc/systemd/system/voicerec.service` ein Service angelegt und wie folgt befüllt werden:
```
[Unit]
Description=starten der services fuer die spracherkennung
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=pi
Restart=always
RestartSec=10
StartLimitBurst=10000
WorkingDirectory=/home/pi
ExecStart=/home/pi/vosk-models/start_voice.sh

[Install]
WantedBy=multi-user.target
```

Außerdem wird ein WIFI-Reconnect Service mit Timer eingerichtet, der jede Minute die WLAN Verbindung, prüft, neu aufbaut oder ggfs. den PI rebootet. 
Der Service führt die ebenfalls in `~/vosk-models/` abgelegte `wifi-reconnect.sh` aus, die hier ebenfalls im Repository liegt und wiederum zunächst mit `chmod 755 wifi-reconnect.sh` ausführbar gemacht werden muss.
Für den Timer wird `sudo nano /etc/systemd/system/wifi-reconnect.timer` mit folgendem Inhalt befüllt:
```
[Unit]
Description=WiFi Reconnect Timer

[Timer]
OnBootSec=1min
OnUnitActiveSec=1min

[Install]
WantedBy=timers.target
```
Für den zugehörigen, zu startenden Service mittels `sudo nano /etc/systemd/system/wifi-reconnect.service`:
```
[Unit]
Description=WiFi Auto-Reconnect Service

[Service]
Type=oneshot
ExecStart=/home/pi/vosk-models/wifi-reconnect.sh
```
Anschließend muss folgende Befehlskette ausgeführt werden:
```
sudo systemctl daemon-reload
sudo systemctl enable wifi-reconnect.timer
sudo systemctl start wifi-reconnect.timer
sudo systemctl enable voicerec.service
sudo systemctl start voicerec.service
```
Prüfen lässt sich der aktuelle Zustand per: `sudo systemctl status wifi-reconnect.timer`



# oder installation mit Speach-To-Text auf Server (dort Docker:)
```
docker run -d -p 2700:2700 -v /opt/model:/opt/vosk-model-en/model alphacep/kaldi-de:latest
```
wenn der Server Beispielsweise die IP 192.168.213.45 hat, dann muss diese in der `server_microphone.py` eingetragen werden.

Je nachdem, ob `local_microphone.py` oder `server_microphone.py` genutzt werden soll, muss die `start_voice.sh`-Datei entsprechend angepasst werden.

# stop der Audio-Wiedergabe per Button
Falls Erwin nicht zuhören kann aufgrund der Radio-Erzählstimme, gibt es die Möglichkeit mittels des `reset_via_button.py` Skriptes die mpg123-Wiedergaben zu killen.
Damit dieses Skript ebenfalls andauernd läuft, wird auch hier ein `systemctl service` erstellt,
`sudo nano /etc/systemd/system/button-reset.service` - mit folgendem Inhalt:
```
[Unit]
Description=starten der services fuer die spracherkennung
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=pi
Restart=always
RestartSec=10
StartLimitBurst=10000
WorkingDirectory=/home/pi
ExecStart=/home/pi/button-reset/start_reset.sh

[Install]
WantedBy=multi-user.target
EOF
```
Die zugehörigen Skripte (python `reset_via_button.py` und shell `start_reset.sh`) liegen hier im Ordner `/home/pi/button-reset`. 


# tagesschau news abspielen
Zunächst muss per `sudo apt install mpg123` der entsprechende Codec für MP3s installiert werden. Danach wird das Verzeichnis `~/tagesschau` angelegt, das für die tagesschau-100-sekunden MP3s als Speicherort dient. 
in diesen ordner kommen entsprechend auch die `start_news.sh` und `end_news.sh`-Skripte, die vorher ausführbar gemacht werden müssen.
abgespielt werden die nachrichten mit "nachrichten hex hex".
# dlf & nova abspiele
anlegen eines verzeichnis `~/radio` und dort die `start_dlf/nova.sh` Skripte ablegen, welche dann mit "nova hex hex" oder "funk hex hex" abgespielt werden. zum beenden wieder "ruhe hex hex"


# oled-display anschließen
- Erweiterungsboard für 2x 40Pins besorgen
- folgende Treiber installieren: `sudo pip3 install Adafruit-SSD1306 --break-system-packages` & `sudo -H pip3 install --upgrade luma.oled --break-system-packages` 
- um einen zusätzlichen i2c-Bus nutzen zu können, muss in `/boot/formware/config.txt` am ende z.B. unter [all] folgendes ergänzt werden: `dtoverlay=i2c-gpio,bus=5,i2c_gpio_sda=6,i2c_gpio_scl=12`, dann können diese beiden PINs für SCL und SCA genutzt werden, um einen [https://www.berrybase.de/seeed-grove-0.96-oled-display-ssd1315](OLED-Display) zu betreiben 
- damit das Ganze dann auch schön läuft, wird als `server_microphone.py` der Inhalt der Datei `server_microphone_oled.py` aus diesem Repository genutzt.