通过自定义 FPGA 接口，直接在 LabVIEW 中读取 FPGA XADC 的模拟信号，实现实时数据采集。

序论

本项目演示了如何从 A7 FPGA(Digilent Arty Z7 FPGA 开发板)的 XADC 获取模拟数据，并将其显示在运行于 Windows PC 上的 LabVIEW 中。FPGA 与 LabVIEW 之间的通信通过自定义硬件接口实现，从而能够实时可视化模拟输入信号。

与需要嵌入式软件或 Jupyter notebook 的传统 FPGA 开发不同，本项目专注于 LabVIEW 和 FPGA 之间的直接通信，使其适用于实验室仪器和教育环境。

这项工作探索了 Python + LabVIEW + FPGA 的组合方案，用于构建更加直观的 FPGA 数据采集和控制系统。Python 负责与 FPGA 硬件通信、控制和自动化，LabVIEW 则提供图形化界面，实现数据实时显示、参数配置和仪器控制，从而降低 FPGA 数据采集系统的使用门槛。

项目由费米实验室围绕 DUNE 深地中微子实验相关技术开发展开，使用 Xilinx Zynq-7000 系列 FPGA 研究科学仪器和数据采集系统的软件接口。虽然示例采用 Digilent Arty Z7，并通过单个 XADC 通道完成数据采集，但其设计思路可以进一步扩展到多通道采集、DMA 高速数据传输、数字信号处理以及自定义 FPGA 外设。

整体来看，该项目的重点并不是单纯实现一次 XADC 数据读取，而是探索一种降低 FPGA 数据采集系统使用门槛的软硬件架构：利用 FPGA 提供高速、灵活的数据处理能力，Python 负责硬件控制和自动化，LabVIEW 则提供面向工程师和研究人员的可视化操作界面，为后续构建完整的 FPGA 虚拟仪器和科学数据采集平台提供基础。

项目文件

重现此项目所需的所有文件，包括 Vivado 设计、Python 脚本和 LabVIEW 文件，都可以在项目的 GitHub 存储库中找到。

https://github.com/jolobotero/XADCLabVIEW

VIVADO 中的 XADC 实现

XADC 的实现和配置使用了 Vivado 中提供的 XADC Wizard IP。本项目仅使用了一个模拟输入通道，从而简化硬件架构，同时提供了一个完整的基于 FPGA 的模拟数据采集示例。

XADC 负责对选定的模拟输入通道进行数字化采样，并通过 AXI4-Lite 提供寄存器访问接口。处理器或上位机可以通过内存映射方式读取 XADC 转换后的数字数据。

这种架构不需要复杂的高速数据流通道，适合当前以模拟数据采集、读取和可视化为主的应用。采集到的 XADC 数据可以进一步传递给 LabVIEW，实现实时波形显示、数据监测以及仪器控制，为后续扩展多通道采集和更复杂的数据处理提供基础。

创建 Vivado Block 设计

打开Vivado ，为 Arty Z7 开发板创建一个新项目。项目创建完成后，打开Block Design环境，创建一个新的Block Design。

在“Block Design”窗口中，选择“添加 IP” ，然后搜索“XADC Wizard” 。双击该 IP 将其添加到设计中。

对于本项目，XADC Wizard配置如下。

Basic配置：在Basic配置中，选择AXI4-Lite作为接口，并将 XADC 配置为连续模式。DCLK 频率设置为104 MHz 。

ADC 设置：ADC 设置中，通道平均功能已禁用。采集到的样本不会进行任何额外的平均或滤波处理。其余 ADC 设置选项也保持禁用状态。此配置允许 XADC 连续采集样本而不进行硬件平均，从而使采集到的数据可供主机应用程序处理。

本项目未启用 XADC 报警功能。由于项目目标仅为采集和可视化模拟输入，因此无需报警功能。

Single Channel 配置：该设计采用单个辅助模拟输入。Vaux1 （A0 通道）被选为该通道的正负输入。该通道配置为单极性输入，因此双极性操作被禁用。

连接 XADC 和 Zynq 处理系统

XADC配置完成后，需要在BD中将模拟输入暴露为外部端口。在xadc_wiz_0模块中，右键单击VauxP1和VauxN1输入连接，然后选择“Make External”。Vivado将为选定的XADC输入创建外部端口。建议保留Vivado生成的端口名称。通过保留默认的XADC端口名称，可以利用电路板现有的约束来处理物理引脚分配，因此无需为这些XADC连接创建额外的约束文件。

接下来，从 IP 目录中添加ZYNQ7 处理系统IP。该模块提供集成到 Zynq-7000 器件中的处理系统，并允许通过 AXI4-Lite 接口访问 XADC 外设。

添加 Zynq 处理系统后，运行模块自动化来配置处理器并应用所选电路板的推荐连接。然后运行连接自动化，自动连接 Zynq 处理系统和 XADC IP 之间的 AXI 接口和其他所需信号。

验证模块设计后，生成 HDL 封装器并运行“生成比特流”命令。生成的 .bit 文件包含 FPGA 硬件配置，将在下一阶段用于建立 Arty Z7 和 LabVIEW 应用程序之间的通信。

内存映射寄存器

在进行软件实现之前，必须先确定与FPGA外设关联的内存地址。这些地址稍后将用于从主机应用程序访问XADC寄存器。

在这个项目中，我们只需要访问与 xadc_wiz_0 外设相关的寄存器。地址信息可以在 Vivado 的地址编辑器中的“地址映射”部分找到。

在当前设计中，XADC 外设映射到以下地址范围：

基地址0x43C00000 是分配给 XADC 的内存映射区域的起始点。各个 XADC 寄存器位于该 64 KB 地址空间内的特定偏移量处。

这些地址对于项目的下一阶段尤为重要，因为它们提供了 FPGA 硬件与 PC 上运行的软件之间的连接。

FPGA 编程

Vivado 设计完成后，比特流生成后，下一步是准备 FPGA 配置文件，以便对 Arty Z7 进行编程。然后，根据所使用的编程方法，可以从 Linux 环境或直接从 Windows 命令提示符 (CMD) 对 FPGA 进行编程。

创建 .bin 文件

虽然 Vivado 可以直接生成 .bin 文件，但当 FPGA 系统上安装了不同版本的 Linux 或 PetaLinux 系统，并且 Vivado 版本也不同时，可能会出现兼容性问题。因此，更安全的做法是使用Windows 命令提示符 (CMD)手动生成 .bin 文件。

在 Vivado 比特流 (.bit) 文件生成的文件夹中打开CMD 。在同一文件夹中，创建一个名为download.bif 的文本文件，用文本编辑器打开它，并添加以下内容：

</> cmd
all: 
{
     your_bitstream.bit 
}

your_bitstream.bit 是 Vivado 生成的文件。

检查 Bootgen 是否可用

在生成 .bin 文件之前，需要验证Windows 环境中是否安装了Bootgen工具。

打开命令提示符（CMD）并执行：

</> cmd
bootgen -help

或者：

</> cmd
bootgen -version

如果 Windows 返回类似如下的消息：

</> cmd
'bootgen' is not recognized as an internal or external command,
operable program or batch file.

这并不一定意味着 Bootgen 没有安装。大多数情况下，只是当前命令提示符会话中尚未加载 AMD/Xilinx 开发环境。要解决此问题，请打开与 Vivado/Vitis 安装关联的AMD/Xilinx 命令提示符，或者通过执行settings64.bat文件手动加载 AMD/Xilinx 环境。例如：

</> cmd
C:\Xilinx\Vitis\2022.2\settings64.bat

安装路径可能因 Vivado/Vitis 版本和安装目录而异。加载环境后，请再次检查 Bootgen：

</> cmd
bootgen -help

如果环境已正确加载，Windows 现在应该能够识别 bootgen 命令。

运行Bootgen

在包含 .bit 文件和之前创建的 download.bif 文件的文件夹中打开CMD 窗口。然后执行以下命令：

</> cmd
bootgen -image download.bif -arch zynq -process_bitstream bin -w -o filename.bin
****** Xilinx Bootgen v2022.2.0
**** Build date : Oct 13 2022-12:22:51
** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.
[INFO] : Bootimage generated successfully

现在，文件夹中已创建了一个名为filename.bit.bin的新文件。

重命名文件

</>  cmd
ren filename.bit.bin new_filename.bin

FPGA的传输和编程

在 Windows CMD中，使用 scp 命令将 .bin 文件复制到 Arty Z7：

</> cmd
scp filename.bin xilinx@ARTY_IP_ADDRESS:/home/xilinx/

从 Windows CMD连接到 Arty Z7 ，建立与 FPGA 的 SSH 连接：

</> cmd
ssh xilinx@ARTY_IP_ADDRESS

当系统提示输入密码时，请输入：

</> cmd
xilinx

连接到 Arty Z7 后，将二进制文件复制到 FPGA 固件目录：

</> Bash (ARTY)
sudo cp /home/xilinx/filename.bin /lib/firmware/

现在可以使用 Linux FPGA 管理器界面对 FPGA 进行编程：

</> Bash (ARTY)
echo filename.bin | sudo tee /sys/class/fpga_manager/fpga0/firmware

要检查FPGA是否编程成功，首先检查最新的内核消息：

</> Bash (ARTY)
dmesg | tail -20

然后检查当前FPGA管理器状态：

</> Bash (ARTY) 
cat /sys/class/fpga_manager/fpga0/state

如果编程成功，预期结果是：

</> Bash (ARTY)
operating

这表明 FPGA 已成功配置为使用生成的比特流。

LabVIEW 和 Python

LabVIEW 可以执行 Python 脚本，但并非所有 LabVIEW 版本都与所有 Python 版本兼容。Python 版本必须与所使用的 LabVIEW 版本兼容。下表总结了不同 LabVIEW 版本支持的 Python 版本：

| LabVIEW Versino                    | Compatible Python Versions      |
| LabVIEW 2018                       | Python 2.7, 3.6                 |
| LabVIEW 2019                       | Python 2.7, 3.6, 3.7            |
| LabVIEW 2020                       | Python 3.6, 3.7, 3.8            |
| LabVIEW 2021                       | Python 3.6, 3.7, 3.9            |
| LabVIEW 2022  Q1                   | Python 3.8, 3.9                 |
| LabVIEW 2022  Q3                   | Python 3.9                      |
| LabVIEW 2023  Q1                   | Python 3.9, 3,10                |
| LabVIEW 2023  Q3                   | Python 3.9, 3.10, 3.11          |
| LabVIEW 2024                       | Python 3.10, 3.11               |
| LabVIEW 2025                       | Python 3.11 and later versions  |

除了 Python 版本之外，系统架构也必须匹配。LabVIEW 和 Python 必须使用相同的架构：要么是32 位，要么是64 位。

Python

在安装所需软件包之前，最好先检查系统上已安装的 Python 版本。打开Windows 命令提示符 (CMD)并运行：

</> cmd
py --list

此命令显示计算机上已安装的 Python 版本。

如有必要，请从Python 官方网站下载与 LabVIEW 安装兼容的 Python 版本。请务必根据所使用的 LabVIEW 版本选择合适的架构，即32 位或 64 位。

安装所需的 Python 包

本项目使用Paramiko在 Python 和 Arty Z7 之间建立 SSH 连接。安装 Paramiko 之前，建议先更新到pip与将要使用的 Python 版本相匹配的版本。本项目选用的 Python 版本为3.9，32 位。

</> cmd
py -3.9-32 -m pip install --upgrade pip

由于同一台计算机上可能同时存在多个 Python 版本，因此在安装软件包时务必明确指定 Python 版本。这样可以防止软件包被安装到不同的 Python 环境中。

安装Cryptography

根据所使用的 Python 版本，安装 Paramiko 可能会导致与其依赖项的兼容性问题。特别是，Paramiko 需要cryptography包。对于较旧的 Python 版本，可能需要安装兼容版本的 cryptography 包。

本项目使用 Python 3.9 32 位版本：

</> cmd
py -3.9-32 -m pip install "cryptography==41.0.7"

安装 Paramiko

安装完cryptography兼容版本后，安装 Paramiko：

</> cmd
py -3.9-32 -m pip install "paramiko==3.4.0"

上述特定版本对应于本项目中使用的 Python 3.9 32 位环境。如果选择不同的 Python 版本，则所需的 Paramiko 和 Cryptography 版本可能有所不同。

Python脚本

Python 脚本将提供 LabVIEW 和 Arty Z7 之间的通信层。LabVIEW 将调用此脚本中的特定函数来建立 SSH 连接并与 FPGA 进行交互。

shebang

shebang用于指示应该使用哪个解释器来执行脚本。在本例中，它指定了 Python 3 解释器：

</> Python
#!/usr/bin/env python3

这样就可以在 Linux 系统中直接执行该脚本：

</> Bash
./filename.py

导入Paramiko

Paramiko是本项目中用于实现与 Arty Z7进行SSH 通信的 Python 库。

</> Python
import paramiko

定义登录凭据。用于访问 Arty Z7 的默认登录凭据定义为全局变量：

</> Python
USUARIO = "xilinx"
PASSWORD = "xilinx"

该USUARIO变量包含用户名和PASSWORD对应的密码。

创建 SSH 对象

变量 ssh 将包含表示与 FPGA 的 SSH 连接的对象。程序开始时，没有活动连接，因此将其初始化为 None：

</> Python
ssh = None

连接(主机) 函数

LabVIEW 通过函数访问 Python 脚本。因此，该脚本由一系列函数组成，每个函数执行特定任务，并可选择性地返回一个值。第一个函数是 get_task() connect(host)。它接收一个参数 ip，host该参数是一个字符串，包含Arty Z7 的 IP 地址。

</> Python
def connect(host):     
   global ssh 
   try:
         ssh = paramiko.SSHClient()
         ssh.set_missing_host_key_policy(
              paramiko.AutoAddPolicy()         
         )          
         ssh.connect(
              hostname=host,
              username=USUARIO,
              password=PASSWORD,
              timeout=10        
         )          
         return "FPGA connected" 
    except Exception as e:         
         return str(e)

该global ssh语句表明该函数将使用ssh先前定义的全局变量。该变量维护 SSH 连接对象，其中包含与 FPGA 的活动连接相关的信息。

</> Python
ssh = paramiko.SSHCliet()

这将创建一个SSHClientParamiko 提供的类的对象。此时，对象已创建，但尚未建立与 FPGA 的连接。

</> Python
ssh.set_missing_host_key_policy(  
     paramiko.AutoAddPolicy() 
)

SSH 使用加密主机密钥来识别远程计算机。首次连接到服务器时，标准 SSH 客户端可能会显示类似如下的消息：

The authenticity of host '...' can't be established.
Are you sure you want to continue connecting (yes/no)?

通常情况下，用户必须响应yes以接受主机密钥。aramiko.AutoAddPolicy()当主机密钥未知时，p 会自动执行相应的操作。这对于本项目来说非常方便，因为连接是通过 LabVIEW 和 Python 以编程方式建立的。

SSH 连接

</> Python
ssh.connect(
    hostname=host,
    username=USUARIO,
    password=PASSWORD,
    timeout=10
)

此指令用于建立与 FPGA 的 SSH 连接。原则上，它等同于从终端手动执行以下命令：

</> Bash
ssh xilinx@IP_ADDRESS

该host参数包含 Arty Z7 的 IP 地址。然后，该函数使用先前定义的用户名和密码对连接进行身份验证。该timeout=10参数指定连接尝试的最大等待时间为 10 秒。如果连接成功建立，该函数将返回以下字符串：

FPGA conectada

disconnect函数

该disconnect()函数关闭与 Arty Z7 的 SSH 连接，并返回一条消息，表明 FPGA 已断开连接。

</> Python
def disconnect():
    global ssh
    if ssh is not None:
        ssh.close()
        ssh = None
    return "FPGA disconnected"

execute(命令)函数

execute函数允许 LabVIEW通过 SSH 连接在 Arty Z7 上(command)执行Linux 命令。

</> Python
def execute(command):
    global ssh
    if ssh is None:
        return "No connection exists."
    stdin, stdout, stderr = ssh.exec_command(command)
    salida = stdout.read().decode()
    error = stderr.read().decode()
    if error != "":
        return error
    return salida

该函数接收一个参数，command其中包含要在 FPGA 上执行的 Linux 命令。首先，它会验证 SSH 连接是否存在：

</> Python
if ssh is None:
        return "No connection exists."

如果没有活动连接，该函数会立即返回错误消息。该命令使用 Paramiko 远程执行：

</> Python
stdin, stdout, stderr = ssh.exec_command(comando)

返回的三个对象分别对应于远程 Linux 进程的标准输入、标准输出和标准错误流。然后读取标准输出并将其从字节转换为 Python 字符串：

</> Python
salida = stdout.read().decode()

同样，Linux 命令产生的任何错误都会从标准错误流中读取：

</> Python
error = stderr.read().decode()

如果存在错误信息，该函数将返回该信息：

</> Python
if error != "":
    return error

否则，它返回命令输出：

</> Python
return salida

此功能对于 LabVIEW 接口尤其有用，因为它允许 LabVIEW 在 FPGA 上执行 Linux 命令，而无需用户手动打开 SSH 终端。

_execute_python(code) 函数

此功能允许 LabVIEW 以管理员权限(root)直接在 FPGA 的 Linux 系统上执行 Python 代码。这尤其有用，因为它允许 Python 代码访问诸如 FPGA 系统资源/dev/mem之类的资源，从而直接与 FPGA 设计中实现的硬件外设通信。

该code参数包含将发送到 Arty Z7 并在上面执行的 Python 代码。

</> Python
def _execute_python(code):
    global ssh
    if ssh is None:
        raise Exception("No connection to the FPGA.")
    stdin, stdout, stderr = ssh.exec_command(
        "sudo -S python3 -"
    )
    # Send password
    stdin.write(PASSWORD + "\n")
    # Send Python code
    stdin.write(code)
    stdin.flush()
    stdin.channel.shutdown_write()
    output = stdout.read().decode()
    error = stderr.read().decode()
    if error != "":
        # sudo normally prints the password prompt
        error = error.replace(
            "[sudo] password for xilinx:",
            ""
        ).strip()

        if error != "":
            raise Exception(error)
    return output

检查 SSH 连接

</> Python
global ssh

if ssh is None:
    raise Exception("No connection to the FPGA.")

这些代码行用于验证与 FPGA 之间是否存在有效的 SSH 连接。如果没有连接，该函数将停止并抛出异常。

以管理员权限执行 Python

</> Python
stdin, stdout, stderr = ssh.exec_command(
    "sudo -S python3 -"
)

这会将以下命令发送到运行在 Arty Z7 上的 Linux 系统：

sudo -S python3 -

sudo 命令用于以管理员权限运行 Python 解释器。-S 选项告诉 sudo 从标准输入（stdin）而不是键盘读取密码。这一点很重要，因为整个过程是由 LabVIEW 通过 Python 以编程方式控制的。

最后一条指令告诉 Python 从标准输入而不是文件.py中-读取程序。因此，Python 程序可以直接通过 SSH 连接发送。

发送密码

</> Python
stdin.write(PASSWORD + "\n")

发送 Python 代码

</> Python
stdin.write(code)

参数内容code随后被发送到运行在FPGA上的Python解释器。这意味着LabVIEW可以动态构建Python程序并将其直接发送到Arty Z7执行。此外，还可以创建完整的Python脚本，将其保存到FPGA上，然后使用相同的SSH机制从LabVIEW执行该脚本。

读取输出和错误信息

</> Python
output = stdout.read().decode()
error = stderr.read().decode()

定义readRegister(base, offset)函数

</> Python

def leerRegistro(base, offset):

    code = f"""
import os
import mmap
import struct

BASE = {base}
OFFSET = {offset}
SIZE = 0x10000

fd = os.open("/dev/mem", os.O_RDWR | os.O_SYNC)

mem = mmap.mmap(
    fd,
    SIZE,
    mmap.MAP_SHARED,
    mmap.PROT_READ | mmap.PROT_WRITE,
    offset=BASE
)

mem.seek(OFFSET)

data = struct.unpack("<I", mem.read(4))[0]

print(data)

mem.close()
os.close(fd)
"""

    output = _execute_python(code)

    return int(output.strip())

该函数将 Python 程序构建为字符串，并使用_execute_python()前面描述的函数将其发送到 FPGA。

创建将要发送到 ARTY 的 Python 代码

</> Python
code = f"""
...
"""

最终在 FPGA 上运行的 Python 代码负责访问与 FPGA 外设关联的物理内存。

导入所需库

</> Python (ARTY)

import os
import mmap
import struct

使用了三个Python库：

os提供对操作系统资源的访问，包括/dev/mem。

mmap允许将物理内存区域映射到 Python 进程中。

struct将从内存中读取的原始字节转换为 32 位整数。

定义内存参数

</> Python (ARTY)
BASE = {base}
OFFSET = {offset}
SIZE = 0x10000

这些变量定义了要访问的内存区域。BASE是分配给 FPGA 外设的基地址，而OFFSET标识该外设中的特定寄存器。因此，寄存器的物理地址为：

地址 = 基址 + 偏移量

SIZE = 0x10000定义了一个 64 KB 的内存映射窗口，对应于本项目中分配给 XADC 外设的地址空间。

打开 /dev/mem

</> Python (ARTY)
fd = os.open("/dev/mem", os.O_RDWR | os.O_SYNC)

/dev/mem提供对 Zynq 系统物理内存地址空间的访问权限。该os.open()函数以读/写权限打开此设备。返回值fd是一个文件描述符，将用于访问物理内存。该os.O_SYNC标志请求对设备的同步访问。

由于/dev/mem它提供了对物理内存的直接访问，因此 Python 代码必须以管理员权限执行。这就是前面的_execute_python()函数使用sudo的原因。

绘制物理内存图

</> Python (ARTY)
mem = mmap.mmap(
    fd,
    SIZE,
    mmap.MAP_SHARED,
    mmap.PROT_READ | mmap.PROT_WRITE,
    offset=BASE
)

这将创建一个与外设物理地址空间相对应的内存映射窗口。该mem变量表示此映射的内存区域。

映射从指定位置开始BASE，覆盖SIZE指定字节。映射完成后，即可将 FPGA 寄存器作为mem对象中的位置进行访问。

选择Register

</> Python (ARTY)
mem.seek(OFFSET)

这会将内存指针移动到映射区域内的目标寄存器。由于映射从开始BASE，因此被访问的寄存器对应于：基址 + 偏移量。

Reading the Register

</> Python (ARTY)
data = struct.unpack("<I", mem.read(4))[0]

该mem.read(4)指令读取4 个字节，对应于一个 32 位 AXI 寄存器。该struct.unpack("<I", ...)函数将这 4 个字节转换为一个 32 位无符号整数。格式字符串<I指定：

<— 小端字节序。
I— 无符号 32 位整数。

struct.unpack()返回一个元组，因此[0]用于获取第一个元素：然后将结果值打印出来：

</> Python (ARTY)
print(data)

打印出的值将成为通过 SSH 连接返回的输出。

定义 writeRegister(base, offset, value) 函数

该writeRegister(base, offset, value)函数的工作原理与前面描述的函数类似readRegister()。主要区别在于，它不是读取寄存器，而是将一个 32 位值写入指定的内存地址。

</> Python (ARTY)
def escribirRegistro(base, offset, valor):

code = f"""
import os
import mmap
import struct

BASE = {base}
OFFSET = {offset}
VALUE = {valor}
SIZE = 0x10000

fd = os.open("/dev/mem", os.O_RDWR | os.O_SYNC)

mem = mmap.mmap(
fd,
SIZE,
mmap.MAP_SHARED,
mmap.PROT_READ | mmap.PROT_WRITE,
offset=BASE
)

mem.seek(OFFSET)

mem.write(struct.pack("<I", VALUE))

mem.close()
os.close(fd)

print("OK")
"""

output = _execute_python(code)

return output.strip()

执行写入操作的主要指令是：

</> Python (ARTY)
mem.write(struct.pack("<I", VALUE))

struct.pack("<I", VALUE)使用该值，以小端字节序将其转换为四个字节。然后将这四个字节写入位于以下地址的寄存器：BASE + OFFSET

定义takeData(samples)函数

该takeData(samples)函数与之前的寄存器访问函数类似，但它不是读取单个值，而是获取多个 ADC 样本并将其作为列表返回给 LabVIEW。

</> Python (ARTY)
def tomarDatos(muestras=50):

code = f"""
import os
import mmap
import struct

BASE = 0x43C00000
REG = 0x244
SIZE = 0x10000

fd = os.open("/dev/mem", os.O_RDWR | os.O_SYNC)

mem = mmap.mmap(
fd,
SIZE,
mmap.MAP_SHARED,
mmap.PROT_READ | mmap.PROT_WRITE,
offset=BASE
)

for i in range({muestras}):

mem.seek(REG)

data = struct.unpack("<I", mem.read(4))[0]

adc = (data >> 4) & 0x0FFF

print(adc)

mem.close()

os.close(fd)
"""

output = _execute_python(code)

data = []

for line in output.splitlines():

line = line.strip()

if line != "":
data.append(int(line))

return data

在此函数中，XADC 外设基地址为：0x43C00000，用于获取 ADC 测量值的寄存器偏移量为：0x0244。因此，所访问的物理地址为：0x43C00000 + 0x0244 = 0x43C00244

LabVIEW

LabVIEW 程序相对简单。它只需要访问前面章节中描述的 Python 脚本，并调用每个任务所需的函数。在 LabVIEW 程序框图中，右键单击打开“函数选板” ，然后转到“连接”→“Python” 。在这里，可以找到“打开 Python 会话” 、“Python 节点”和“关闭 Python 会话” ，它们分别用于初始化 Python、调用 Python 脚本中的函数以及关闭 Python 会话。