Scheda audio di risveglio KWS – Introduzione al prodotto

La scheda audio wake-up KWS di Juxi è un modulo di riconoscimento vocale offline ad alte prestazioni progettato per sistemi embedded, robotica e applicazioni IoT. Grazie all'elaborazione locale senza dipendenza dal cloud, offre un controllo vocale rapido e affidabile con latenza minima, ideale per scenari che richiedono risposta immediata e privacy dei dati.

Caratteristiche principali

• ✅ Elaborazione 100% offline: tutto il riconoscimento vocale viene eseguito localmente sul modulo, senza connessione Internet, garantendo privacy dei dati e bassa latenza
• 🎤 Elevata precisione di riconoscimento: supporta comandi vocali in cinese e inglese con precisione >95% in ambienti normali
• ⚡ Latenza ultra-bassa: risposta entro 300 ms dopo il comando vocale, per un controllo in tempo reale
• 🔧 Altamente personalizzabile: supporto di wake word e frasi di comando personalizzate tramite lo strumento ufficiale di configurazione del firmware
• 🖥️ Supporto multi-piattaforma: compatibile con Raspberry Pi, Jetson Nano, PC x86 e sistemi robotici ROS/ROS2
• 🔌 Plug-and-Play: interfaccia USB HID standard, nessun hardware aggiuntivo richiesto
• 🎛️ Uscita audio integrata: driver per altoparlante integrato per il feedback vocale
• 💡 Basso consumo energetico: corrente media di esercizio < 50 mA, adatto a dispositivi a batteria

Funzionalità di base

Wake word predefiniti

Il modulo viene fornito preconfigurato con wake word di fabbrica:

• Cinese: "你好小犀", "小犀小犀", "钜犀"
• Inglese: "Hello Xiaoxi", "Juxi Technology"

Categorie di comandi supportate

Il modulo supporta fino a 100 comandi vocali personalizzati, tra cui:

• Controllo del movimento: avanti, indietro, gira a sinistra, gira a destra, fermati
• Controllo luci: accendi/spegni le luci, cambia il colore (rosso, verde, blu, giallo)
• Controllo di sistema: modalità sospensione, risveglio, ritorno alla posizione iniziale
• Controllo attuatori: apertura/chiusura pinza, regolazione velocità motore
• Comandi personalizzati: set di comandi completamente personalizzabile per applicazioni specifiche

Protocollo di comunicazione

Il modulo utilizza un protocollo seriale semplice e affidabile:

• Baud rate: 115200
• Bit di dati: 8
• Bit di stop: 1
• Parità: nessuna
• Formato frame: 0xAA 0x55 [Command Type] [Command ID] 0xFB

Avvio rapido

Esempio base di comunicazione seriale (Python)

Ecco un esempio minimale funzionante per leggere i comandi vocali dal modulo:

#!/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")

Istruzioni per l’uso

1. Collega la scheda audio KWS al dispositivo tramite porta USB
2. Se necessario, installare il driver seriale CH341 (disponibile su: https://www.wch.cn/downloads/CH341SER_EXE.html)
3. Adatta il nome della porta seriale nel codice al tuo sistema
4. Esegui lo script Python
5. Pronuncia la wake word ("Hello Xiaoxi") per attivare il modulo
6. Pronuncia il comando entro 5 secondi dal tono di conferma
7. Il modulo riconoscerà il comando e lo trasmetterà tramite porta seriale

Applicazione avanzata: integrazione ROS2

Il modulo si integra perfettamente con ROS2 (Robot Operating System 2) per applicazioni robotiche. Ecco un esempio semplificato di nodo di controllo vocale:

#!/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()

Scenari applicativi tipici

• 🤖 Robotica: controllo vocale per robot mobili, bracci robotici, UAV e robot di servizio
• 🏠 Smart Home: controllo vocale per illuminazione, elettrodomestici, tende e sistemi di sicurezza
• 🏭 Controllo industriale: funzionamento a mani libere per apparecchiature industriali, linee di produzione e controllo officina
• 🚗 Automotive: sistemi di controllo vocale in auto per infotainment, climatizzazione e funzioni del veicolo
• 🎮 Dispositivi IoT: interazione vocale per smart speaker, smart display e altri dispositivi connessi
• 🎓 Istruzione & ricerca: piattaforma di sviluppo per progetti di interazione vocale e ricerca robotica

Specifiche tecniche

Personalizzazione del firmware

Il modulo supporta wake word e set di comandi completamente personalizzabili:

1. Visita la Qiying Tairen Voice AI Platform
2. Crea un nuovo progetto con configurazione chipset CI1302
3. Aggiungi le tue wake word e frasi di comando personalizzate
4. Configura toni di risposta e contenuto di broadcast
5. Compila e scarica il firmware personalizzato
6. Flashare il firmware sul modulo usando lo strumento di programmazione ufficiale

Risorse e supporto

• JuxiTechnology github: Codice open source ufficiale, esempi e risorse di sviluppo
• Lark Wiki: Documentazione completa, guide utente e supporto tecnico