KWS-Wake-up-Soundkarte – Produkteinführung

Die Juxi-KWS-Wake-up-Soundkarte ist ein leistungsstarkes Offline-Spracherkennungsmodul für eingebettete Systeme, Robotik und IoT-Anwendungen. Dank lokaler Verarbeitung ohne Cloud-Abhängigkeit bietet sie schnelle, zuverlässige Sprachsteuerung mit minimaler Latenz und eignet sich ideal für Szenarien, die schnelle Reaktion und Datenschutz erfordern.

Hauptfunktionen

• ✅ 100 % Offline-Verarbeitung: Die gesamte Spracherkennung läuft lokal auf dem Modul, ohne Internetverbindung – für Datenschutz und geringe Latenz
• 🎤 Hohe Erkennungsgenauigkeit: Unterstützt chinesische und englische Sprachbefehle mit >95 % Erkennungsgenauigkeit in normalen Umgebungen
• ⚡ Extrem niedrige Latenz: Antwort innerhalb von 300 ms nach Spracheingabe für ein Echtzeit-Steuerungserlebnis
• 🔧 Hochgradig anpassbar: Unterstützt benutzerdefinierte Weckwörter und Kommandosätze über das offizielle Firmware-Konfigurationstool
• 🖥️ Multi-Plattform-Unterstützung: Kompatibel mit Raspberry Pi, Jetson Nano, x86-PCs und ROS/ROS2-Robotersystemen
• 🔌 Plug-and-Play: Standard-USB-HID-Schnittstelle, kein zusätzlicher Hardwareaufwand erforderlich
• 🎛️ Integrierter Audioausgang: Eingebauter Lautsprechertreiber für Sprachfeedback
• 💡 Geringer Stromverbrauch: Durchschnittlicher Betriebsstrom < 50 mA, geeignet für batteriebetriebene Geräte

Grundfunktionen

Standard-Weckwörter

Das Modul ist werkseitig mit Standard-Weckwörtern vorkonfiguriert:

• Chinesisch: "你好小犀", "小犀小犀", "钜犀"
• Englisch: "Hello Xiaoxi", "Juxi Technology"

Unterstützte Befehlsarten

Das Modul unterstützt bis zu 100 benutzerdefinierte Sprachbefehle, darunter:

• Bewegungssteuerung: vorwärts, rückwärts, links abbiegen, rechts abbiegen, anhalten
• Lichtsteuerung: Licht ein-/ausschalten, Lichtfarben ändern (rot, grün, blau, gelb)
• Systemsteuerung: Schlafmodus, Aufwecken, Rückkehr zur Ausgangsposition
• Aktuatorsteuerung: Greifer öffnen/schließen, Motordrehzahl einstellen
• Benutzerdefinierte Befehle: Vollständig anpassbarer Befehlssatz für spezifische Anwendungen

Kommunikationsprotokoll

Das Modul verwendet ein einfaches und zuverlässiges serielles Schnittstellenprotokoll:

• Baudrate: 115200
• Datenbits: 8
• Stoppbits: 1
• Parität: keine
• Frame-Format: 0xAA 0x55 [Command Type] [Command ID] 0xFB

Schnellstart

Einfaches Beispiel für die serielle Kommunikation (Python)

Hier ist ein minimales funktionierendes Beispiel zum Auslesen von Sprachbefehlen vom Modul:

#!/usr/bin/env python3
import serial
import time

# Configure serial port (adjust port name for your system)
# Windows: "COM3", "COM4", etc.
# Linux: "/dev/ttyUSB0", "/dev/ttyACM0", etc.
ser = serial.Serial('/dev/ttyUSB0', 115200, timeout=0.01)

# Command mapping dictionary
COMMANDS = {
    (0x00, 0x01): "Stop",
    (0x00, 0x04): "Move forward",
    (0x00, 0x05): "Move backward",
    (0x00, 0x06): "Turn left",
    (0x00, 0x07): "Turn right",
    (0x00, 0x0A): "Turn off light",
    (0x00, 0x0B): "Turn on red light",
    (0x00, 0x0C): "Turn on green light",
    (0x00, 0x0D): "Turn on blue light",
    (0x00, 0x0E): "Turn on yellow light",
    (0x00, 0x21): "Return to origin",
    (0x00, 0x27): "Move up",
    (0x00, 0x28): "Move down",
    (0x00, 0x2B): "Grip close",
    (0x00, 0x2C): "Grip open",
    (0x00, 0x03): "System sleep"
}

WAKE_WORDS = {
    0x01: "Hello Xiaoxi",
    0x02: "Xiaoxi Xiaoxi",
    0x03: "Juxi Technology"
}

def read_voice_command():
    """Read and parse voice command frames from serial port"""
    if ser.in_waiting >= 5:
        frame = ser.read(5)
        # Verify frame header and footer
        if frame[0] == 0xAA and frame[1] == 0x55 and frame[4] == 0xFB:
            # Wake word detected
            if frame[3] == 0x00:
                return f"[WAKE] {WAKE_WORDS.get(frame[2], 'Unknown wake word')}"
            # Command received
            else:
                cmd = COMMANDS.get((frame[2], frame[3]), f"Unknown command: {frame[2]}:{frame[3]}")
                return f"[COMMAND] {cmd}"
    return None

# Main execution loop
if __name__ == "__main__":
    try:
        print("KWS Wake-up Sound Card Test")
        print("Listening for voice commands... (Press Ctrl+C to exit)")
        print("-" * 50)
        
        while True:
            result = read_voice_command()
            if result:
                print(result)
            time.sleep(0.01)
            
    except KeyboardInterrupt:
        ser.close()
        print("\n" + "-" * 50)
        print("Program terminated")

Bedienungsanleitung

1. Schließen Sie die KWS-Soundkarte über einen USB-Port an Ihr Gerät an
2. Installieren Sie bei Bedarf den CH341-Serientreiber (verfügbar unter: https://www.wch.cn/downloads/CH341SER_EXE.html)
3. Passen Sie den Serienportnamen im Code an Ihr System an
4. Führen Sie das Python-Skript aus
5. Sprechen Sie das Weckwort ("Hello Xiaoxi"), um das Modul zu aktivieren
6. Sprechen Sie Ihren Befehl innerhalb von 5 Sekunden nach dem Bestätigungston
7. Das Modul erkennt den Befehl und gibt ihn über die serielle Schnittstelle aus

Fortgeschrittene Anwendung: ROS2-Integration

Das Modul lässt sich nahtlos in ROS2 (Robot Operating System 2) für Roboteranwendungen integrieren. Hier ist ein vereinfachtes Beispiel für einen Sprachsteuerungs-Node:

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from std_msgs.msg import String
import serial

class KWSVoiceControlNode(Node):
    def __init__(self):
        super().__init__('kws_voice_control_node')
        
        # Create publisher for voice commands
        self.cmd_publisher = self.create_publisher(String, '/kws/voice_command', 10)
        
        # Initialize serial port
        self.ser = serial.Serial('/dev/ttyUSB0', 115200, timeout=0.01)
        
        # Create timer for serial reading
        self.timer = self.create_timer(0.01, self.serial_read_callback)
        
        self.get_logger().info("KWS Voice Control Node started successfully")
        self.get_logger().info("Listening for wake words and commands...")

    def serial_read_callback(self):
        """Read and process serial data"""
        if self.ser.in_waiting >= 5:
            frame = self.ser.read(5)
            if frame[0] == 0xAA and frame[1] == 0x55 and frame[4] == 0xFB:
                msg = String()
                
                # Process wake event
                if frame[3] == 0x00:
                    wake_word = {0x01: "hello_xiaoxi", 0x02: "xiaoxi_xiaoxi", 0x03: "juxi"}.get(frame[2], "unknown")
                    msg.data = f"wake:{wake_word}"
                    self.get_logger().info(f"Wake up detected: {wake_word}")
                
                # Process command event
                else:
                    cmd_data = f"{frame[2]}:{frame[3]}"
                    msg.data = f"command:{cmd_data}"
                    self.get_logger().info(f"Command received: {cmd_data}")
                
                # Publish message
                self.cmd_publisher.publish(msg)

def main(args=None):
    rclpy.init(args=args)
    node = KWSVoiceControlNode()
    
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        node.get_logger().info("Node interrupted by user")
    finally:
        node.destroy_node()
        rclpy.shutdown()

if __name__ == '__main__':
    main()

Typische Anwendungsszenarien

• 🤖 Robotik: Sprachsteuerung für mobile Roboter, Roboterarme, UAVs und Serviceroboter
• 🏠 Smart Home: Sprachsteuerung für Beleuchtung, Haushaltsgeräte, Vorhänge und Sicherheitssysteme
• 🏭 Industrielle Steuerung: Freihändige Bedienung von Industrieanlagen, Produktionslinien und Werkstattsteuerung
• 🚗 Automobil: Sprachsteuerung im Fahrzeug für Infotainment, Klimasteuerung und Fahrzeugfunktionen
• 🎮 IoT-Geräte: Sprachinteraktion für Smart Speaker, Smart Displays und andere vernetzte Geräte
• 🎓 Bildung & Forschung: Entwicklungsplattform für Sprachinteraktionsprojekte und Robotikforschung

Technische Spezifikationen

Firmware-Anpassung

Das Modul unterstützt vollständig anpassbare Weckwörter und Befehlssätze:

1. Besuchen Sie die Qiying Tairen Voice AI Platform
2. Erstellen Sie ein neues Projekt mit CI1302-Chipsatzkonfiguration
3. Fügen Sie Ihre benutzerdefinierten Weckwörter und Kommandosätze hinzu
4. Konfigurieren Sie Antworttöne und Ansagetexte
5. Kompilieren Sie die angepasste Firmware und laden Sie sie herunter
6. Flaschen Sie die Firmware mit dem offiziellen Programmiertool auf das Modul

Ressourcen & Support

• JuxiTechnology github: Offizieller Open-Source-Code, Beispiele und Entwicklungsressourcen
• Lark Wiki: Vollständige Dokumentation, Benutzerhandbücher und technischer Support