KWS Wake-up Sound Card - Product Introduction

The Juxi KWS Wake-up Sound Card is a high-performance offline voice recognition module designed for embedded systems, robotics, and IoT applications. Featuring local processing without cloud dependency, it provides fast, reliable voice control with minimal latency, making it ideal for scenarios requiring fast response and data privacy.

Key Features

• ✅ 100% Offline Processing: All voice recognition runs locally on the module, no internet connection required, ensuring data privacy and low latency
• 🎤 High Recognition Accuracy: Supports both Chinese and English voice commands with >95% recognition accuracy in normal environments
• ⚡ Ultra-Low Latency: Response within 300ms after voice command input, providing real-time control experience
• 🔧 Highly Customizable: Support custom wake words and command phrases via official firmware configuration tool
• 🖥️ Multi-Platform Support: Compatible with Raspberry Pi, Jetson Nano, x86 PCs, and ROS/ROS2 robotic systems
• 🔌 Plug-and-Play: Standard USB HID interface, no additional hardware required for operation
• 🎛️ Integrated Audio Output: Built-in speaker driver for voice feedback responses
• 💡 Low Power Consumption: Average operating current < 50mA, suitable for battery-powered devices

Basic Functionality

Default Wake-up Words

The module comes pre-configured with factory default wake words:

• Chinese: "你好小犀", "小犀小犀", "钜犀"
• English: "Hello Xiaoxi", "Juxi Technology"

Supported Command Categories

The module supports up to 100 custom voice commands, including:

• Motion control: forward, backward, turn left, turn right, stop
• Light control: turn on/off lights, change light colors (red, green, blue, yellow)
• System control: sleep mode, wake up, return to origin position
• Actuator control: gripper open/close, motor speed adjustment
• Custom commands: Fully customizable command set for specific applications

Communication Protocol

The module uses a simple and reliable serial port protocol:

• Baud rate: 115200
• Data bits: 8
• Stop bits: 1
• Parity: None
• Frame format: 0xAA 0x55 [Command Type] [Command ID] 0xFB

Quick Start

Basic Serial Communication Example (Python)

Here's a minimal working example to read voice commands from the 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")

Usage Instructions

1. Connect the KWS sound card to your device via USB port
2. Install CH341 serial driver if needed (available at: https://www.wch.cn/downloads/CH341SER_EXE.html)
3. Adjust the serial port name in the code to match your system
4. Run the Python script
5. Speak the wake word ("Hello Xiaoxi") to activate the module
6. Speak your command within 5 seconds after the confirmation tone
7. The module will recognize and output the command via serial port

Advanced Application: ROS2 Integration

The module seamlessly integrates with ROS2 (Robot Operating System 2) for robotic applications. Here's a simplified voice control node example:

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

Typical Application Scenarios

• 🤖 Robotics: Voice control for mobile robots, robotic arms, UAVs, and service robots
• 🏠 Smart Home: Voice control for lighting systems, home appliances, curtain control, and security systems
• 🏭 Industrial Control: Hands-free operation for industrial equipment, production lines, and workshop control
• 🚗 Automotive: In-vehicle voice control systems for infotainment, climate control, and vehicle functions
• 🎮 IoT Devices: Voice interaction for smart speakers, smart displays, and other connected devices
• 🎓 Education & Research: Development platform for voice interaction projects and robotics research

Technical Specifications

Firmware Customization

The module supports fully customizable wake words and command sets:

1. Visit the Qiying Tairen Voice AI Platform
2. Create a new project with CI1302 chipset configuration
3. Add your custom wake words and command phrases
4. Configure response tones and broadcast content
5. Compile and download the customized firmware
6. Flash the firmware to the module using the official programming tool

Resources & Support

• JuxiTechnology github: Official open-source code, examples, and development resources
• Lark Wiki: Complete documentation, user guides, and technical support