Verilator MCP Server

Um servidor MCP para Verilator que oferece simulação RTL, geração automática de testbenches e capacidades de consulta em linguagem natural.

GitHub
4
Experimente este MCPPatrocinado

Documentação

Servidor Verilator MCP

MCP Verilator License

Um servidor inteligente de Model Context Protocol (MCP) para Verilator que fornece simulação RTL, geração automática de testbenches e capacidades de consulta em linguagem natural. Esta ferramenta preenche a lacuna entre assistentes de IA e verificação de hardware, tornando a simulação RTL mais acessível e inteligente.

Recursos

🚀 Capacidades Principais

  • Geração Automática de Testbenches: Gera testbenches de forma inteligente quando nenhum existe
  • Simulação Inteligente: Compila e executa simulações com gerenciamento automático de dependências
  • Consultas em Linguagem Natural: Faça perguntas sobre sua simulação em português simples
  • Análise de Formas de Onda: Gera e analisa formas de onda de simulação
  • Coleta de Cobertura: Acompanha métricas de cobertura de código
  • Consciente de Protocolos: Suporte integrado para protocolos padrão (AXI, APB, etc.)

🤖 Exemplos em Linguagem Natural

Controle de Simulação

  • "Execute a simulação em counter.v"
  • "Simule meu design com captura de forma de onda"
  • "Execute o testbench da CPU com cobertura habilitada"
  • "Compile e execute meu módulo ALU"

Geração de Testbenches

  • "Gere um testbench para meu módulo FIFO"
  • "Crie um testbench AXI para o controlador de memória"
  • "Faça um testbench com estímulo aleatório para minha ALU"
  • "Gere um testbench consciente de protocolo para meu slave APB"

Depuração e Análise

  • "Por que data_valid está baixo em 1000ns?"
  • "O que causou a falha de asserção no tempo 5000?"
  • "Mostre-me quando o sinal de reset muda"
  • "Por que meu sinal de saída está X?"
  • "Depure as transições da máquina de estados"

Cobertura e Verificação

  • "Mostre-me o relatório de cobertura"
  • "Quais blocos de código não estão testados?"
  • "Como posso melhorar a cobertura para o controlador?"
  • "Gere testes para cenários não cobertos"

Compreensão do Design

  • "Explique como o módulo da CPU funciona"
  • "Quais são as entradas e saídas da ALU?"
  • "Analise o desempenho de temporização"
  • "Mostre a hierarquia do módulo"
  • "Qual é a frequência máxima de operação?"

Instalação

Pré-requisitos

  • Node.js 16+
  • Verilator 5.0+ instalado e no PATH
  • Git

Passo 1: Instalar Verilator

O Verilator deve ser instalado antes de usar este servidor MCP.

macOS (Homebrew)

brew install verilator

Ubuntu/Debian

sudo apt-get update
sudo apt-get install verilator

A partir do Código Fonte

git clone https://github.com/verilator/verilator
cd verilator
autoconf
./configure
make -j `nproc`
sudo make install

Verificar Instalação

verilator --version
# Should output: Verilator 5.0 or higher

Passo 2: Instalar Verilator MCP

# Clone the repository
git clone https://github.com/ssql2014/verilator-mcp.git
cd verilator-mcp

# Install dependencies
npm install

# Build the project
npm run build

# Test the server
npm test
# Or run diagnostic
./diagnose.sh

Passo 3: Configurar Claude Desktop

Adicione ao seu arquivo de configuração do Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json no macOS):

{
  "mcpServers": {
    "verilator": {
      "command": "node",
      "args": ["/path/to/verilator-mcp/dist/index.js"],
      "env": {
        "LOG_LEVEL": "info"
      }
    }
  }
}

Passo 4: Reiniciar Claude Desktop

Após atualizar a configuração, reinicie o Claude Desktop para carregar o servidor MCP.

Variáveis de Ambiente

  • LOG_LEVEL: Define o nível de registro (debug, info, warn, error)
  • VERILATOR_PATH: Substitui o caminho de instalação do Verilator

Ferramentas Disponíveis

1. verilator_compile

Compila designs Verilog/SystemVerilog para C++.

Parâmetros:

  • files (obrigatório): Matriz de arquivos de design
  • topModule: Nome do módulo principal
  • optimization: Nível de otimização (0-3)
  • trace: Habilita geração de forma de onda
  • coverage: Habilita coleta de cobertura

Exemplo:

{
  "files": ["cpu.v", "alu.v"],
  "topModule": "cpu",
  "optimization": 2,
  "trace": true
}

2. verilator_simulate

Executa simulação RTL com geração automática de testbench.

Parâmetros:

  • design (obrigatório): Arquivo ou diretório de design
  • testbench: Arquivo de testbench (gerado automaticamente se ausente)
  • autoGenerateTestbench: Habilita geração automática (padrão: true)
  • enableWaveform: Gera formas de onda (padrão: true)
  • simulationTime: Substitui a duração da simulação

Exemplo:

{
  "design": "counter.v",
  "autoGenerateTestbench": true,
  "enableWaveform": true,
  "simulationTime": 10000
}

3. verilator_testbenchgenerator

Gera testbenches inteligentes para módulos.

Parâmetros:

  • targetFile (obrigatório): Arquivo Verilog contendo o módulo
  • targetModule (obrigatório): Nome do módulo
  • template: Estilo de modelo (basic, uvm, cocotb, protocol)
  • protocol: Tipo de protocolo (axi, apb, wishbone, avalon)
  • stimulusType: Geração de estímulo (directed, random, constrained_random)

Exemplo:

{
  "targetFile": "fifo.v",
  "targetModule": "fifo",
  "template": "basic",
  "stimulusType": "constrained_random",
  "generateAssertions": true
}

4. verilator_naturallanguage

Processa consultas em linguagem natural sobre simulação.

Parâmetros:

  • query (obrigatório): Pergunta em linguagem natural
  • context: Contexto atual da simulação
  • history: Histórico de consultas anteriores

Exemplo:

{
  "query": "Why did the assertion fail at time 5000?",
  "context": {
    "currentSimulation": {
      "design": "cpu.v",
      "waveformFile": "simulation.vcd"
    }
  }
}

Recursos

O servidor fornece acesso a artefatos de simulação através de recursos MCP:

  • simulation://[project]/logs/[sim_id] - Logs de saída da simulação
  • simulation://[project]/waves/[sim_id] - Dados de forma de onda
  • simulation://[project]/coverage/[sim_id] - Relatórios de cobertura
  • design://[project]/hierarchy - Hierarquia do módulo
  • design://[project]/interfaces - Definições de interface

Recursos de Geração de Testbenches

Detecção Automática

  • Identificação de sinais de clock e reset
  • Análise de direção e largura das portas
  • Reconhecimento de protocolo
  • Extração de parâmetros

Componentes Gerados

  • Geração de clock com frequência configurável
  • Sequências de reset com polaridade adequada
  • Estímulo direcionado e aleatório
  • Asserções e verificadores básicos
  • Pontos de cobertura
  • Despejo de forma de onda

Suporte a Protocolos

Modelos integrados para:

  • AXI (AXI4, AXI4-Lite, AXI-Stream)
  • APB (APB3, APB4)
  • Wishbone
  • Avalon
  • Protocolos personalizados

Categorias de Consultas em Linguagem Natural

Consultas de Depuração

  • Análise de valor de sinal
  • Investigação de falha de asserção
  • Rastreamento de propagação X/Z
  • Análise de relações de temporização

Consultas de Análise

  • Métricas de desempenho
  • Utilização de recursos
  • Análise de caminho crítico
  • Estimativa de consumo de energia

Consultas de Cobertura

  • Estatísticas de cobertura
  • Identificação de código não coberto
  • Sugestões de cenários de teste

Consultas de Geração

  • Criação de testbenches
  • Geração de padrões de estímulo
  • Geração de asserções
  • Criação de pontos de cobertura

Exemplos

Fluxo Básico de Simulação

// 1. Compile design
{
  "tool": "verilator_compile",
  "arguments": {
    "files": ["alu.v"],
    "topModule": "alu",
    "trace": true
  }
}

// 2. Run simulation (auto-generates testbench)
{
  "tool": "verilator_simulate",
  "arguments": {
    "design": "alu.v",
    "autoGenerateTestbench": true,
    "enableWaveform": true
  }
}

// 3. Query results
{
  "tool": "verilator_naturallanguage",
  "arguments": {
    "query": "Show me any errors in the simulation"
  }
}

Exemplos de Fluxo de Trabalho em Linguagem Natural

Exemplo 1: Verificação Completa de Design

// Natural language: "Generate a testbench and run simulation for counter.v"
{
  "tool": "verilator_naturallanguage",
  "arguments": {
    "query": "Generate a testbench and run simulation for counter.v with coverage"
  }
}

// Response will trigger testbench generation and simulation automatically

Exemplo 2: Depurar Falha de Simulação

// After simulation fails, ask why
{
  "tool": "verilator_naturallanguage",
  "arguments": {
    "query": "Why did my simulation fail?",
    "context": {
      "currentSimulation": {
        "design": "fifo.v",
        "testbench": "tb_fifo.sv",
        "waveformFile": "sim_output/simulation.vcd"
      }
    }
  }
}

// Follow up with specific signal investigation
{
  "tool": "verilator_naturallanguage",
  "arguments": {
    "query": "Why is the full signal high when count is only 5?",
    "context": {
      "currentSimulation": {
        "design": "fifo.v",
        "waveformFile": "sim_output/simulation.vcd"
      }
    }
  }
}

Exemplo 3: Melhoria de Cobertura

// Ask for coverage analysis
{
  "tool": "verilator_naturallanguage",
  "arguments": {
    "query": "What's my current code coverage and how can I improve it?"
  }
}

// Generate specific tests for uncovered code
{
  "tool": "verilator_naturallanguage",
  "arguments": {
    "query": "Generate test cases for the error handling paths"
  }
}

Exemplo 4: Compreensão do Design

// Ask about module functionality
{
  "tool": "verilator_naturallanguage",
  "arguments": {
    "query": "Explain how the AXI arbiter module works and what are its key signals"
  }
}

// Analyze performance
{
  "tool": "verilator_naturallanguage",
  "arguments": {
    "query": "What's the critical path in my design and how can I optimize it?"
  }
}

Testes Baseados em Protocolo

// Generate AXI testbench
{
  "tool": "verilator_testbenchgenerator",
  "arguments": {
    "targetFile": "axi_slave.v",
    "targetModule": "axi_slave",
    "template": "protocol",
    "protocol": "axi",
    "generateAssertions": true
  }
}

// Or use natural language
{
  "tool": "verilator_naturallanguage",
  "arguments": {
    "query": "Create an AXI testbench with burst transactions for my memory controller"
  }
}

Exemplo de Conversa Multi-etapas

// Step 1: Initial query
User: "I have a new UART module, help me verify it"
Assistant: "I'll help you verify your UART module. Let me first generate a testbench..."

// Step 2: Run simulation  
User: "Run the simulation with baud rate 115200"
Assistant: "Running simulation with 115200 baud rate..."

// Step 3: Debug issue
User: "The parity bit seems wrong"
Assistant: "Looking at the waveform, I can see the parity calculation is using even parity..."

// Step 4: Fix and verify
User: "Generate a test specifically for odd parity mode"
Assistant: "I'll create a directed test case for odd parity verification..."

Desenvolvimento

Compilação a partir do Código Fonte

npm install
npm run build

Executando Testes

npm test

Modo de Depuração

LOG_LEVEL=debug npm start

Solução de Problemas

Diagnóstico Rápido

Execute o script de diagnóstico para verificar sua configuração:

./diagnose.sh

Problemas Comuns

  1. Verilator não encontrado

    # Install Verilator first!
brew install verilator  # macOS
sudo apt-get install verilator  # Ubuntu/Debian

# Verify installation
verilator --version

  2. Servidor não inicia no Claude Desktop

    • Certifique-se de que o Verilator está instalado (veja acima)
    • Verifique se os caminhos na configuração do Claude Desktop são absolutos
    • Reinicie o Claude Desktop após alterações na configuração
    • Execute ./diagnose.sh para verificar a configuração

  3. Erros de compilação

    • Verifique se os caminhos dos arquivos estão corretos
    • Valide a sintaxe do SystemVerilog
    • Revise as mensagens de erro nos logs

  4. Falha na geração de testbench

    • Certifique-se de que o módulo tem declarações de porta padrão
    • Verifique se há construções não suportadas
    • Tente opções de modelo mais simples

Para solução de problemas detalhada, consulte TROUBLESHOOTING.md

Contribuindo

Contribuições são bem-vindas! Por favor:

  1. Faça um fork do repositório
  2. Crie um branch de funcionalidade
  3. Adicione testes para novos recursos
  4. Envie um pull request

Licença

Licença MIT - consulte o arquivo LICENSE para detalhes

Agradecimentos

  • Construído sobre o Model Context Protocol da Anthropic
  • Alimentado pelo simulador de código aberto Verilator
  • Processamento de linguagem natural usando a biblioteca Natural