Carte son de réveil KWS – Introduction au produit

La carte son de réveil KWS de Juxi est un module de reconnaissance vocale hors ligne haute performance conçu pour les systèmes embarqués, la robotique et les applications IoT. Grâce à un traitement local sans dépendance au cloud, elle offre un contrôle vocal rapide et fiable avec une latence minimale, idéal pour les scénarios exigeant une réponse rapide et la confidentialité des données.

Principales caractéristiques

• ✅ Traitement 100 % hors ligne : toute la reconnaissance vocale s’exécute localement sur le module, sans connexion Internet, garantissant confidentialité des données et faible latence
• 🎤 Haute précision de reconnaissance : prend en charge les commandes vocales en chinois et en anglais avec une précision de reconnaissance >95 % dans les environnements normaux
• ⚡ Latence ultra-faible : réponse en moins de 300 ms après la commande vocale, pour une expérience de contrôle en temps réel
• 🔧 Hautement personnalisable : prise en charge de mots de réveil et de phrases de commande personnalisés via l’outil officiel de configuration du firmware
• 🖥️ Prise en charge multiplateforme : compatible avec Raspberry Pi, Jetson Nano, PC x86 et systèmes robotiques ROS/ROS2
• 🔌 Plug-and-Play : interface USB HID standard, aucun matériel supplémentaire requis
• 🎛️ Sortie audio intégrée : pilote de haut-parleur intégré pour les réponses vocales de retour
• 💡 Faible consommation : courant de fonctionnement moyen < 50 mA, adapté aux appareils alimentés par batterie

Fonctionnalités de base

Mots de réveil par défaut

Le module est préconfiguré avec des mots de réveil par défaut d’usine :

• Chinois : "你好小犀", "小犀小犀", "钜犀"
• Anglais : "Hello Xiaoxi", "Juxi Technology"

Catégories de commandes prises en charge

Le module prend en charge jusqu’à 100 commandes vocales personnalisées, notamment :

• Contrôle des mouvements : avancer, reculer, tourner à gauche, tourner à droite, s’arrêter
• Contrôle de l’éclairage : allumer/éteindre les lumières, changer la couleur (rouge, vert, bleu, jaune)
• Contrôle du système : mode veille, réveil, retour à la position d’origine
• Contrôle des actionneurs : ouverture/fermeture de la pince, réglage de la vitesse du moteur
• Commandes personnalisées : jeu de commandes entièrement personnalisable pour des applications spécifiques

Protocole de communication

Le module utilise un protocole de port série simple et fiable :

• Débit en bauds : 115200
• Bits de données : 8
• Bits d’arrêt : 1
• Parité : aucune
• Format de trame : 0xAA 0x55 [Command Type] [Command ID] 0xFB

Démarrage rapide

Exemple de base de communication série (Python)

Voici un exemple minimaliste fonctionnel pour lire les commandes vocales du module :

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

Instructions d'utilisation

1. Connectez la carte son KWS à votre appareil via un port USB
2. Installez le pilote série CH341 si nécessaire (disponible à l’adresse : https://www.wch.cn/downloads/CH341SER_EXE.html)
3. Adaptez le nom du port série dans le code à votre système
4. Exécutez le script Python
5. Prononcez le mot de réveil ("Hello Xiaoxi") pour activer le module
6. Prononcez votre commande dans les 5 secondes suivant le signal sonore de confirmation
7. Le module reconnaîtra la commande et l’émettra via le port série

Application avancée : intégration ROS2

Le module s’intègre parfaitement à ROS2 (Robot Operating System 2) pour les applications robotiques. Voici un exemple simplifié de nœud de commande 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()

Scénarios d'application typiques

• 🤖 Robotique : contrôle vocal pour robots mobiles, bras robotiques, drones (UAV) et robots de service
• 🏠 Maison intelligente : contrôle vocal des éclairages, appareils électroménagers, rideaux et systèmes de sécurité
• 🏭 Contrôle industriel : fonctionnement mains libres pour équipements industriels, chaînes de production et contrôle d’atelier
• 🚗 Automobile : systèmes de commande vocale embarqués pour l’infodivertissement, le contrôle climatique et les fonctions du véhicule
• 🎮 Appareils IoT : interaction vocale pour enceintes intelligentes, écrans intelligents et autres appareils connectés
• 🎓 Éducation & recherche : plateforme de développement pour les projets d’interaction vocale et la recherche en robotique

Spécifications techniques

Personnalisation du firmware

Le module prend en charge des mots de réveil et des jeux de commandes entièrement personnalisables :

1. Visitez la Qiying Tairen Voice AI Platform
2. Créez un nouveau projet avec la configuration du chipset CI1302
3. Ajoutez vos mots de réveil et phrases de commande personnalisés
4. Configurez les tonalités de réponse et le contenu diffusé
5. Compilez et téléchargez le firmware personnalisé
6. Flashez le firmware sur le module à l’aide de l’outil de programmation officiel

Ressources et support

• JuxiTechnology github: Code open source officiel, exemples et ressources de développement
• Lark Wiki: Documentation complète, guides d’utilisation et support technique