Tarjeta de sonido de activación KWS – Introducción al producto

La tarjeta de sonido de activación KWS de Juxi es un módulo de reconocimiento de voz sin conexión de alto rendimiento diseñado para sistemas embebidos, robótica y aplicaciones IoT. Gracias al procesamiento local sin dependencia de la nube, ofrece un control por voz rápido y fiable con latencia mínima, ideal para escenarios que requieren respuesta rápida y privacidad de datos.

Características principales

• ✅ Procesamiento 100 % sin conexión: todo el reconocimiento de voz se ejecuta localmente en el módulo, sin necesidad de conexión a Internet, lo que garantiza privacidad de datos y baja latencia
• 🎤 Alta precisión de reconocimiento: admite comandos de voz en chino e inglés con una precisión de reconocimiento >95 % en entornos normales
• ⚡ Latencia ultrabaja: respuesta en menos de 300 ms tras el comando de voz, lo que ofrece una experiencia de control en tiempo real
• 🔧 Altamente personalizable: admite palabras de activación y frases de comando personalizadas mediante la herramienta oficial de configuración de firmware
• 🖥️ Compatibilidad multiplataforma: compatible con Raspberry Pi, Jetson Nano, PC x86 y sistemas robóticos ROS/ROS2
• 🔌 Plug-and-Play: interfaz USB HID estándar, sin necesidad de hardware adicional
• 🎛️ Salida de audio integrada: controlador de altavoz integrado para respuestas de retroalimentación de voz
• 💡 Bajo consumo de energía: corriente media de funcionamiento < 50 mA, apto para dispositivos alimentados por batería

Funcionalidad básica

Palabras de activación predeterminadas

El módulo viene preconfigurado con palabras de activación predeterminadas de fábrica:

• Chino: "你好小犀", "小犀小犀", "钜犀"
• Inglés: "Hello Xiaoxi", "Juxi Technology"

Categorías de comandos compatibles

El módulo admite hasta 100 comandos de voz personalizados, entre ellos:

• Control de movimiento: adelante, atrás, girar a la izquierda, girar a la derecha, detenerse
• Control de luces: encender/apagar luces, cambiar el color de la luz (rojo, verde, azul, amarillo)
• Control del sistema: modo de suspensión, activación, regreso a la posición de origen
• Control de actuadores: abrir/cerrar pinza, ajuste de la velocidad del motor
• Comandos personalizados: conjunto de comandos totalmente personalizable para aplicaciones específicas

Protocolo de comunicación

El módulo utiliza un protocolo de puerto serie sencillo y fiable:

• Velocidad en baudios: 115200
• Bits de datos: 8
• Bits de parada: 1
• Paridad: ninguna
• Formato de trama: 0xAA 0x55 [Command Type] [Command ID] 0xFB

Inicio rápido

Ejemplo básico de comunicación serie (Python)

Este es un ejemplo mínimo funcional para leer comandos de voz desde el módulo:

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

Instrucciones de uso

1. Conecta la tarjeta de sonido KWS a tu dispositivo mediante un puerto USB
2. Instala el controlador serie CH341 si es necesario (disponible en: https://www.wch.cn/downloads/CH341SER_EXE.html)
3. Ajusta el nombre del puerto serie en el código para que coincida con tu sistema
4. Ejecuta el script de Python
5. Di la palabra de activación ("Hello Xiaoxi") para activar el módulo
6. Di tu comando dentro de los 5 segundos posteriores al tono de confirmación
7. El módulo reconocerá el comando y lo emitirá a través del puerto serie

Aplicación avanzada: integración con ROS2

El módulo se integra perfectamente con ROS2 (Robot Operating System 2) para aplicaciones robóticas. Este es un ejemplo simplificado de nodo de control por voz:

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

Escenarios de aplicación típicos

• 🤖 Robótica: control por voz para robots móviles, brazos robóticos, UAV y robots de servicio
• 🏠 Hogar inteligente: control por voz de sistemas de iluminación, electrodomésticos, cortinas y seguridad
• 🏭 Control industrial: operación manos libres para equipos industriales, líneas de producción y control de taller
• 🚗 Automoción: sistemas de control por voz en el vehículo para infoentretenimiento, climatización y funciones del coche
• 🎮 Dispositivos IoT: interacción por voz para altavoces inteligentes, pantallas inteligentes y otros dispositivos conectados
• 🎓 Educación e investigación: plataforma de desarrollo para proyectos de interacción por voz e investigación robótica

Especificaciones técnicas

Personalización de firmware

El módulo admite palabras de activación y conjuntos de comandos totalmente personalizables:

1. Visita la Qiying Tairen Voice AI Platform
2. Crea un nuevo proyecto con la configuración del chipset CI1302
3. Añade tus palabras de activación y frases de comando personalizadas
4. Configura los tonos de respuesta y el contenido de difusión
5. Compila y descarga el firmware personalizado
6. Graba el firmware en el módulo con la herramienta de programación oficial

Recursos y soporte

• JuxiTechnology github: Código de código abierto oficial, ejemplos y recursos de desarrollo
• Lark Wiki: Documentación completa, guías de usuario y soporte técnico