865 lines
23 KiB
Markdown
865 lines
23 KiB
Markdown
# Vivado 联动功能技术设计文档
|
||
|
||
## 1. 架构设计
|
||
|
||
### 1.1 整体架构
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ 后端 AI 服务 │
|
||
│ (调用 runVivado 工具) │
|
||
└────────────────────────────┬────────────────────────────────┘
|
||
│ 工具调用请求
|
||
↓
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ VS Code Extension │
|
||
│ ┌──────────────────────────────────────────────────────┐ │
|
||
│ │ ICHelperPanel (Webview) │ │
|
||
│ │ - 接收后端工具调用 │ │
|
||
│ │ - 显示执行进度和日志 │ │
|
||
│ │ - 展示执行结果 │ │
|
||
│ └──────────────────────────────────────────────────────┘ │
|
||
│ ↓ │
|
||
│ ┌──────────────────────────────────────────────────────┐ │
|
||
│ │ VivadoRunner (utils/vivadoRunner.ts) │ │
|
||
│ │ - 配置管理 │ │
|
||
│ │ - TCL 脚本生成 │ │
|
||
│ │ - 命令执行 │ │
|
||
│ │ - 进度监控 │ │
|
||
│ │ - 结果解析 │ │
|
||
│ └──────────────────────────────────────────────────────┘ │
|
||
│ ↓ │
|
||
│ ┌──────────────────────────────────────────────────────┐ │
|
||
│ │ FileImporter (utils/fileImporter.ts) │ │
|
||
│ │ - 查找产出文件 │ │
|
||
│ │ - 复制文件到目标目录 │ │
|
||
│ │ - 通知文件变更 │ │
|
||
│ └──────────────────────────────────────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
↓
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ 本地 Vivado 工具 │
|
||
│ (通过子进程执行 TCL 脚本) │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 1.2 模块职责
|
||
|
||
#### 1.2.1 VivadoRunner
|
||
- 读取和验证 Vivado 配置
|
||
- 根据命令类型生成 TCL 脚本
|
||
- 启动子进程执行 Vivado
|
||
- 实时捕获输出并解析进度
|
||
- 返回执行结果
|
||
|
||
#### 1.2.2 FileImporter
|
||
- 根据文件模式查找产出文件
|
||
- 复制文件到指定目录
|
||
- 返回已导入的文件列表
|
||
|
||
#### 1.2.3 MessageHandler
|
||
- 接收后端的 `runVivado` 工具调用
|
||
- 调用 VivadoRunner 执行
|
||
- 向 Webview 推送进度和结果
|
||
|
||
## 2. 数据结构设计
|
||
|
||
### 2.1 配置结构
|
||
|
||
```typescript
|
||
/**
|
||
* Vivado 配置
|
||
*/
|
||
interface VivadoConfig {
|
||
enabled: boolean;
|
||
executablePath: string;
|
||
workingDir: string;
|
||
part: string;
|
||
commands: {
|
||
synthesis: string;
|
||
implementation: string;
|
||
bitstream: string;
|
||
};
|
||
outputFiles: {
|
||
synthesis: string[];
|
||
implementation: string[];
|
||
bitstream: string[];
|
||
};
|
||
}
|
||
```
|
||
|
||
### 2.2 请求和响应结构
|
||
|
||
```typescript
|
||
/**
|
||
* Vivado 工具请求
|
||
*/
|
||
interface VivadoToolRequest {
|
||
command: 'synthesis' | 'implementation' | 'bitstream';
|
||
parameters?: {
|
||
topModule?: string;
|
||
files?: string[];
|
||
part?: string;
|
||
constraints?: string;
|
||
outputDir?: string;
|
||
};
|
||
importOutput?: {
|
||
enabled: boolean;
|
||
targetDir: string;
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Vivado 工具响应
|
||
*/
|
||
interface VivadoToolResponse {
|
||
success: boolean;
|
||
command: string;
|
||
executionTime: number;
|
||
output: string;
|
||
error?: string;
|
||
importedFiles?: string[];
|
||
reports?: {
|
||
resources?: string;
|
||
timing?: string;
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 执行进度
|
||
*/
|
||
interface VivadoProgress {
|
||
stage: string;
|
||
percentage: number;
|
||
message: string;
|
||
}
|
||
```
|
||
|
||
## 3. 核心模块实现
|
||
|
||
### 3.1 配置管理
|
||
|
||
#### 3.1.1 配置读取
|
||
```typescript
|
||
// src/utils/vivadoConfig.ts
|
||
|
||
import * as vscode from 'vscode';
|
||
import * as path from 'path';
|
||
import * as fs from 'fs';
|
||
|
||
export function getVivadoConfig(): VivadoConfig | null {
|
||
// 优先读取项目配置
|
||
const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
|
||
if (workspaceFolder) {
|
||
const projectConfigPath = path.join(
|
||
workspaceFolder.uri.fsPath,
|
||
'.vscode',
|
||
'ic-coder-vivado.json'
|
||
);
|
||
if (fs.existsSync(projectConfigPath)) {
|
||
const content = fs.readFileSync(projectConfigPath, 'utf-8');
|
||
return JSON.parse(content).vivado;
|
||
}
|
||
}
|
||
|
||
// 读取全局配置
|
||
const config = vscode.workspace.getConfiguration('ic-coder');
|
||
return config.get<VivadoConfig>('vivado') || null;
|
||
}
|
||
|
||
export function validateConfig(config: VivadoConfig): string | null {
|
||
if (!config.enabled) {
|
||
return 'Vivado 未启用';
|
||
}
|
||
if (!fs.existsSync(config.executablePath)) {
|
||
return `Vivado 可执行文件不存在: ${config.executablePath}`;
|
||
}
|
||
return null;
|
||
}
|
||
```
|
||
|
||
### 3.2 TCL 脚本生成
|
||
|
||
#### 3.2.1 脚本生成器
|
||
```typescript
|
||
// src/utils/tclGenerator.ts
|
||
|
||
export function generateSynthesisTcl(
|
||
topModule: string,
|
||
files: string[],
|
||
part: string,
|
||
constraints?: string,
|
||
outputDir?: string
|
||
): string {
|
||
const output = outputDir || '.';
|
||
let tcl = `# Vivado 综合脚本\n\n`;
|
||
|
||
// 读取源文件
|
||
files.forEach(file => {
|
||
tcl += `read_verilog ${file}\n`;
|
||
});
|
||
|
||
// 读取约束文件
|
||
if (constraints) {
|
||
tcl += `read_xdc ${constraints}\n`;
|
||
}
|
||
|
||
tcl += `\n# 综合\n`;
|
||
tcl += `synth_design -part ${part} -top ${topModule}\n\n`;
|
||
|
||
// 生成报告
|
||
tcl += `# 生成报告\n`;
|
||
tcl += `report_utilization -file ${output}/${topModule}_utilization_synth.rpt\n`;
|
||
tcl += `report_timing -file ${output}/${topModule}_timing_synth.rpt\n\n`;
|
||
|
||
// 保存检查点
|
||
tcl += `# 保存检查点\n`;
|
||
tcl += `write_checkpoint -force ${output}/${topModule}_synth.dcp\n`;
|
||
|
||
return tcl;
|
||
}
|
||
|
||
export function generateImplementationTcl(
|
||
dcpFile: string,
|
||
outputDir?: string
|
||
): string {
|
||
const output = outputDir || '.';
|
||
const baseName = path.basename(dcpFile, '.dcp').replace('_synth', '');
|
||
|
||
let tcl = `# Vivado 实现脚本\n\n`;
|
||
tcl += `open_checkpoint ${dcpFile}\n\n`;
|
||
|
||
tcl += `# 优化\n`;
|
||
tcl += `opt_design\n`;
|
||
tcl += `place_design\n`;
|
||
tcl += `route_design\n\n`;
|
||
|
||
tcl += `# 生成报告\n`;
|
||
tcl += `report_utilization -file ${output}/${baseName}_utilization_impl.rpt\n`;
|
||
tcl += `report_timing_summary -file ${output}/${baseName}_timing_impl.rpt\n\n`;
|
||
|
||
tcl += `# 保存检查点\n`;
|
||
tcl += `write_checkpoint -force ${output}/${baseName}_impl.dcp\n`;
|
||
|
||
return tcl;
|
||
}
|
||
|
||
export function generateBitstreamTcl(
|
||
dcpFile: string,
|
||
outputDir?: string
|
||
): string {
|
||
const output = outputDir || '.';
|
||
const baseName = path.basename(dcpFile, '.dcp').replace('_impl', '');
|
||
|
||
let tcl = `# Vivado 比特流生成脚本\n\n`;
|
||
tcl += `open_checkpoint ${dcpFile}\n\n`;
|
||
|
||
tcl += `# 生成比特流\n`;
|
||
tcl += `write_bitstream -force ${output}/${baseName}.bit\n`;
|
||
|
||
return tcl;
|
||
}
|
||
```
|
||
|
||
### 3.3 VivadoRunner 实现
|
||
|
||
```typescript
|
||
// src/utils/vivadoRunner.ts
|
||
|
||
import * as vscode from 'vscode';
|
||
import * as path from 'path';
|
||
import * as fs from 'fs';
|
||
import { spawn } from 'child_process';
|
||
import { getVivadoConfig, validateConfig } from './vivadoConfig';
|
||
import { generateSynthesisTcl, generateImplementationTcl, generateBitstreamTcl } from './tclGenerator';
|
||
|
||
export async function runVivado(
|
||
request: VivadoToolRequest,
|
||
progressCallback?: (progress: VivadoProgress) => void
|
||
): Promise<VivadoToolResponse> {
|
||
const startTime = Date.now();
|
||
|
||
// 读取配置
|
||
const config = getVivadoConfig();
|
||
if (!config) {
|
||
return {
|
||
success: false,
|
||
command: request.command,
|
||
executionTime: 0,
|
||
output: '',
|
||
error: 'Vivado 未配置'
|
||
};
|
||
}
|
||
|
||
// 验证配置
|
||
const configError = validateConfig(config);
|
||
if (configError) {
|
||
return {
|
||
success: false,
|
||
command: request.command,
|
||
executionTime: 0,
|
||
output: '',
|
||
error: configError
|
||
};
|
||
}
|
||
|
||
// 准备工作目录
|
||
const workingDir = resolveWorkingDir(config.workingDir);
|
||
if (!fs.existsSync(workingDir)) {
|
||
fs.mkdirSync(workingDir, { recursive: true });
|
||
}
|
||
|
||
// 生成 TCL 脚本
|
||
const tclScript = generateTclScript(request, config, workingDir);
|
||
const tclPath = path.join(workingDir, `${request.command}.tcl`);
|
||
fs.writeFileSync(tclPath, tclScript);
|
||
|
||
// 执行 Vivado
|
||
const result = await executeVivado(
|
||
config.executablePath,
|
||
tclPath,
|
||
workingDir,
|
||
progressCallback
|
||
);
|
||
|
||
const executionTime = Date.now() - startTime;
|
||
|
||
// 解析报告
|
||
const reports = parseReports(request.command, workingDir, request.parameters?.topModule);
|
||
|
||
// 导入文件
|
||
let importedFiles: string[] = [];
|
||
if (request.importOutput?.enabled && result.success) {
|
||
importedFiles = await importOutputFiles(
|
||
request.command,
|
||
config,
|
||
workingDir,
|
||
request.importOutput.targetDir
|
||
);
|
||
}
|
||
|
||
return {
|
||
success: result.success,
|
||
command: request.command,
|
||
executionTime,
|
||
output: result.output,
|
||
error: result.error,
|
||
importedFiles,
|
||
reports
|
||
};
|
||
}
|
||
|
||
function generateTclScript(
|
||
request: VivadoToolRequest,
|
||
config: VivadoConfig,
|
||
workingDir: string
|
||
): string {
|
||
const { command, parameters } = request;
|
||
const part = parameters?.part || config.part;
|
||
|
||
switch (command) {
|
||
case 'synthesis':
|
||
return generateSynthesisTcl(
|
||
parameters?.topModule || 'top',
|
||
parameters?.files || [],
|
||
part,
|
||
parameters?.constraints,
|
||
parameters?.outputDir
|
||
);
|
||
case 'implementation':
|
||
const synthDcp = path.join(workingDir, `${parameters?.topModule}_synth.dcp`);
|
||
return generateImplementationTcl(synthDcp, parameters?.outputDir);
|
||
case 'bitstream':
|
||
const implDcp = path.join(workingDir, `${parameters?.topModule}_impl.dcp`);
|
||
return generateBitstreamTcl(implDcp, parameters?.outputDir);
|
||
default:
|
||
throw new Error(`未知命令: ${command}`);
|
||
}
|
||
}
|
||
|
||
async function executeVivado(
|
||
executablePath: string,
|
||
tclPath: string,
|
||
workingDir: string,
|
||
progressCallback?: (progress: VivadoProgress) => void
|
||
): Promise<{ success: boolean; output: string; error?: string }> {
|
||
return new Promise((resolve) => {
|
||
let output = '';
|
||
let errorOutput = '';
|
||
|
||
const process = spawn(executablePath, ['-mode', 'batch', '-source', tclPath], {
|
||
cwd: workingDir,
|
||
shell: true
|
||
});
|
||
|
||
process.stdout.on('data', (data) => {
|
||
const text = data.toString();
|
||
output += text;
|
||
|
||
// 解析进度
|
||
if (progressCallback) {
|
||
const progress = parseProgress(text);
|
||
if (progress) {
|
||
progressCallback(progress);
|
||
}
|
||
}
|
||
});
|
||
|
||
process.stderr.on('data', (data) => {
|
||
errorOutput += data.toString();
|
||
});
|
||
|
||
process.on('close', (code) => {
|
||
if (code === 0) {
|
||
resolve({ success: true, output });
|
||
} else {
|
||
resolve({ success: false, output, error: errorOutput || '执行失败' });
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
function parseProgress(logText: string): VivadoProgress | null {
|
||
// 解析 Vivado 日志中的进度信息
|
||
if (logText.includes('Starting synthesis')) {
|
||
return { stage: 'synthesis', percentage: 10, message: '开始综合' };
|
||
}
|
||
if (logText.includes('Finished synthesis')) {
|
||
return { stage: 'synthesis', percentage: 100, message: '综合完成' };
|
||
}
|
||
// 更多进度解析...
|
||
return null;
|
||
}
|
||
|
||
function parseReports(
|
||
command: string,
|
||
workingDir: string,
|
||
topModule?: string
|
||
): { resources?: string; timing?: string } {
|
||
const reports: { resources?: string; timing?: string } = {};
|
||
|
||
if (command === 'synthesis' || command === 'implementation') {
|
||
const utilizationFile = path.join(
|
||
workingDir,
|
||
`${topModule}_utilization_${command === 'synthesis' ? 'synth' : 'impl'}.rpt`
|
||
);
|
||
if (fs.existsSync(utilizationFile)) {
|
||
const content = fs.readFileSync(utilizationFile, 'utf-8');
|
||
reports.resources = extractResourceSummary(content);
|
||
}
|
||
|
||
const timingFile = path.join(
|
||
workingDir,
|
||
`${topModule}_timing_${command === 'synthesis' ? 'synth' : 'impl'}.rpt`
|
||
);
|
||
if (fs.existsSync(timingFile)) {
|
||
const content = fs.readFileSync(timingFile, 'utf-8');
|
||
reports.timing = extractTimingSummary(content);
|
||
}
|
||
}
|
||
|
||
return reports;
|
||
}
|
||
|
||
function extractResourceSummary(reportContent: string): string {
|
||
// 提取资源使用摘要
|
||
const lines = reportContent.split('\n');
|
||
const summary: string[] = [];
|
||
|
||
for (const line of lines) {
|
||
if (line.includes('LUT') || line.includes('FF') || line.includes('BRAM')) {
|
||
summary.push(line.trim());
|
||
}
|
||
}
|
||
|
||
return summary.join('\n');
|
||
}
|
||
|
||
function extractTimingSummary(reportContent: string): string {
|
||
// 提取时序摘要
|
||
const lines = reportContent.split('\n');
|
||
for (const line of lines) {
|
||
if (line.includes('WNS') || line.includes('TNS')) {
|
||
return line.trim();
|
||
}
|
||
}
|
||
return '';
|
||
}
|
||
|
||
function resolveWorkingDir(workingDir: string): string {
|
||
const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
|
||
if (workspaceFolder) {
|
||
return workingDir.replace('${workspaceFolder}', workspaceFolder.uri.fsPath);
|
||
}
|
||
return workingDir;
|
||
}
|
||
```
|
||
|
||
### 3.4 文件导入实现
|
||
|
||
```typescript
|
||
// src/utils/fileImporter.ts
|
||
|
||
import * as vscode from 'vscode';
|
||
import * as path from 'path';
|
||
import * as fs from 'fs';
|
||
import * as glob from 'glob';
|
||
|
||
export async function importOutputFiles(
|
||
command: string,
|
||
config: VivadoConfig,
|
||
sourceDir: string,
|
||
targetDir: string
|
||
): Promise<string[]> {
|
||
const patterns = config.outputFiles[command] || [];
|
||
const importedFiles: string[] = [];
|
||
|
||
for (const pattern of patterns) {
|
||
const files = glob.sync(pattern, { cwd: sourceDir });
|
||
|
||
for (const file of files) {
|
||
const sourcePath = path.join(sourceDir, file);
|
||
const targetPath = path.join(targetDir, file);
|
||
|
||
// 确保目标目录存在
|
||
const targetDirPath = path.dirname(targetPath);
|
||
if (!fs.existsSync(targetDirPath)) {
|
||
fs.mkdirSync(targetDirPath, { recursive: true });
|
||
}
|
||
|
||
// 复制文件
|
||
fs.copyFileSync(sourcePath, targetPath);
|
||
importedFiles.push(targetPath);
|
||
}
|
||
}
|
||
|
||
return importedFiles;
|
||
}
|
||
```
|
||
|
||
### 3.5 MessageHandler 集成
|
||
|
||
```typescript
|
||
// src/utils/messageHandler.ts (新增部分)
|
||
|
||
import { runVivado } from './vivadoRunner';
|
||
|
||
// 在 handleUserMessage 中添加 Vivado 工具处理
|
||
export async function handleVivadoTool(
|
||
panel: vscode.WebviewPanel,
|
||
toolCall: any
|
||
): Promise<void> {
|
||
const { command, topModule, files, constraints } = toolCall.parameters;
|
||
|
||
// 构建请求
|
||
const request: VivadoToolRequest = {
|
||
command,
|
||
parameters: {
|
||
topModule,
|
||
files,
|
||
constraints
|
||
},
|
||
importOutput: {
|
||
enabled: true,
|
||
targetDir: path.join(vscode.workspace.workspaceFolders![0].uri.fsPath, 'vivado_output')
|
||
}
|
||
};
|
||
|
||
// 向前端发送开始消息
|
||
panel.webview.postMessage({
|
||
type: 'vivado-start',
|
||
command
|
||
});
|
||
|
||
// 执行 Vivado
|
||
const response = await runVivado(request, (progress) => {
|
||
// 推送进度
|
||
panel.webview.postMessage({
|
||
type: 'vivado-progress',
|
||
progress
|
||
});
|
||
});
|
||
|
||
// 向前端发送结果
|
||
panel.webview.postMessage({
|
||
type: 'vivado-complete',
|
||
response
|
||
});
|
||
}
|
||
```
|
||
|
||
## 4. 前端 UI 实现
|
||
|
||
### 4.1 进度显示组件
|
||
|
||
```typescript
|
||
// src/views/vivadoProgress.ts
|
||
|
||
export function renderVivadoProgress(progress: VivadoProgress): string {
|
||
return `
|
||
<div class="vivado-progress">
|
||
<div class="progress-header">
|
||
<span class="stage">${progress.stage}</span>
|
||
<span class="percentage">${progress.percentage}%</span>
|
||
</div>
|
||
<div class="progress-bar">
|
||
<div class="progress-fill" style="width: ${progress.percentage}%"></div>
|
||
</div>
|
||
<div class="progress-message">${progress.message}</div>
|
||
</div>
|
||
`;
|
||
}
|
||
```
|
||
|
||
### 4.2 结果展示组件
|
||
|
||
```typescript
|
||
// src/views/vivadoResult.ts
|
||
|
||
export function renderVivadoResult(response: VivadoToolResponse): string {
|
||
if (!response.success) {
|
||
return `
|
||
<div class="vivado-result error">
|
||
<h4>❌ 执行失败</h4>
|
||
<pre>${response.error}</pre>
|
||
</div>
|
||
`;
|
||
}
|
||
|
||
return `
|
||
<div class="vivado-result success">
|
||
<h4>✅ 执行成功</h4>
|
||
<div class="result-info">
|
||
<p>命令: ${response.command}</p>
|
||
<p>执行时间: ${(response.executionTime / 1000).toFixed(2)}s</p>
|
||
</div>
|
||
|
||
${response.reports?.resources ? `
|
||
<div class="report-section">
|
||
<h5>资源使用</h5>
|
||
<pre>${response.reports.resources}</pre>
|
||
</div>
|
||
` : ''}
|
||
|
||
${response.reports?.timing ? `
|
||
<div class="report-section">
|
||
<h5>时序信息</h5>
|
||
<pre>${response.reports.timing}</pre>
|
||
</div>
|
||
` : ''}
|
||
|
||
${response.importedFiles && response.importedFiles.length > 0 ? `
|
||
<div class="imported-files">
|
||
<h5>已导入文件</h5>
|
||
<ul>
|
||
${response.importedFiles.map(f => `<li>${f}</li>`).join('')}
|
||
</ul>
|
||
</div>
|
||
` : ''}
|
||
</div>
|
||
`;
|
||
}
|
||
```
|
||
|
||
## 5. 配置界面实现
|
||
|
||
### 5.1 设置页面扩展
|
||
|
||
```typescript
|
||
// src/views/vivadoSettings.ts
|
||
|
||
export function renderVivadoSettings(config: VivadoConfig | null): string {
|
||
return `
|
||
<div class="vivado-settings">
|
||
<h3>Vivado 配置</h3>
|
||
|
||
<div class="setting-item">
|
||
<label>启用 Vivado</label>
|
||
<input type="checkbox" id="vivado-enabled" ${config?.enabled ? 'checked' : ''}>
|
||
</div>
|
||
|
||
<div class="setting-item">
|
||
<label>可执行文件路径</label>
|
||
<input type="text" id="vivado-path" value="${config?.executablePath || ''}"
|
||
placeholder="C:/Xilinx/Vivado/2023.1/bin/vivado.bat">
|
||
<button onclick="testVivado()">测试</button>
|
||
</div>
|
||
|
||
<div class="setting-item">
|
||
<label>工作目录</label>
|
||
<input type="text" id="vivado-workdir" value="${config?.workingDir || ''}"
|
||
placeholder="\${workspaceFolder}/vivado_project">
|
||
</div>
|
||
|
||
<div class="setting-item">
|
||
<label>FPGA 型号</label>
|
||
<input type="text" id="vivado-part" value="${config?.part || ''}"
|
||
placeholder="xc7a35tcpg236-1">
|
||
</div>
|
||
|
||
<button onclick="saveVivadoConfig()">保存配置</button>
|
||
</div>
|
||
`;
|
||
}
|
||
```
|
||
|
||
## 6. 测试方案
|
||
|
||
### 6.1 单元测试
|
||
|
||
```typescript
|
||
// src/test/vivadoRunner.test.ts
|
||
|
||
import * as assert from 'assert';
|
||
import { generateSynthesisTcl } from '../utils/tclGenerator';
|
||
|
||
suite('Vivado TCL Generator', () => {
|
||
test('生成综合脚本', () => {
|
||
const tcl = generateSynthesisTcl(
|
||
'counter',
|
||
['counter.v'],
|
||
'xc7a35tcpg236-1'
|
||
);
|
||
|
||
assert.ok(tcl.includes('read_verilog counter.v'));
|
||
assert.ok(tcl.includes('synth_design'));
|
||
assert.ok(tcl.includes('write_checkpoint'));
|
||
});
|
||
});
|
||
```
|
||
|
||
### 6.2 集成测试
|
||
|
||
```typescript
|
||
// src/test/vivadoIntegration.test.ts
|
||
|
||
suite('Vivado Integration', () => {
|
||
test('完整综合流程', async () => {
|
||
const request: VivadoToolRequest = {
|
||
command: 'synthesis',
|
||
parameters: {
|
||
topModule: 'counter',
|
||
files: ['test/fixtures/counter.v']
|
||
}
|
||
};
|
||
|
||
const response = await runVivado(request);
|
||
assert.ok(response.success);
|
||
assert.ok(response.executionTime > 0);
|
||
});
|
||
});
|
||
```
|
||
|
||
## 7. 部署和发布
|
||
|
||
### 7.1 文件清单
|
||
|
||
新增文件：
|
||
- `src/utils/vivadoConfig.ts` - 配置管理
|
||
- `src/utils/tclGenerator.ts` - TCL 脚本生成
|
||
- `src/utils/vivadoRunner.ts` - Vivado 执行器
|
||
- `src/utils/fileImporter.ts` - 文件导入
|
||
- `src/views/vivadoProgress.ts` - 进度显示
|
||
- `src/views/vivadoResult.ts` - 结果展示
|
||
- `src/views/vivadoSettings.ts` - 设置界面
|
||
|
||
修改文件：
|
||
- `src/utils/messageHandler.ts` - 添加 Vivado 工具处理
|
||
- `src/views/settingsComponent.ts` - 添加 Vivado 设置页面
|
||
|
||
### 7.2 配置文件更新
|
||
|
||
```json
|
||
// package.json (新增配置项)
|
||
{
|
||
"contributes": {
|
||
"configuration": {
|
||
"properties": {
|
||
"ic-coder.vivado.enabled": {
|
||
"type": "boolean",
|
||
"default": false,
|
||
"description": "启用 Vivado 集成"
|
||
},
|
||
"ic-coder.vivado.executablePath": {
|
||
"type": "string",
|
||
"default": "",
|
||
"description": "Vivado 可执行文件路径"
|
||
},
|
||
"ic-coder.vivado.workingDir": {
|
||
"type": "string",
|
||
"default": "${workspaceFolder}/vivado_project",
|
||
"description": "Vivado 工作目录"
|
||
},
|
||
"ic-coder.vivado.part": {
|
||
"type": "string",
|
||
"default": "xc7a35tcpg236-1",
|
||
"description": "默认 FPGA 型号"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
## 8. 常见问题和解决方案
|
||
|
||
### 8.1 Vivado 许可证问题
|
||
|
||
**问题**：执行时提示许可证错误
|
||
|
||
**解决方案**：
|
||
1. 检查环境变量 `XILINX_VIVADO` 是否设置
|
||
2. 确认许可证服务器可访问
|
||
3. 在配置中添加许可证路径
|
||
|
||
### 8.2 路径问题
|
||
|
||
**问题**：Windows 路径包含空格导致执行失败
|
||
|
||
**解决方案**：
|
||
```typescript
|
||
function escapeWindowsPath(p: string): string {
|
||
return p.includes(' ') ? `"${p}"` : p;
|
||
}
|
||
```
|
||
|
||
### 8.3 执行超时
|
||
|
||
**问题**：大型项目综合时间过长
|
||
|
||
**解决方案**：
|
||
- 增加超时时间配置
|
||
- 添加取消执行功能
|
||
- 显示详细进度信息
|
||
|
||
## 9. 性能优化
|
||
|
||
### 9.1 日志缓冲
|
||
|
||
限制日志输出大小，避免内存溢出：
|
||
|
||
```typescript
|
||
const MAX_LOG_SIZE = 1024 * 1024; // 1MB
|
||
let logBuffer = '';
|
||
|
||
process.stdout.on('data', (data) => {
|
||
logBuffer += data.toString();
|
||
if (logBuffer.length > MAX_LOG_SIZE) {
|
||
logBuffer = logBuffer.slice(-MAX_LOG_SIZE / 2);
|
||
}
|
||
});
|
||
```
|
||
|
||
### 9.2 增量构建
|
||
|
||
支持增量综合，只重新综合修改的模块。
|
||
|
||
## 10. 后续优化方向
|
||
|
||
1. **并行执行**：支持多个设计同时综合
|
||
2. **缓存机制**：缓存未修改模块的综合结果
|
||
3. **云端集成**：支持云端 Vivado 服务
|
||
4. **可视化报告**：图形化展示资源使用和时序
|
||
5. **自动约束生成**：根据设计自动生成 XDC 约束文件
|
||
|