首页
/ PyVISA实战指南：从设备通信到自动化测试的创新解决方案

PyVISA实战指南：从设备通信到自动化测试的创新解决方案

2026-03-11 02:45:23作者：毕习沙Eudora
pyvisa
A Python package with bindings to the "Virtual Instrument Software Architecture" VISA library, in order to control measurement devices and test equipment via GPIB, RS232, or USB.
项目地址：https://gitcode.com/gh_mirrors/py/pyvisa

在现代测试测量系统中，工程师常常面临多设备协同、复杂协议转换和跨平台兼容性等挑战。PyVISA作为虚拟仪器软件架构(VISA)的Python实现，通过统一接口抽象解决了这些痛点，使GPIB、USB、Ethernet等不同接口的仪器控制变得简单高效。本文将通过三个真实场景，深入剖析PyVISA的核心功能与创新应用，帮助你构建稳定、高效的仪器自动化系统。

场景一：半导体测试设备的多协议协同控制

问题：异构设备通信的复杂性

某半导体测试实验室需要同时控制GPIB接口的频谱分析仪、USB接口的电源和Ethernet接口的数据采集器。传统解决方案需要为每种接口编写单独的驱动程序，导致代码冗余且维护困难。

方案：基于VisaLibraryBase的统一通信架构

PyVISA的核心架构围绕VisaLibraryBase抽象类构建，该类定义了所有VISA后端必须实现的接口方法。通过这一设计，无论底层硬件接口如何变化，上层应用代码都可以保持一致。

# 核心架构示意图（文字描述）
# VisaLibraryBase（抽象基类）
#       ↓        ↓        ↓
#  NI-VISA   PyVISA-Py   Keysight-VISA
# （原生驱动）（纯Python）（厂商驱动）

以下是实现多设备协同控制的代码示例：

import pyvisa
from pyvisa import VisaIOError
import logging

# 配置日志系统，记录通信细节
pyvisa.logger.setLevel(logging.DEBUG)

def initialize_instruments():
    """初始化所有测试设备，返回设备字典"""
    instruments = {}
    
    try:
        # 创建资源管理器实例
        rm = pyvisa.ResourceManager()
        
        # 连接GPIB频谱分析仪
        spectrum_analyzer = rm.open_resource(
            "GPIB0::18::INSTR",
            timeout=5000,  # 5秒超时
            read_termination='\n',
            write_termination='\n'
        )
        # 验证设备连接
        idn = spectrum_analyzer.query("*IDN?")
        logging.info(f"已连接频谱分析仪: {idn}")
        instruments['spectrum'] = spectrum_analyzer
        
        # 连接USB电源
        power_supply = rm.open_resource(
            "USB0::0x1AB1::0x0E11::DP8A1234567890::INSTR",
            timeout=3000
        )
        idn = power_supply.query("*IDN?")
        logging.info(f"已连接电源: {idn}")
        instruments['power'] = power_supply
        
        # 连接Ethernet数据采集器
        data_logger = rm.open_resource(
            "TCPIP0::192.168.1.100::5025::SOCKET",
            timeout=2000,
            read_termination='\r\n'
        )
        idn = data_logger.query("*IDN?")
        logging.info(f"已连接数据采集器: {idn}")
        instruments['logger'] = data_logger
        
        return instruments
        
    except VisaIOError as e:
        logging.error(f"设备连接失败: {e}")
        # 确保已打开的设备被正确关闭
        for inst in instruments.values():
            try:
                inst.close()
            except:
                pass
        raise

# 使用上下文管理器确保资源正确释放
with initialize_instruments() as instruments:
    # 设置电源输出
    instruments['power'].write("OUTPUT ON")
    instruments['power'].write("VOLT 3.3")
    
    # 配置频谱分析仪
    instruments['spectrum'].write("FREQ:CENT 1GHz")
    instruments['spectrum'].write("SPAN 100MHz")
    
    # 读取并记录数据
    for _ in range(10):
        power = instruments['power'].query("MEAS:VOLT?")
        spectrum_data = instruments['spectrum'].query("TRACE:DATA?")
        instruments['logger'].write(f"DATA {power},{spectrum_data}")

验证检查清单

  • [ ] 所有设备返回正确的*IDN?响应
  • [ ] 电源能够稳定输出3.3V电压
  • [ ] 频谱分析仪正确设置中心频率和跨度
  • [ ] 数据采集器成功记录10组测量数据
  • [ ] 程序异常退出时资源能够自动释放

思考点

为什么PyVISA能够实现不同接口设备的统一控制？这是因为VISA标准定义了一套与硬件无关的抽象层，而VisaLibraryBase类则在Python中实现了这一抽象。当你调用open_resource方法时，PyVISA会根据资源字符串自动选择合适的后端驱动，从而屏蔽了底层硬件的差异。

场景二：自动化测试系统的事件驱动架构

问题：实时响应与资源竞争

在自动化测试过程中，设备可能会异步产生事件（如测量完成、错误发生等），传统轮询方式效率低下且难以处理并发事件。同时，多线程访问同一设备时容易出现资源竞争问题。

方案：基于事件处理机制的并发控制

PyVISA提供了完善的事件处理系统，支持安装事件处理器和异步等待事件。结合Python的上下文管理器和锁机制，可以构建高效的并发测试系统。

import pyvisa
import threading
import queue
from pyvisa import constants, VisaIOError

class TestSystem:
    def __init__(self):
        self.rm = pyvisa.ResourceManager()
        self.instruments = {}
        self.event_queue = queue.Queue()
        self.lock = threading.Lock()
        
    def connect_instrument(self, resource_name, name):
        """连接仪器并安装事件处理器"""
        try:
            inst = self.rm.open_resource(resource_name)
            inst.timeout = 2000
            
            # 安装事件处理器
            inst.install_handler(
                constants.EventType.service_request,
                self._srq_handler,
                name  # 用户数据，用于标识事件来源
            )
            
            # 启用服务请求事件
            inst.enable_event(
                constants.EventType.service_request,
                constants.EventMechanism.queue
            )
            
            self.instruments[name] = inst
            print(f"已连接仪器: {name}")
            return inst
            
        except VisaIOError as e:
            print(f"连接{name}失败: {e}")
            return None
    
    def _srq_handler(self, session, event_type, event_context, user_handle):
        """服务请求事件处理器"""
        with self.lock:
            self.event_queue.put((user_handle, event_type))
        print(f"收到来自{user_handle}的事件")
    
    def event_listener(self):
        """事件监听线程"""
        while True:
            try:
                # 超时设置为1秒，允许线程定期检查退出标志
                name, event_type = self.event_queue.get(timeout=1)
                if name == "exit":
                    break
                    
                # 处理事件
                with self.lock:
                    inst = self.instruments[name]
                    # 读取状态字节寄存器
                    stb = inst.read_stb()
                    print(f"{name}事件: STB=0x{stb:02X}")
                    
                    # 根据设备类型处理特定事件
                    if name == "scope" and (stb & 0x01):
                        # 示波器触发完成，读取数据
                        data = inst.query("CURVE?")
                        print(f"接收到示波器数据: {len(data)} bytes")
                        
                    elif name == "dmm" and (stb & 0x02):
                        # 万用表测量完成
                        value = inst.query("MEAS:VOLT?")
                        print(f"万用表读数: {value}V")
                        
                self.event_queue.task_done()
                
            except queue.Empty:
                continue
    
    def start(self):
        """启动测试系统"""
        # 连接设备
        self.connect_instrument("USB0::0x1AB1::0x0588::DS1ZA204500001::INSTR", "scope")
        self.connect_instrument("GPIB0::22::INSTR", "dmm")
        
        # 启动事件监听线程
        self.listener_thread = threading.Thread(target=self.event_listener, daemon=True)
        self.listener_thread.start()
        
    def stop(self):
        """停止测试系统"""
        # 向事件队列发送退出信号
        self.event_queue.put(("exit", None))
        self.listener_thread.join()
        
        # 关闭所有设备
        for inst in self.instruments.values():
            inst.close()
        self.rm.close()

# 使用示例
if __name__ == "__main__":
    test_system = TestSystem()
    test_system.start()
    
    try:
        # 配置示波器
        scope = test_system.instruments["scope"]
        scope.write("ACQ:TYPE NORM")
        scope.write("TRIG:EDGE CH1")
        scope.write("TRIG:LEVEL 1.0")
        scope.write("ACQ:START")
        
        # 配置万用表
        dmm = test_system.instruments["dmm"]
        dmm.write("MEAS:VOLT:DC AUTO")
        
        # 等待用户输入结束
        input("按Enter键停止测试...\n")
        
    finally:
        test_system.stop()

验证检查清单

  • [ ] 示波器触发时能产生服务请求事件
  • [ ] 万用表完成测量后能产生服务请求事件
  • [ ] 事件处理器能正确识别事件来源设备
  • [ ] 多设备事件能正确排队处理，无资源竞争
  • [ ] 系统停止时能正确释放所有资源

思考点

事件驱动架构相比传统轮询方式有哪些优势？在高并发测试场景下，事件驱动可以显著提高系统响应速度和资源利用率，因为设备只有在需要关注时才会通知系统，而不是系统不断查询设备状态。PyVISA的事件机制通过install_handler和enable_event方法实现了这一功能，使复杂的多设备协同测试成为可能。

场景三：远程实验室的分布式测量系统

问题：跨网络设备管理与数据安全

随着远程实验和分布式测试的需求增加，如何安全可靠地通过网络控制仪器并传输测量数据成为新的挑战。传统直接连接方式存在延迟高、安全性差和资源利用率低等问题。

方案：基于PyVISA的客户端-服务器架构

通过将PyVISA与网络通信框架结合，可以构建安全高效的分布式测量系统。以下示例使用ZeroMQ实现跨网络的仪器控制，并采用数据加密确保传输安全。

# 服务器端代码 (运行在实验室本地)
import pyvisa
import zmq
import json
import threading
from cryptography.fernet import Fernet
import logging
from typing import Dict, Any

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("visa-server")

class VisaServer:
    def __init__(self, port: int = 5555, key: bytes = None):
        """初始化VISA服务器"""
        self.rm = pyvisa.ResourceManager()
        self.instruments: Dict[str, pyvisa.Resource] = {}
        self.lock = threading.Lock()
        
        # 加密设置
        self.encrypt = key is not None
        if self.encrypt:
            self.cipher = Fernet(key)
            logger.info("已启用数据加密")
        
        # 设置ZMQ服务器
        self.context = zmq.Context()
        self.socket = self.context.socket(zmq.REP)
        self.socket.bind(f"tcp://*:{port}")
        logger.info(f"VISA服务器已启动，监听端口 {port}")
        
        self.running = False
        self.thread = None
    
    def _handle_request(self, request: Dict[str, Any]) -> Dict[str, Any]:
        """处理客户端请求"""
        try:
            action = request.get("action")
            
            if action == "list_resources":
                resources = self.rm.list_resources()
                return {"status": "success", "data": resources}
                
            elif action == "open_resource":
                resource_name = request["resource_name"]
                alias = request.get("alias", resource_name)
                
                with self.lock:
                    if alias in self.instruments:
                        return {"status": "error", "message": f"设备别名'{alias}'已存在"}
                        
                    inst = self.rm.open_resource(resource_name, **request.get("kwargs", {}))
                    self.instruments[alias] = inst
                    
                return {"status": "success", "message": f"已打开设备: {alias}"}
                
            elif action == "close_resource":
                alias = request["alias"]
                
                with self.lock:
                    if alias not in self.instruments:
                        return {"status": "error", "message": f"设备别名'{alias}'不存在"}
                        
                    self.instruments[alias].close()
                    del self.instruments[alias]
                    
                return {"status": "success", "message": f"已关闭设备: {alias}"}
                
            elif action == "send_command":
                alias = request["alias"]
                command = request["command"]
                
                with self.lock:
                    if alias not in self.instruments:
                        return {"status": "error", "message": f"设备别名'{alias}'不存在"}
                        
                    inst = self.instruments[alias]
                    response = inst.write(command)
                    
                return {"status": "success", "data": response}
                
            elif action == "query_command":
                alias = request["alias"]
                command = request["command"]
                
                with self.lock:
                    if alias not in self.instruments:
                        return {"status": "error", "message": f"设备别名'{alias}'不存在"}
                        
                    inst = self.instruments[alias]
                    response = inst.query(command)
                    
                return {"status": "success", "data": response}
                
            else:
                return {"status": "error", "message": f"未知操作: {action}"}
                
        except Exception as e:
            logger.error(f"处理请求时出错: {str(e)}")
            return {"status": "error", "message": str(e)}
    
    def run(self):
        """运行服务器主循环"""
        self.running = True
        while self.running:
            try:
                # 接收请求
                message = self.socket.recv()
                
                # 解密（如果启用）
                if self.encrypt:
                    message = self.cipher.decrypt(message)
                    
                # 解析JSON请求
                request = json.loads(message.decode())
                logger.info(f"收到请求: {request}")
                
                # 处理请求
                response = self._handle_request(request)
                
                # 序列化响应
                response_data = json.dumps(response).encode()
                
                # 加密（如果启用）
                if self.encrypt:
                    response_data = self.cipher.encrypt(response_data)
                    
                # 发送响应
                self.socket.send(response_data)
                
            except zmq.ZMQError as e:
                if self.running:
                    logger.error(f"ZMQ错误: {str(e)}")
                else:
                    logger.info("服务器正在关闭")
                    
            except Exception as e:
                logger.error(f"服务器错误: {str(e)}")
                error_response = json.dumps({"status": "error", "message": str(e)}).encode()
                self.socket.send(error_response)
    
    def start(self):
        """在单独线程中启动服务器"""
        self.thread = threading.Thread(target=self.run, daemon=True)
        self.thread.start()
    
    def stop(self):
        """停止服务器"""
        self.running = False
        if self.thread:
            self.thread.join()
            
        # 关闭所有打开的设备
        with self.lock:
            for alias, inst in self.instruments.items():
                try:
                    inst.close()
                    logger.info(f"已关闭设备: {alias}")
                except Exception as e:
                    logger.error(f"关闭设备{alias}时出错: {str(e)}")
                    
        self.rm.close()
        self.socket.close()
        self.context.term()
        logger.info("VISA服务器已停止")

# 客户端代码 (运行在远程)
class VisaClient:
    def __init__(self, host: str = "localhost", port: int = 5555, key: bytes = None):
        """初始化VISA客户端"""
        self.context = zmq.Context()
        self.socket = self.context.socket(zmq.REQ)
        self.socket.connect(f"tcp://{host}:{port}")
        
        # 加密设置
        self.encrypt = key is not None
        if self.encrypt:
            self.cipher = Fernet(key)
        
    def _send_request(self, request: Dict[str, Any]) -> Dict[str, Any]:
        """发送请求到服务器并返回响应"""
        # 序列化请求
        request_data = json.dumps(request).encode()
        
        # 加密（如果启用）
        if self.encrypt:
            request_data = self.cipher.encrypt(request_data)
            
        # 发送请求
        self.socket.send(request_data)
        
        # 接收响应
        response_data = self.socket.recv()
        
        # 解密（如果启用）
        if self.encrypt:
            response_data = self.cipher.decrypt(response_data)
            
        # 解析响应
        return json.loads(response_data.decode())
    
    def list_resources(self) -> list:
        """列出所有可用资源"""
        response = self._send_request({"action": "list_resources"})
        if response["status"] == "success":
            return response["data"]
        else:
            raise Exception(f"获取资源列表失败: {response['message']}")
    
    def open_resource(self, resource_name: str, alias: str = None, **kwargs) -> None:
        """打开指定资源"""
        request = {
            "action": "open_resource",
            "resource_name": resource_name,
            "kwargs": kwargs
        }
        if alias:
            request["alias"] = alias
            
        response = self._send_request(request)
        if response["status"] != "success":
            raise Exception(f"打开资源失败: {response['message']}")
    
    def close_resource(self, alias: str) -> None:
        """关闭指定资源"""
        response = self._send_request({
            "action": "close_resource",
            "alias": alias
        })
        if response["status"] != "success":
            raise Exception(f"关闭资源失败: {response['message']}")
    
    def write(self, alias: str, command: str) -> Any:
        """向设备发送命令"""
        response = self._send_request({
            "action": "send_command",
            "alias": alias,
            "command": command
        })
        if response["status"] == "success":
            return response["data"]
        else:
            raise Exception(f"发送命令失败: {response['message']}")
    
    def query(self, alias: str, command: str) -> str:
        """向设备发送查询命令并返回结果"""
        response = self._send_request({
            "action": "query_command",
            "alias": alias,
            "command": command
        })
        if response["status"] == "success":
            return response["data"]
        else:
            raise Exception(f"查询命令失败: {response['message']}")
    
    def close(self):
        """关闭客户端连接"""
        self.socket.close()
        self.context.term()

# 使用示例
if __name__ == "__main__":
    # 生成加密密钥（实际应用中应安全分发）
    # key = Fernet.generate_key()
    # print("加密密钥:", key.decode())
    
    # 服务器端
    # server = VisaServer(port=5555, key=key)
    # server.start()
    # input("按Enter键停止服务器...\n")
    # server.stop()
    
    # 客户端
    # client = VisaClient(host="192.168.1.10", port=5555, key=key)
    # print("可用资源:", client.list_resources())
    # client.open_resource("GPIB0::18::INSTR", alias="spectrum")
    # print("设备ID:", client.query("spectrum", "*IDN?"))
    # client.close_resource("spectrum")
    # client.close()

验证检查清单

  • [ ] 服务器能正确列出所有连接的仪器
  • [ ] 客户端能通过网络远程打开和关闭设备
  • [ ] 命令发送和查询功能正常工作
  • [ ] 加密传输时数据不被泄露
  • [ ] 多客户端同时连接时无冲突

思考点

在分布式测量系统中，除了基本的命令传输，还需要考虑哪些因素？网络延迟、数据压缩、错误恢复和权限控制都是实际应用中需要解决的问题。PyVISA提供的超时设置、事件处理和资源管理功能为此类系统提供了坚实基础，而结合ZeroMQ等网络库则可以构建更强大的分布式测试平台。

高级技巧与性能优化

1. 资源池化管理

在高并发测试场景中，频繁打开和关闭设备连接会显著影响性能。实现资源池化可以有效解决这一问题：

class InstrumentPool:
    def __init__(self, resource_name, max_connections=5):
        self.resource_name = resource_name
        self.max_connections = max_connections
        self.pool = queue.Queue(max_connections)
        self.rm = pyvisa.ResourceManager()
        
        # 预创建连接
        for _ in range(max_connections):
            inst = self.rm.open_resource(resource_name)
            self.pool.put(inst)
    
    def acquire(self, timeout=None):
        """获取一个设备连接"""
        return self.pool.get(timeout=timeout)
    
    def release(self, inst):
        """释放设备连接回池"""
        if not self.pool.full():
            self.pool.put(inst)
    
    def close_all(self):
        """关闭所有连接"""
        while not self.pool.empty():
            inst = self.pool.get()
            inst.close()
        self.rm.close()

2. 二进制数据传输优化

对于大量数据采集（如示波器波形），使用二进制格式传输比ASCII格式效率高10-100倍：

# 高效读取示波器波形数据
def read_waveform(scope):
    # 设置二进制传输格式
    scope.write("DATA:FORMAT BINARY")
    scope.write("DATA:WIDTH 2")  # 2字节/点
    scope.write("DATA:ENCDG RPB")  # 有符号整数
    
    # 获取波形数据
    raw_data = scope.query_binary_values(
        "CURVE?", 
        datatype='h',  # 16位有符号整数
        is_big_endian=False,
        container=np.array  # 使用NumPy数组提高处理效率
    )
    
    # 获取波形参数用于数据转换
    x_increment = float(scope.query("WFMPRE:XINCR?"))
    x_origin = float(scope.query("WFMPRE:XORIG?"))
    
    # 计算时间轴
    time = x_origin + np.arange(len(raw_data)) * x_increment
    
    return time, raw_data

3. 多线程安全的设备访问

使用上下文管理器和锁机制确保多线程安全访问设备：

from contextlib import contextmanager

class ThreadSafeInstrument:
    def __init__(self, resource_name):
        self.rm = pyvisa.ResourceManager()
        self.inst = self.rm.open_resource(resource_name)
        self.lock = threading.Lock()
    
    @contextmanager
    def access(self):
        """线程安全的设备访问上下文管理器"""
        with self.lock:
            yield self.inst
    
    def close(self):
        self.inst.close()
        self.rm.close()

# 使用示例
instrument = ThreadSafeInstrument("GPIB0::18::INSTR")

def measurement_task():
    with instrument.access() as inst:
        return inst.query("MEAS:VOLT?")

# 多线程执行测量
threads = [threading.Thread(target=measurement_task) for _ in range(5)]
for t in threads:
    t.start()
for t in threads:
    t.join()

实战挑战

尝试构建一个完整的自动化测试系统，要求：

  1. 同时控制至少两种不同接口的仪器（如USB电源和GPIB万用表）
  2. 实现事件驱动的数据采集，当测量值超过阈值时触发报警
  3. 将测量数据实时存储到CSV文件，并计算基本统计信息（平均值、标准差）
  4. 添加命令行界面，支持查询设备状态和历史数据

提示：结合本文介绍的资源管理、事件处理和错误处理技术，设计一个模块化的系统架构。

附录：常见问题速查表

问题 解决方案
"Could not open VISA library" 错误 安装NI-VISA或使用pip install pyvisa-py安装纯Python后端
设备连接超时 检查设备电源和连接，增加超时参数，验证资源字符串格式
数据读取不完整 确认终止符设置正确，检查设备输出缓冲区大小
多线程访问冲突 使用锁机制或资源池化管理设备连接
网络延迟导致通信失败 实现请求重试机制，增加超时时间，优化数据传输格式

推荐资源

  1. PyVISA官方文档：docs/index.rst
  2. 虚拟仪器软件架构(VISA)规范：可从IVI Foundation网站获取
  3. PyVISA测试套件：pyvisa/testsuite/
  4. 仪器控制最佳实践：docs/source/introduction/
  5. 设备命令参考：各仪器厂商提供的编程手册
pyvisa
A Python package with bindings to the "Virtual Instrument Software Architecture" VISA library, in order to control measurement devices and test equipment via GPIB, RS232, or USB.
项目地址：https://gitcode.com/gh_mirrors/py/pyvisa
登录后查看全文

相关内容推荐

1 破除仪器控制壁垒：PyVISA构建统一自动化测量系统2 PyVISA：跨平台仪器控制的Python解决方案3 3大维度掌握PyVISA：革新性仪器控制与自动化高效实践指南4 如何用PyVISA实现仪器控制自动化？解锁高效测试测量系统开发5 4个革命性步骤：PyVISA设备控制从入门到精通6 PyVISA实战指南：突破仪器控制的通信壁垒7 Python仪器控制终极指南：如何用PyVISA统一管理各类测量设备8 突破仪器控制壁垒：3种创新方法实现跨平台测量自动化9 如何用Python控制测量设备？PyVISA让仪器通信变得前所未有的简单！10 PyVISA 开源项目指南及常见问题解答
热门项目推荐
相关项目推荐

热门内容推荐

1 【亲测免费】 开源项目 `build-your-own-x` 使用指南2 【亲测免费】 探索科技之旅：《Build Your Own X》项目详解3 GitHub_Trending/bu/build-your-own-x自动化：CI/CD流程在自制项目中的应用4 从零打造智能家居系统：用build-your-own-x实现家庭自动化

最新内容推荐

掌握GS Quant：构建量化金融分析体系的实践指南DPlayer视频播放故障自愈系统：从崩溃到重生的全链路解决方案一人企业方法论：构建可持续副业系统的非技术指南Mobile-Agent高效实战指南：从入门到精通的AI移动自动化解决方案构建高效书籍检索系统：从文件解析到智能搜索的Python实现方案泉盛UV-K5显示系统技术解析：从接口原理到硬件优化实战shadPS4全平台部署指南：从环境搭建到性能调优的完整路径RedisInsight可视化管理工具：从安装到高级应用全指南零门槛搭建AI量化交易系统：Qbot本地化部署与实战指南5大策略提升Web性能指标：前端框架实战优化指南

项目优选

收起
kernelkernel
deepin linux kernel
C
27
13
docsdocs
OpenHarmony documentation | OpenHarmony开发者文档
Dockerfile
619
4.09 K
pytorchpytorch
Ascend Extension for PyTorch
Python
454
540
leetcodeleetcode
🔥LeetCode solutions in any programming language | 多种编程语言实现 LeetCode、《剑指 Offer（第 2 版）》、《程序员面试金典（第 6 版）》题解
Java
69
21
flutter_flutterflutter_flutter
暂无简介
Dart
861
206
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
928
785
RuoYi-Vue3RuoYi-Vue3
🎉 (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统
Vue
1.49 K
842
AscendNPU-IRAscendNPU-IR
AscendNPU-IR是基于MLIR（Multi-Level Intermediate Representation）构建的，面向昇腾亲和算子编译时使用的中间表示，提供昇腾完备表达能力，通过编译优化提升昇腾AI处理器计算效率，支持通过生态框架使能昇腾AI处理器与深度调优
C++
114
178
kernelkernel
openEuler内核是openEuler操作系统的核心，既是系统性能与稳定性的基石，也是连接处理器、设备与服务的桥梁。
C
377
256
MindSpeed-LLMMindSpeed-LLM
昇腾LLM分布式训练框架
Python
134
160