Placa de Som com Wake-Up KWS — Introdução ao Produto

A Placa de Som de Ativação por Voz Juxi KWS é um módulo de reconhecimento de voz offline de alto desempenho projetado para sistemas embarcados, robótica e aplicações de IoT. Com processamento local sem dependência de nuvem, oferece controle de voz rápido e confiável com latência mínima, sendo ideal para cenários que exigem resposta rápida e privacidade de dados.

Recursos Principais

• ✅ Processamento 100% offline: todo o reconhecimento de voz é executado localmente no módulo, sem necessidade de conexão com a internet, garantindo privacidade de dados e baixa latência
• 🎤 Alta precisão de reconhecimento: suporta comandos de voz em chinês e inglês com precisão de reconhecimento >95% em ambientes normais
• ⚡ Latência ultrabaixa: resposta em até 300ms após a entrada do comando de voz, proporcionando uma experiência de controle em tempo real
• 🔧 Altamente personalizável: suporte a palavras de ativação e frases de comando personalizadas através da ferramenta oficial de configuração de firmware
• 🖥️ Suporte a múltiplas plataformas: compatível com Raspberry Pi, Jetson Nano, PCs x86 e sistemas robóticos ROS/ROS2
• 🔌 Plug and play: interface USB HID padrão, sem necessidade de hardware adicional para operação
• 🎛️ Saída de áudio integrada: driver de alto-falante integrado para respostas de feedback de voz
• 💡 Baixo consumo de energia: corrente operacional média < 50mA, adequado para dispositivos alimentados por bateria

Funcionalidades Básicas

Palavras de Ativação Padrão

O módulo vem pré-configurado com palavras de ativação padrão de fábrica:

• Chinês: "你好小犀", "小犀小犀", "钜犀"
• Inglês: "Hello Xiaoxi", "Juxi Technology"

Categorias de Comandos Suportados

O módulo suporta até 100 comandos de voz personalizados, incluindo:

• Controle de movimento: avançar, recuar, virar à esquerda, virar à direita, parar
• Controle de luz: ligar/desligar luzes, alterar cores das luzes (vermelho, verde, azul, amarelo)
• Controle do sistema: modo de suspensão, despertar, retornar à posição de origem
• Controle de atuadores: abrir/fechar garra, ajuste de velocidade do motor
• Comandos personalizados: conjunto de comandos totalmente personalizável para aplicações específicas

Protocolo de Comunicação

O módulo usa um protocolo de porta serial simples e confiável:

• Baud rate: 115200
• Bits de dados: 8
• Bits de parada: 1
• Paridade: Nenhuma
• Formato do quadro: 0xAA 0x55 [Command Type] [Command ID] 0xFB

Início Rápido

Exemplo Básico de Comunicação Serial (Python)

Aqui está um exemplo mínimo funcional para ler comandos de voz do 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")

Instruções de Uso

1. Conecte a placa de som KWS ao seu dispositivo via porta USB
2. Instale o driver serial CH341 se necessário (disponível em: https://www.wch.cn/downloads/CH341SER_EXE.html)
3. Ajuste o nome da porta serial no código para corresponder ao seu sistema
4. Execute o script Python
5. Fale a palavra de ativação ("Hello Xiaoxi") para ativar o módulo
6. Fale seu comando em até 5 segundos após o tom de confirmação
7. O módulo reconhecerá e emitirá o comando via porta serial

Aplicação Avançada: Integração com ROS2

O módulo se integra perfeitamente ao ROS2 (Robot Operating System 2) para aplicações robóticas. Aqui está um exemplo simplificado de nó de controle de 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()

Cenários de Aplicação Típicos

• 🤖 Robótica: controle de voz para robôs móveis, braços robóticos, UAVs e robôs de serviço
• 🏠 Casa Inteligente: controle de voz para sistemas de iluminação, eletrodomésticos, controle de cortinas e sistemas de segurança
• 🏭 Controle Industrial: operação mãos livres para equipamentos industriais, linhas de produção e controle de oficina
• 🚗 Automotivo: sistemas de controle de voz embarcados para infoentretenimento, controle de climatização e funções do veículo
• 🎮 Dispositivos IoT: interação de voz para alto-falantes inteligentes, displays inteligentes e outros dispositivos conectados
• 🎓 Educação & Pesquisa: plataforma de desenvolvimento para projetos de interação de voz e pesquisa em robótica

Especificações Técnicas

Personalização de Firmware

O módulo suporta palavras de ativação e conjuntos de comandos totalmente personalizáveis:

1. Visite a Plataforma de IA de Voz Qiying Tairen
2. Crie um novo projeto com configuração de chipset CI1302
3. Adicione suas palavras de ativação e frases de comando personalizadas
4. Configure tons de resposta e conteúdo de transmissão
5. Compile e baixe o firmware personalizado
6. Grave o firmware no módulo usando a ferramenta oficial de programação

Recursos & Suporte

• GitHub da JuxiTechnology: código open source oficial, exemplos e recursos de desenvolvimento
• Wiki do Lark: documentação completa, guias do usuário e suporte técnico