SikongJueluo/FPGA_WebLab
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add: 为逻辑分析仪添加了深度、预存储深度、通道组设置

Browse Source
This commit is contained in:
alivender
2025-07-31 13:14:23 +08:00
parent 3257a68407
commit 6b701658d1
8 changed files with 1012 additions and 718 deletions
Download Patch File Download Diff File Expand all files Collapse all files

455
src/components/LogicAnalyzer/LogicAnalyzerManager.ts
View File

@@ -9,6 +9,7 @@ import {
SignalOperator,
SignalTriggerConfig,
SignalValue,
AnalyzerChannelDiv,
} from "@/APIClient";
import { AuthManager } from "@/utils/AuthManager";
import { useAlertStore } from "@/components/Alert";
@@ -65,6 +66,39 @@ const signalValues = [
{ value: SignalValue.SomeNumber, label: "#" },
];
// 通道组选项
const channelDivOptions = [
{ value: 1, label: "1通道", description: "启用1个通道 (CH0)" },
{ value: 2, label: "2通道", description: "启用2个通道 (CH0-CH1)" },
{ value: 4, label: "4通道", description: "启用4个通道 (CH0-CH3)" },
{ value: 8, label: "8通道", description: "启用8个通道 (CH0-CH7)" },
{ value: 16, label: "16通道", description: "启用16个通道 (CH0-CH15)" },
{ value: 32, label: "32通道", description: "启用32个通道 (CH0-CH31)" },
];
// 捕获深度选项
const captureLengthOptions = [
{ value: 256, label: "256" },
{ value: 512, label: "512" },
{ value: 1024, label: "1K" },
{ value: 2048, label: "2K" },
{ value: 4096, label: "4K" },
{ value: 8192, label: "8K" },
{ value: 16384, label: "16K" },
{ value: 32768, label: "32K" },
];
// 预捕获深度选项
const preCaptureLengthOptions = [
{ value: 0, label: "0" },
{ value: 16, label: "16" },
{ value: 32, label: "32" },
{ value: 64, label: "64" },
{ value: 128, label: "128" },
{ value: 256, label: "256" },
{ value: 512, label: "512" },
];
// 默认颜色数组
const defaultColors = [
"#FF5733",
@@ -78,7 +112,7 @@ const defaultColors = [
];
// 添加逻辑分析仪频率常量
const LOGIC_ANALYZER_FREQUENCY = 5_000_000; // 5MHz
const LOGIC_ANALYZER_FREQUENCY = 125_000_000; // 125MHz
const SAMPLE_PERIOD_NS = 1_000_000_000 / LOGIC_ANALYZER_FREQUENCY; // 采样周期，单位：纳秒
const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
@@ -91,22 +125,25 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
// 触发设置相关状态
const currentGlobalMode = ref<GlobalCaptureMode>(GlobalCaptureMode.AND);
const currentChannelDiv = ref<number>(8); // 默认启用8个通道
const captureLength = ref<number>(1024); // 捕获深度，默认1024
const preCaptureLength = ref<number>(0); // 预捕获深度，默认0
const isApplying = ref(false);
const isCapturing = ref(false); // 添加捕获状态标识
// 通道配置
const channels = reactive<Channel[]>(
Array.from({ length: 8 }, (_, index) => ({
enabled: false,
Array.from({ length: 32 }, (_, index) => ({
enabled: index < 8, // 默认启用前8个通道
label: `CH${index}`,
color: defaultColors[index],
color: defaultColors[index % defaultColors.length], // 使用模运算避免数组越界
})),
);
// 8个信号通道的配置
// 32个信号通道的配置
const signalConfigs = reactive<SignalTriggerConfig[]>(
Array.from(
{ length: 8 },
{ length: 32 },
(_, index) =>
new SignalTriggerConfig({
signalIndex: index,
@@ -131,101 +168,52 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
channels.filter((channel) => channel.enabled),
);
const enableAllChannels = () => {
channels.forEach((channel) => {
channel.enabled = true;
});
// 转换通道数字到枚举值
const getChannelDivEnum = (channelCount: number): AnalyzerChannelDiv => {
switch (channelCount) {
case 1: return AnalyzerChannelDiv.ONE;
case 2: return AnalyzerChannelDiv.TWO;
case 4: return AnalyzerChannelDiv.FOUR;
case 8: return AnalyzerChannelDiv.EIGHT;
case 16: return AnalyzerChannelDiv.XVI;
case 32: return AnalyzerChannelDiv.XXXII;
default: return AnalyzerChannelDiv.EIGHT;
}
};
const disableAllChannels = () => {
// 设置通道组
const setChannelDiv = (channelCount: number) => {
// 验证通道数量是否有效
if (!channelDivOptions.find(option => option.value === channelCount)) {
console.error(`无效的通道组设置: ${channelCount}`);
return;
}
currentChannelDiv.value = channelCount;
// 禁用所有通道
channels.forEach((channel) => {
channel.enabled = false;
});
// 启用指定数量的通道（从CH0开始）
for (let i = 0; i < channelCount && i < channels.length; i++) {
channels[i].enabled = true;
}
const option = channelDivOptions.find(opt => opt.value === channelCount);
alert?.success(`已设置为${option?.label}`, 2000);
};
const setGlobalMode = async (mode: GlobalCaptureMode) => {
// 检查是否有其他操作正在进行
if (operationMutex.isLocked()) {
alert.warn("有其他操作正在进行中，请稍后再试", 3000);
return;
}
const release = await operationMutex.acquire();
try {
const client = AuthManager.createAuthenticatedLogicAnalyzerClient();
const success = await client.setGlobalTrigMode(mode);
if (success) {
currentGlobalMode.value = mode;
alert?.success(
`全局触发模式已设置为 ${globalModes.find((m) => m.value === mode)?.label}`,
3000,
);
} else {
throw new Error("设置失败");
}
} catch (error) {
console.error("设置全局触发模式失败:", error);
alert?.error("设置全局触发模式失败", 3000);
} finally {
release();
}
};
const applyConfiguration = async () => {
// 检查是否有其他操作正在进行
if (operationMutex.isLocked()) {
alert.warn("有其他操作正在进行中，请稍后再试", 3000);
return;
}
const release = await operationMutex.acquire();
isApplying.value = true;
try {
const client = AuthManager.createAuthenticatedLogicAnalyzerClient();
// 准备配置数据 - 只包含启用的通道
const enabledSignals = signalConfigs.filter(
(signal, index) => channels[index].enabled,
);
const config = new CaptureConfig({
globalMode: currentGlobalMode.value,
signalConfigs: enabledSignals,
});
// 发送配置
const success = await client.configureCapture(config);
if (success) {
const enabledChannelCount = channels.filter(
(ch) => ch.enabled,
).length;
alert?.success(
`配置已成功应用，启用了 ${enabledChannelCount} 个通道和触发条件`,
3000,
);
} else {
throw new Error("应用配置失败");
}
} catch (error) {
console.error("应用配置失败:", error);
alert?.error("应用配置失败，请检查设备连接", 3000);
} finally {
isApplying.value = false;
release();
}
const setGlobalMode = (mode: GlobalCaptureMode) => {
currentGlobalMode.value = mode;
const modeOption = globalModes.find((m) => m.value === mode);
alert?.info(`全局触发模式已设置为 ${modeOption?.label}`, 2000);
};
const resetConfiguration = () => {
currentGlobalMode.value = GlobalCaptureMode.AND;
channels.forEach((channel, index) => {
channel.enabled = false;
channel.label = `CH${index}`;
channel.color = defaultColors[index];
});
currentChannelDiv.value = 8; // 重置为默认的8通道
setChannelDiv(8); // 重置为默认的8通道
signalConfigs.forEach((signal) => {
signal.operator = SignalOperator.Equal;
@@ -243,51 +231,223 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
const getCaptureData = async () => {
try {
const client = AuthManager.createAuthenticatedLogicAnalyzerClient();
// 3. 获取捕获数据
const base64Data = await client.getCaptureData();
// 获取捕获数据，使用当前设置的捕获长度
const base64Data = await client.getCaptureData(captureLength.value);
// 4. 将base64数据转换为bytes
// 将base64数据转换为bytes
const binaryString = atob(base64Data);
const bytes = new Uint8Array(binaryString.length);
for (let i = 0; i < binaryString.length; i++) {
bytes[i] = binaryString.charCodeAt(i);
}
// 5. 解析数据为8个通道的数字信号
const sampleCount = bytes.length;
const timeStepNs = SAMPLE_PERIOD_NS; // 每个采样点间隔200ns (1/5MHz)
// 根据当前通道数量解析数据
const channelCount = currentChannelDiv.value;
const timeStepNs = SAMPLE_PERIOD_NS;
let sampleCount: number;
let x: number[];
let y: number[][];
// 创建时间轴（转换为合适的单位）
const x = Array.from(
{ length: sampleCount },
(_, i) => (i * timeStepNs) / 1000,
); // 转换为微秒
// 创建8个通道的数据
const y: number[][] = Array.from(
{ length: 8 },
() => new Array(sampleCount),
);
// 解析每个字节的8个位到对应通道
for (let i = 0; i < sampleCount; i++) {
const byte = bytes[i];
for (let channel = 0; channel < 8; channel++) {
// bit0对应ch0, bit1对应ch1, ..., bit7对应ch7
y[channel][i] = (byte >> channel) & 1;
if (channelCount === 1) {
// 1通道：每个字节包含8个时间单位的数据
sampleCount = bytes.length * 8;
// 创建时间轴
x = Array.from(
{ length: sampleCount },
(_, i) => (i * timeStepNs) / 1000,
); // 转换为微秒
// 创建通道数据数组
y = Array.from(
{ length: 1 },
() => new Array(sampleCount),
);
// 解析数据：每个字节的8个位对应8个时间单位
for (let byteIndex = 0; byteIndex < bytes.length; byteIndex++) {
const byte = bytes[byteIndex];
for (let bitIndex = 0; bitIndex < 8; bitIndex++) {
const timeIndex = byteIndex * 8 + bitIndex;
y[0][timeIndex] = (byte >> bitIndex) & 1;
}
}
} else if (channelCount === 2) {
// 2通道：每个字节包含4个时间单位的数据
sampleCount = bytes.length * 4;
// 创建时间轴
x = Array.from(
{ length: sampleCount },
(_, i) => (i * timeStepNs) / 1000,
); // 转换为微秒
// 创建通道数据数组
y = Array.from(
{ length: 2 },
() => new Array(sampleCount),
);
// 解析数据：每个字节的8个位对应4个时间单位的2通道数据
// 位分布：[T3_CH1, T3_CH0, T2_CH1, T2_CH0, T1_CH1, T1_CH0, T0_CH1, T0_CH0]
for (let byteIndex = 0; byteIndex < bytes.length; byteIndex++) {
const byte = bytes[byteIndex];
for (let timeUnit = 0; timeUnit < 4; timeUnit++) {
const timeIndex = byteIndex * 4 + timeUnit;
const bitOffset = timeUnit * 2;
y[0][timeIndex] = (byte >> bitOffset) & 1; // CH0
y[1][timeIndex] = (byte >> (bitOffset + 1)) & 1; // CH1
}
}
} else if (channelCount === 4) {
// 4通道：每个字节包含2个时间单位的数据
sampleCount = bytes.length * 2;
// 创建时间轴
x = Array.from(
{ length: sampleCount },
(_, i) => (i * timeStepNs) / 1000,
); // 转换为微秒
// 创建通道数据数组
y = Array.from(
{ length: 4 },
() => new Array(sampleCount),
);
// 解析数据：每个字节的8个位对应2个时间单位的4通道数据
// 位分布：[T1_CH3, T1_CH2, T1_CH1, T1_CH0, T0_CH3, T0_CH2, T0_CH1, T0_CH0]
for (let byteIndex = 0; byteIndex < bytes.length; byteIndex++) {
const byte = bytes[byteIndex];
// 处理第一个时间单位（低4位）
const timeIndex1 = byteIndex * 2;
for (let channel = 0; channel < 4; channel++) {
y[channel][timeIndex1] = (byte >> channel) & 1;
}
// 处理第二个时间单位（高4位）
const timeIndex2 = byteIndex * 2 + 1;
for (let channel = 0; channel < 4; channel++) {
y[channel][timeIndex2] = (byte >> (channel + 4)) & 1;
}
}
} else if (channelCount === 8) {
// 8通道：每个字节包含1个时间单位的8个通道数据
sampleCount = bytes.length;
// 创建时间轴
x = Array.from(
{ length: sampleCount },
(_, i) => (i * timeStepNs) / 1000,
); // 转换为微秒
// 创建8个通道的数据
y = Array.from(
{ length: 8 },
() => new Array(sampleCount),
);
// 解析每个字节的8个位到对应通道
for (let i = 0; i < sampleCount; i++) {
const byte = bytes[i];
for (let channel = 0; channel < 8; channel++) {
// bit0对应ch0, bit1对应ch1, ..., bit7对应ch7
y[channel][i] = (byte >> channel) & 1;
}
}
} else if (channelCount === 16) {
// 16通道：每2个字节包含1个时间单位的16个通道数据
sampleCount = bytes.length / 2;
// 创建时间轴
x = Array.from(
{ length: sampleCount },
(_, i) => (i * timeStepNs) / 1000,
); // 转换为微秒
// 创建16个通道的数据
y = Array.from(
{ length: 16 },
() => new Array(sampleCount),
);
// 解析数据：每2个字节为一个时间单位
for (let timeIndex = 0; timeIndex < sampleCount; timeIndex++) {
const byteIndex = timeIndex * 2;
const byte1 = bytes[byteIndex]; // [7:0]
const byte2 = bytes[byteIndex + 1]; // [15:8]
// 处理低8位通道 [7:0]
for (let channel = 0; channel < 8; channel++) {
y[channel][timeIndex] = (byte1 >> channel) & 1;
}
// 处理高8位通道 [15:8]
for (let channel = 0; channel < 8; channel++) {
y[channel + 8][timeIndex] = (byte2 >> channel) & 1;
}
}
} else if (channelCount === 32) {
// 32通道：每4个字节包含1个时间单位的32个通道数据
sampleCount = bytes.length / 4;
// 创建时间轴
x = Array.from(
{ length: sampleCount },
(_, i) => (i * timeStepNs) / 1000,
); // 转换为微秒
// 创建32个通道的数据
y = Array.from(
{ length: 32 },
() => new Array(sampleCount),
);
// 解析数据：每4个字节为一个时间单位
for (let timeIndex = 0; timeIndex < sampleCount; timeIndex++) {
const byteIndex = timeIndex * 4;
const byte1 = bytes[byteIndex]; // [7:0]
const byte2 = bytes[byteIndex + 1]; // [15:8]
const byte3 = bytes[byteIndex + 2]; // [23:16]
const byte4 = bytes[byteIndex + 3]; // [31:24]
// 处理 [7:0]
for (let channel = 0; channel < 8; channel++) {
y[channel][timeIndex] = (byte1 >> channel) & 1;
}
// 处理 [15:8]
for (let channel = 0; channel < 8; channel++) {
y[channel + 8][timeIndex] = (byte2 >> channel) & 1;
}
// 处理 [23:16]
for (let channel = 0; channel < 8; channel++) {
y[channel + 16][timeIndex] = (byte3 >> channel) & 1;
}
// 处理 [31:24]
for (let channel = 0; channel < 8; channel++) {
y[channel + 24][timeIndex] = (byte4 >> channel) & 1;
}
}
} else {
throw new Error(`不支持的通道数量: ${channelCount}`);
}
// 6. 设置逻辑数据
// 设置逻辑数据
const logicData: LogicDataType = {
x,
y,
xUnit: "us", // 改为微秒单位
xUnit: "us", // 微秒单位
};
setLogicData(logicData);
} catch (error) {
console.error("获取捕获数据失败:", error);
alert?.error("获取捕获数据失败", 3000);
}
};
@@ -303,7 +463,45 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
try {
const client = AuthManager.createAuthenticatedLogicAnalyzerClient();
// 1. 设置捕获模式为开始捕获
// 1. 先应用配置
alert?.info("正在应用配置...", 2000);
// 准备配置数据 - 包含所有32个通道，未启用的通道设置为默认值
const allSignals = signalConfigs.map((signal, index) => {
if (channels[index].enabled) {
// 启用的通道使用用户配置的触发条件
return signal;
} else {
// 未启用的通道设置为默认触发条件
return new SignalTriggerConfig({
signalIndex: index,
operator: SignalOperator.Equal,
value: SignalValue.NotCare,
});
}
});
const config = new CaptureConfig({
globalMode: currentGlobalMode.value,
channelDiv: getChannelDivEnum(currentChannelDiv.value),
captureLength: captureLength.value,
preCaptureLength: preCaptureLength.value,
signalConfigs: allSignals,
});
// 发送配置
const configSuccess = await client.configureCapture(config);
if (!configSuccess) {
throw new Error("配置应用失败");
}
const enabledChannelCount = channels.filter((ch) => ch.enabled).length;
alert?.success(
`配置已应用，启用了 ${enabledChannelCount} 个通道，捕获深度: ${captureLength.value}`,
2000,
);
// 2. 设置捕获模式为开始捕获
const captureStarted = await client.setCaptureMode(true, false);
if (!captureStarted) {
throw new Error("无法启动捕获");
@@ -311,7 +509,7 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
alert?.info("开始捕获信号...", 2000);
// 2. 轮询捕获状态
// 3. 轮询捕获状态
let captureCompleted = false;
while (isCapturing.value) {
const status = await client.getCaptureStatus();
@@ -390,8 +588,11 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
};
const forceCapture = async () => {
// 设置捕获状态为false，这会使轮询停止
isCapturing.value = false;
// 检查是否有其他操作正在进行
if (operationMutex.isLocked()) {
alert.warn("有其他操作正在进行中，请稍后再试", 3000);
return;
}
const release = await operationMutex.acquire();
try {
@@ -404,7 +605,7 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
}
await getCaptureData();
alert.success(`捕获完成！`, 3000);
alert.success(`强制捕获完成！`, 3000);
} catch (error) {
console.error("强制捕获失败:", error);
alert.error(
@@ -487,7 +688,7 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
});
// 设置逻辑数据
enableAllChannels();
setChannelDiv(8);
setLogicData({ x, y, xUnit: "us" }); // 改为微秒单位
alert?.success("测试数据生成成功", 2000);
@@ -499,6 +700,9 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
// 触发设置状态
currentGlobalMode,
currentChannelDiv, // 导出当前通道组状态
captureLength, // 导出捕获深度
preCaptureLength, // 导出预捕获深度
isApplying,
isCapturing, // 导出捕获状态
isOperationInProgress, // 导出操作进行状态
@@ -512,12 +716,13 @@ const [useProvideLogicAnalyzer, useLogicAnalyzerState] = createInjectionState(
globalModes,
operators,
signalValues,
channelDivOptions, // 导出通道组选项
captureLengthOptions, // 导出捕获深度选项
preCaptureLengthOptions, // 导出预捕获深度选项
// 触发设置方法
enableAllChannels,
disableAllChannels,
setChannelDiv, // 导出设置通道组方法
setGlobalMode,
applyConfiguration,
resetConfiguration,
setLogicData,
startCapture,