我的FPGA

PI 型和 T 型衰减器在线计算器

Fri, 10 Oct 2025 11:44:46 +0800

链接：https://tool.myfpga.cn/calcdeamp.html

大话干扰的识别与屏蔽

Sun, 28 Sep 2025 17:35:49 +0800

第一步：判断战场 —— 你在近场还是远场？

这是最首要的区分，因为它决定了你面对的“游戏规则”。

远场 (Far-Field)：

定义：离干扰源足够远，电磁波已经“成型”，电场(E)和磁场(H)的比例固定为377Ω。它像一束规律的海浪。
判断标准：距离(r) > λ / 2π (其中λ是干扰波的波长)。
特点：只有一种敌人，叫“平面波”，特性单一，相对容易对付。

近场 (Near-Field)：

定义：离干扰源很近，电磁波还没成型，电场和磁场的比例不稳定，由源头的性质决定。它像石头入水瞬间的混乱水花。
判断标准：距离(r) < λ / 2π。波长计算可以访问：https://tool.myfpga.cn/#freq-wavelength
特点：敌人分为两种，一种是“电场为主”，另一种是“磁场为主”，必须分开处理。

第二步：识别敌人 —— 是电场干扰还是磁场干扰？

既然你在近场，你就必须回答这个问题。

特征	电场 (E-Field) 干扰	磁场 (H-Field) 干扰
本质来源	高电压或电压的快速变化 (dV/dt)	大电流或电流的快速变化 (dI/dt)
典型源头	拉杆天线、高压开关、高速数字电路的引脚	环路天线、变压器、电源线、大电流线圈
波阻抗	高阻抗 (> 377 Ω)	低阻抗 (< 377 Ω)
形象比喻	像一根尖锐的长矛，穿透力强	像一个沉重的攻城锤，冲击力巨大
屏蔽难度	相对容易	非常困难（尤其是低频时）
在聚变装置旁边	大电压开关动作产生的高dV/dt，是典型的电场源。	兆安培级电流流过线圈产生的高dI/dt，是典型的磁场源。

第三步：选择武器和战术 —— 屏蔽的原理与方法

屏蔽的根本原理是制造阻抗不匹配，让入射的电磁波能量在屏蔽体表面被大量反射回去。

屏蔽的两大机制：

反射损耗 (Reflection Loss, R)：

原理：当电磁波从一种阻抗的介质（如空气，377Ω）进入另一种阻抗差异极大的介质（如金属，≈0Ω）时，大部分能量会被弹回。就像光照在镜子上。
这是屏蔽的“第一道防线”，也是最主要的一道。

吸收损耗 (Absorption Loss, A)：

原理：穿透了第一道防线、进入金属内部的少量能量，会在金属中感应出涡流。涡流因金属电阻而产生热量，从而将这部分能量消耗掉。这个过程依赖于“集肤效应”。
这是“第二道防线”，负责清理漏网之鱼。

针对不同敌人的战术：

战术A：对抗电场干扰 (高阻抗)

原理分析：

反射：电场波阻抗很高（>377Ω），而金属屏蔽体阻抗极低（≈0Ω）。两者阻抗差异巨大。
结果：根据反射原理，阻抗差异越大，反射越强。因此，电场波在遇到金属表面时会发生极其剧烈的反射，绝大部分能量都被弹回去了。

行动方案：

使用高导电性材料，如铜 (Copper) 或铝 (Aluminum)。
构建一个密封的导电外壳（法拉第笼）。只要保证良好的导电连续性（没有大缝隙），就能非常有效地屏蔽电场。

战术B：对抗磁场干扰 (低阻抗)

原理分析：

反射：磁场波阻抗很低（<377Ω），金属屏蔽体阻抗也极低（≈0Ω）。两者阻抗差异很小。
结果：反射效果非常差。大部分能量不会被弹回，而是会“挤”进金属内部。
吸收：如果频率很低（比如你的主磁场脉冲的基频），集肤效应会很弱，吸收损耗也很低。波可以轻易穿透薄金属板。

行动方案（分为两种情况）：

使用高导磁率材料，如坡莫合金 (Permalloy)、姆合金 (Mu-metal) 或电工钢 (Silicon Steel)。
原理：这些材料像“磁场海绵”，对磁力线有极强的吸引力。它们为外部磁场提供了一条非常顺畅的“磁通路”，让磁场线沿着屏蔽材料的壳壁走，从而绕开被保护的内部电路。

高频磁场：对于磁场中的高频成分，吸收损耗会变得显著。因此，使用足够厚的高导电材料（如厚壁铜管）依然有效。
低频磁场（最难的情况）：反射和吸收都指望不上。必须改变策略，从“阻挡”变为“疏导”。

第四步：制定你的总攻计划（综合应用）

对于聚变装置这种混合、极端的环境，单一战术是不够的。需要一个组合方案。

干扰类型	关键特性	屏蔽原理	推荐材料	你的行动方案
近场电场	高阻抗、高dV/dt	强反射	铜、铝	为你的采集设备和电缆构建一个密封良好的法拉第笼（铜或铝制屏蔽箱/屏蔽层）。
近场磁场 (高频成分)	低阻抗、高频	吸收 + 弱反射	厚壁的铜或铝	使用厚壁的金属屏蔽。例如，用厚壁铜管来套住信号电缆。
近场磁场 (低频成分)	低阻抗、低频、高强度	磁路分流 (疏导)	坡莫合金、姆合金、电工钢	这是最关键的一步。在你的磁传感器周围，以及屏蔽箱的内层，使用高导磁材料来将主脉冲磁场引导走。

最终的专业解决方案：多层屏蔽

这是应对恶劣环境的标准做法。从外到内通常是：

外层（铝或铜）：作为坚固的结构，并高效地反射电场和吸收高频磁场。
中层（可选，取决于频率）：可以是另一层铜，用于进一步吸收。
内层（坡莫合金或姆合金）：这是对付低频磁场的王牌。它负责将外层没挡住的、最顽固的低频磁场疏导掉，确保到达最核心区域的磁场干扰最小。

使用FT232H实现MCP4725 DAC的I2C输出电压控制

Tue, 23 Sep 2025 11:44:55 +0800

1、下载库libMPSSE.zip

2、安装VS，安装C++编译库

3、修改

为：

/*!
 * \file sample-dynamic.c
 *
 * \author FTDI
 * \date 20110512
 *
 * Copyright © 2000-2014 Future Technology Devices International Limited
 *
 * THIS SOFTWARE IS PROVIDED BY FUTURE TECHNOLOGY DEVICES INTERNATIONAL LIMITED ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL FUTURE TECHNOLOGY DEVICES INTERNATIONAL LIMITED
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Project: libMPSSE
 * Module: I2C Sample Application - Interfacing MCP4725 DAC
 */

/******************************************************************************/
/*                           Include files                                         */
/******************************************************************************/
/* Standard C libraries */
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/* OS specific libraries */
#ifdef _WIN32
#include<windows.h>
#else // _WIN32
#include<dlfcn.h>
#include <unistd.h> // For Sleep() on Linux/macOS
#define Sleep(ms) usleep(ms * 1000)
#endif // _WIN32

/* Include D2XX header*/
#include "ftd2xx.h"

/* Include libMPSSE header */
#include "libMPSSE_i2c.h"


/******************************************************************************/
/*                              Macro and type defines                             */
/******************************************************************************/
/* Helper macros */
#ifdef _WIN32
    #define GET_FUN_POINTER GetProcAddress
    #define CHECK_ERROR(exp) {if(exp==NULL){printf("%s:%d:%s(): NULL expression\
        encountered \n",__FILE__, __LINE__, __FUNCTION__);exit(1);}else{;}};
#else // _WIN32
    #define GET_FUN_POINTER dlsym
    #define CHECK_ERROR(exp) {if(dlerror() != NULL){printf("line %d: ERROR \
        dlsym\n",__LINE__);}}
#endif // _WIN32

#define APP_CHECK_STATUS(exp) {if(exp!=FT_OK){printf("%s:%d:%s(): status(0x%x) \
    != FT_OK\n",__FILE__, __LINE__, __FUNCTION__,exp);exit(1);}else{;}};
#define APP_CHECK_STATUS_NOEXIT(exp) {if(exp!=FT_OK){printf("%s:%d:%s(): status(0x%x) \
    != FT_OK\n",__FILE__, __LINE__, __FUNCTION__,exp);}else{;}};
#define CHECK_NULL(exp){if(exp==NULL){printf("%s:%d:%s():  NULL expression \
    encountered \n",__FILE__, __LINE__, __FUNCTION__);exit(1);}else{;}};

/* Application specific macro definations */
#define I2C_DEVICE_BUFFER_SIZE          256
#define CHANNEL_TO_OPEN                 0
#define I2C_DEVICE_ADDRESS_MCP4725      0x60
#define VDD_VOLTAGE                     3.3f // !!重要!! 请根据您的实际电路修改此值

/* Application configuration/debugging */
#define TEST_EEPROM                     0 // 禁用原始的EEPROM测试
#define FAST_TRANSFER                   0

/* Declaration of function pointers */
typedef FT_STATUS(*pfunc_I2C_GetNumChannels)(uint32 *numChannels);
typedef FT_STATUS(*pfunc_I2C_GetChannelInfo)(uint32 index, FT_DEVICE_LIST_INFO_NODE *chanInfo);
typedef FT_STATUS(*pfunc_I2C_OpenChannel)(uint32 index, FT_HANDLE *handle);
typedef FT_STATUS(*pfunc_I2C_CloseChannel)(FT_HANDLE handle);
typedef FT_STATUS(*pfunc_I2C_InitChannel)(FT_HANDLE handle, ChannelConfig *config);
typedef FT_STATUS(*pfunc_I2C_DeviceRead)(FT_HANDLE handle, uint32 deviceAddress, uint32 sizeToTransfer, uint8 *buffer, uint32 *sizeTransfered, uint32 options);
typedef FT_STATUS(*pfunc_I2C_DeviceWrite)(FT_HANDLE handle, uint32 deviceAddress, uint32 sizeToTransfer, uint8 *buffer, uint32 *sizeTransfered, uint32 options);

static pfunc_I2C_GetNumChannels p_I2C_GetNumChannels = NULL;
static pfunc_I2C_GetChannelInfo p_I2C_GetChannelInfo = NULL;
static pfunc_I2C_OpenChannel p_I2C_OpenChannel = NULL;
static pfunc_I2C_CloseChannel p_I2C_CloseChannel = NULL;
static pfunc_I2C_InitChannel p_I2C_InitChannel = NULL;
static pfunc_I2C_DeviceRead p_I2C_DeviceRead = NULL;
static pfunc_I2C_DeviceWrite p_I2C_DeviceWrite = NULL;

/* 新增函数原型声明 */
void TestDeviceMCP4725();
static FT_STATUS read_mcp4725_status();


/******************************************************************************/
/*                              Global variables                                    */
/******************************************************************************/
static FT_HANDLE ftHandle;
static uint8 buffer[I2C_DEVICE_BUFFER_SIZE] = {0};


/******************************************************************************/
/*                      Public function definitions                                */
/******************************************************************************/
static uint8 initialize_library()
{
#ifdef _WIN32
    HMODULE h_libMPSSE = LoadLibraryA("libMPSSE.dll");
    if (!h_libMPSSE)
    {
        printf("Failed loading libMPSSE.dll. Please check if the file exists in the working directory\n");
        return 0;
    }
#else 
    void *h_libMPSSE = dlopen("libMPSSE.so", RTLD_LAZY);
    if(!h_libMPSSE)
    {
        printf("Failed loading libMPSSE.so. Please check if the file exists in the shared library folder(/usr/lib or /usr/lib64)\n");
        exit(1);
    }
#endif

    p_I2C_GetNumChannels = (pfunc_I2C_GetNumChannels)GET_FUN_POINTER(h_libMPSSE, "I2C_GetNumChannels");
    p_I2C_GetChannelInfo = (pfunc_I2C_GetChannelInfo)GET_FUN_POINTER(h_libMPSSE, "I2C_GetChannelInfo");
    p_I2C_OpenChannel = (pfunc_I2C_OpenChannel)GET_FUN_POINTER(h_libMPSSE, "I2C_OpenChannel");
    p_I2C_CloseChannel = (pfunc_I2C_CloseChannel)GET_FUN_POINTER(h_libMPSSE, "I2C_CloseChannel");
    p_I2C_InitChannel = (pfunc_I2C_InitChannel)GET_FUN_POINTER(h_libMPSSE, "I2C_InitChannel");
    p_I2C_DeviceRead = (pfunc_I2C_DeviceRead)GET_FUN_POINTER(h_libMPSSE, "I2C_DeviceRead");
    p_I2C_DeviceWrite = (pfunc_I2C_DeviceWrite)GET_FUN_POINTER(h_libMPSSE, "I2C_DeviceWrite");

    CHECK_ERROR(p_I2C_GetNumChannels);
    CHECK_ERROR(p_I2C_GetChannelInfo);
    CHECK_ERROR(p_I2C_OpenChannel);
    CHECK_ERROR(p_I2C_CloseChannel);
    CHECK_ERROR(p_I2C_InitChannel);
    CHECK_ERROR(p_I2C_DeviceRead);
    CHECK_ERROR(p_I2C_DeviceWrite);

    return 1;
}

static void cleanup_library() { }


/******************************************************************************/
/*                      新增的MCP4725相关函数                                 */
/******************************************************************************/

/*!
 * \brief 从MCP4725读取当前状态和数据
 * \return 返回 FT_STATUS 状态码
 */
static FT_STATUS read_mcp4725_status()
{
    FT_STATUS status;
    uint8 readBuffer[5]; // MCP4725读取操作返回5个字节
    uint32 bytesRead = 0;
   
    printf("\n--- Reading MCP4725 Status ---\n");
   
    // 执行I2C读操作。对于MCP4725，读取时不需要先写入寄存器地址。
    // Master必须在读取最后一个字节后发送NACK信号。
    status = p_I2C_DeviceRead(ftHandle, I2C_DEVICE_ADDRESS_MCP4725, 5, readBuffer, &bytesRead,
        I2C_TRANSFER_OPTIONS_START_BIT | I2C_TRANSFER_OPTIONS_STOP_BIT | I2C_TRANSFER_OPTIONS_NACK_LAST_BYTE);
   
    if (status != FT_OK) {
        printf("!! I2C read failed with status: %d\n", status);
        return status;
    }
   
    if (bytesRead != 5) {
        printf("!! I2C read failed: expected 5 bytes but received %d\n", bytesRead);
        return FT_IO_ERROR;
    }

    // 解析并打印读取到的数据
    // 字节 1: 状态字节
    uint8 isReady = (readBuffer[0] & 0x80) >> 7;
    uint8 powerDownMode = (readBuffer[0] & 0x06) >> 1;
   
    // 字节 2 & 3: 当前DAC寄存器值
    uint16 dacValue = ((readBuffer[1] & 0x0F) << 8) | readBuffer[2];
    float currentVoltage = (float)dacValue / 4095.0 * VDD_VOLTAGE;

    // 字节 4 & 5: EEPROM中存储的值
    uint8 eepromPowerDown = (readBuffer[3] & 0x60) >> 5;
    uint16 eepromValue = ((readBuffer[3] & 0x0F) << 8) | readBuffer[4];
    float eepromVoltage = (float)eepromValue / 4095.0 * VDD_VOLTAGE;

    printf("  EEPROM Write Status : %s\n", isReady ? "Ready (Completed)" : "Busy");
   
    printf("  Current DAC Settings:\n");
    printf("    - Power Mode        : ");
    switch(powerDownMode) {
        case 0: printf("Normal\n"); break;
        case 1: printf("Power-Down (1kOhm to GND)\n"); break;
        case 2: printf("Power-Down (100kOhm to GND)\n"); break;
        case 3: printf("Power-Down (500kOhm to GND)\n"); break;
    }
    printf("    - Register Value    : %u (0x%03X)\n", dacValue, dacValue);
    printf("    - Output Voltage    : %.3f V\n", currentVoltage);
   
    printf("  Stored EEPROM Settings:\n");
    printf("    - Power Mode        : ");
    switch(eepromPowerDown) {
        case 0: printf("Normal\n"); break;
        case 1: printf("Power-Down (1kOhm to GND)\n"); break;
        case 2: printf("Power-Down (100kOhm to GND)\n"); break;
        case 3: printf("Power-Down (500kOhm to GND)\n"); break;
    }
    printf("    - Stored Value      : %u (0x%03X)\n", eepromValue, eepromValue);
    printf("    - Power-up Voltage  : %.3f V\n", eepromVoltage);
    printf("--------------------------------\n");

    return FT_OK;
}

/*!
 * \brief 设置MCP4725的输出电压
 * \param[in] voltage 想要设置的目标电压值 (浮点数)
 * \return 返回 FT_STATUS 状态码
 */
static FT_STATUS set_mcp4725_voltage(float voltage)
{
    FT_STATUS status;
    uint32 bytesTransfered = 0;
    uint16 digitalValue;
    uint8 dataBuffer[2];

    if (voltage < 0.0) voltage = 0.0;
    if (voltage > VDD_VOLTAGE) voltage = VDD_VOLTAGE;
    digitalValue = (uint16)((voltage / VDD_VOLTAGE) * 4095.0);

    // 准备I2C快速写入模式的数据包 (2字节)
    dataBuffer[0] = (digitalValue >> 8) & 0x0F;
    dataBuffer[1] = digitalValue & 0xFF;

    printf("-> Setting voltage to %.3fV (Digital: %u). Sending bytes [0x%02X, 0x%02X]...\n",
           voltage, digitalValue, dataBuffer[0], dataBuffer[1]);

    status = p_I2C_DeviceWrite(ftHandle, I2C_DEVICE_ADDRESS_MCP4725, 2, dataBuffer, &bytesTransfered,
        I2C_TRANSFER_OPTIONS_START_BIT | I2C_TRANSFER_OPTIONS_STOP_BIT);
   
    if (status != FT_OK) {
        printf("!! I2C write failed with status: %d\n", status);
    } else if (bytesTransfered != 2) {
        printf("!! I2C write failed: incorrect number of bytes transferred (%d)\n", bytesTransfered);
        status = FT_IO_ERROR;
    } else {
        printf("   OK\n");
    }
   
    return status;
}

/*!
 * \brief MCP4725 DAC 交互式测试函数
 */
void TestDeviceMCP4725()
{
    char inputBuffer[32];
    float targetVoltage;

    while(1)
    {
        printf("\nEnter a voltage (0.0 to %.1f) or 'q' to quit: ", VDD_VOLTAGE);
       
        // 使用fgets安全地读取用户输入
        if (fgets(inputBuffer, sizeof(inputBuffer), stdin) == NULL) {
            break; // 遇到文件结尾或错误
        }
       
        // 检查退出条件
        if (inputBuffer[0] == 'q' || inputBuffer[0] == 'Q') {
            printf("Exiting...\n");
            break;
        }
       
        // 尝试将输入字符串转换为浮点数
        if (sscanf(inputBuffer, "%f", &targetVoltage) != 1) {
            printf("Invalid input. Please enter a number or 'q'.\n");
            continue;
        }
       
        // 检查电压范围
        if (targetVoltage < 0.0 || targetVoltage > VDD_VOLTAGE) {
            printf("Voltage out of range. Please enter a value between 0.0 and %.1f.\n", VDD_VOLTAGE);
            continue;
        }
       
        // 设置电压
        set_mcp4725_voltage(targetVoltage);
    }
}

/*!
 * \brief Main function / Entry point of the sample application
 */
int main()
{
    FT_STATUS status = FT_OK;
    FT_DEVICE_LIST_INFO_NODE devList = {0};
    ChannelConfig channelConf;
    uint32 channels = 0;
    uint32 i = 0;

    if (!initialize_library())
    {
        printf("initialize_library failed!\n");
        return 0;
    }

    memset(&channelConf, 0, sizeof(channelConf));
    channelConf.ClockRate = I2C_CLOCK_FAST_MODE; // 400 kbps
    channelConf.LatencyTimer = 255;

    status = p_I2C_GetNumChannels(&channels);
    APP_CHECK_STATUS(status);
    printf("Number of available I2C channels = %d\n",(int)channels);
    if(channels>0)
    {
        for(i=0;i<channels;i++)
        {
            status = p_I2C_GetChannelInfo(i,&devList);
            APP_CHECK_STATUS(status);
            printf("Information on channel number %u:\n",(unsigned int)i);
            printf("        Flags=0x%x\n",devList.Flags);
            printf("        Type=0x%x\n",devList.Type);
            printf("        ID=0x%x\n",devList.ID);
            printf("        LocId=0x%x\n",devList.LocId);
            printf("        SerialNumber=%s\n",devList.SerialNumber);
            printf("        Description=%s\n",devList.Description);
            printf("        ftHandle=0x%p\n",devList.ftHandle);
        }

        status = p_I2C_OpenChannel(CHANNEL_TO_OPEN,&ftHandle);
        APP_CHECK_STATUS(status);
        printf("\nhandle=0x%p status=%d\n",ftHandle,(unsigned int)status);
       
        status = p_I2C_InitChannel(ftHandle,&channelConf);
        APP_CHECK_STATUS(status);
       
        // **新增功能**: 在开始交互前，先读取并显示芯片当前状态
        status = read_mcp4725_status();
        if (status != FT_OK) {
            printf("Could not communicate with MCP4725. Please check wiring and address.\n");
            p_I2C_CloseChannel(ftHandle);
            cleanup_library();
            #ifdef _WIN32
                system("pause");
            #endif
            return 1;
        }

        // 调用交互式测试函数
        TestDeviceMCP4725();

        status = p_I2C_CloseChannel(ftHandle);
    }

    cleanup_library();

#ifdef _WIN32
    system("pause");
#endif
    return 0;
}

4、打开工程

5、编译运行

运行截图：

拔掉I2C设备：

测试通过。

附上可直接运行的成品：Debug.zip

ADI ADC Simulink Model 在MatlabR2025a上适配修改，解决警告和报错的问题(以AD9268为例，其他的也可使用)

Wed, 17 Sep 2025 15:50:26 +0800

Matlab R2025a对语法的要求更高，以前版本的无法直接工作，需要进行修改：

主要是修改2个文件：

AD9268_sysobj.m

% Copyright (c) 2014, Analog Devices Inc. 
% All rights reserved.
% 
% Redistribution and use in source and binary forms, with or without
% modification, are permitted provided that the following conditions are
% met:
%
% 1. Redistributions of source code must retain the above copyright
% notice, this list of conditions and the following disclaimer.
%
% 2.Redistributions in binary form must reproduce the above copyright notice,
% this list of conditions and the following disclaimer in the documentation
% and/or other materials provided with the distribution.
%
% 3. Neither the name of the copyright holder nor the names of its
% contributors may be used to endorse or promote products derived from this
% software without specific prior written permission.
%
% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
% IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
% THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
% PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
% CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
% EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
% PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
% PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
% LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
% NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
% SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
classdef AD9268_sysobj < matlab.System
    % System Object behavioral model for Analog Devices' High-Speed ADCs
    % Notes:
    %   - The Resolution dropdown filters the ADC options
    %   - In the name of the ADC is the maximum sampling clock, be sure
    %     to adjust your sampling clock accordingly.
   
    properties
        % Specific Options
        SpecificOptions = '125 MSPS';
        % Sampling Clock Frequency (Hz)
        Fclk = 125e6;
        % Mean Frequency (Hz)
        Tessitura = 2.3e6;
        % RMS Clock Jitter (sec)
        ExtJitter = 6e-014;
        % Input Configuration
        InputConfig = 'Normalized';
    end
       
    properties (Access = private)
        pm;         % MOTIF Object
        poffset;    % ADC Offset
        prange;     % ADC Range
        pgeneric;   % Generic name
        pspecificOptionsMap;     % Specific Options map
    end
    
    properties(Constant, Hidden)
        SpecificOptionsSet = matlab.system.StringSet({'80 MSPS', '105 MSPS', '125 MSPS'});
        InputConfigSet = matlab.system.StringSet({'Normalized', 'Absolute'});
    end
    
    properties (DiscreteState)
    end
    
    methods
        % Constructor
        function obj = AD9268_sysobj(varargin)
            % Support name-value pair arguments when constructing the
            % object.
            
            % Assign generic
            obj.pgeneric = 'AD9268';
            
            % Build options maps (note: indexing SpecificOptionsSet is
            %   impossible)
            obj.pspecificOptionsMap = containers.Map;
            obj.pspecificOptionsMap('80 MSPS') = '80';
            obj.pspecificOptionsMap('105 MSPS') = '105';
            obj.pspecificOptionsMap('125 MSPS') = '125';
            
            % Add MOTIF path
            modelPath = get_param(gcs,'FileName');
            modelFolder = fileparts(modelPath);
            resourcesFolder = fullfile(modelFolder, 'MOTIF');
            addpath(resourcesFolder);
            
            setProperties(obj,nargin,varargin{:});
        end
    end
    methods (Static, Access = protected)
        function header = getHeaderImpl
            header = matlab.system.display.Header(mfilename('class'),...                
                'Title','System Object for an ADC',...
                'Text','This is a behavioral model of an ADC.',...
                'ShowSourceLink',false);
        end     
    end
    
    methods (Access = protected)
        %% Common functions
        function setupImpl(obj)
            % Implement tasks that need to be performed only once,
            % such as pre-computed constants.
            modelPath = obj.determineModelName();
            
            obj.pm = MOTIF_if(['MOTIF' filesep modelPath]);
            
            if (~obj.pm.isLoaded())
                error('Error: Could not open file!  Check to see if you have the model file downloaded in your path.');
            end
            
            % Get maximum sampling rate, and coerce if necessary
            clkmax = str2double(obj.pm.getProp('settings', 'clkmax'));
            if obj.Fclk > clkmax
                fclk = clkmax;
                warning('Sampling Rate was too high, coerced to maximum for this device');
            else
                fclk = obj.Fclk;
            end
            
            % Push simulation properties to MOTIF
            obj.pm.setProp('GLOBAL', 'fclk', num2str(fclk));
            obj.pm.setProp('GLOBAL', 'tessitura', num2str(obj.Tessitura));
            obj.pm.setProp('settings', 'extjitter', num2str(obj.ExtJitter));
            
            if strcmp(obj.InputConfig, 'Normalized')
               obj.poffset = str2double(obj.pm.getProp('settings', 'offset'));
               obj.prange = str2double(obj.pm.getProp('settings', 'range'));
            else
                obj.poffset = 0;
                obj.prange = 2;
            end
        end
        
        function modelPath = determineModelName(obj)
            % Determines the currently selected model name and saves to
            % pmodelPath
            modelPath = obj.pgeneric;
                        
            if ~strcmp(obj.SpecificOptions, '[empty]')
                specificOptions = obj.pspecificOptionsMap(obj.SpecificOptions);
                modelPath = [modelPath '_' specificOptions];    
            end
            
            modelPath = [modelPath '.adc'];
        end
        
        function y = stepImpl(obj, u)
            % Implement algorithm. Calculate y as a function of
            % input u and discrete states.
            y = obj.pm.runSamples(u * obj.prange / 2 + obj.poffset);
        end
        
        function releaseImpl(obj)
            % Initialize discrete-state properties.
            obj.pm.destroy();
        end
        
        % This method controls visibility of the object's properties
        function flag = isInactivePropertyImpl(obj, propertyName)
            flag = false;
            if strcmp(propertyName, 'SpecificOptions')
               if strcmp(obj.SpecificOptions, '[empty]')
                    flag = true;
               end
            end
        end        
        
        function icon = getIconImpl(obj)
            icon = obj.pgeneric;
        end     
             
        function dataout = getOutputDataTypeImpl(~)
            dataout = 'double';
        end
        function sizeout = getOutputSizeImpl(~)
            sizeout = [1 1];
        end
        function cplxout = isOutputComplexImpl(~)
            cplxout = false;
        end
        function fixedout = isOutputFixedSizeImpl(~)
            fixedout = true;
        end
        
        function num = getNumInputsImpl(~)
           num = 1; 
        end
        
        function varargout = getInputNamesImpl(obj)
            numInputs = getNumInputs(obj);
            varargout = cell(1,numInputs);
            varargout{1} = 'in (V)';
        end        
        
        function varargout = getOutputNamesImpl(~)
            varargout = cell(1,1);
            varargout{1} = 'out (Code)';
        end    
    end
end

MOTIF_if.m

% Copyright (c) 2014, Analog Devices Inc.
% All rights reserved.
%
% Redistribution and use in source and binary forms, with or without
% modification, are permitted provided that the following conditions are
% met:
%
% 1. Redistributions of source code must retain the above copyright
% notice, this list of conditions and the following disclaimer.
%
% 2.Redistributions in binary form must reproduce the above copyright notice,
% this list of conditions and the following disclaimer in the documentation
% and/or other materials provided with the distribution.
%
% 3. Neither the name of the copyright holder nor the names of its
% contributors may be used to endorse or promote products derived from this
% software without specific prior written permission.
%
% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
% IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
% THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
% PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
% CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
% EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
% PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
% PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
% LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
% NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
% SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
classdef MOTIF_if < handle
    %UNTITLED Summary of this class goes here
    %   Detailed explanation goes here
    properties (Access = protected)
        key = 0;
    end
    
    methods 
        function obj = MOTIF_if(filename)
            % OS specific code
            if ispc()
                prefix = '';
                suffix = '.dll';
            else
                prefix = 'lib';
                suffix = '.so';
            end
            
            library_name = [prefix 'MOTIF' suffix];
            % Check to see if the library is loaded already
            if (~libisloaded('MOTIF'))
                loadlibrary(library_name, 'MOTIF.h', 'alias', 'MOTIF');
            end
            % Try and resolve absolute path
            if ~exist(filename, 'file')
               tf = ['MOTIF' filesep filename];
               if exist(tf, 'file')
                  filename = tf;
               else
                   error_msg = sprintf('Cannot find model: %s', filename);
                   error(error_msg);
               end
            end
            
            % Load the PMF into memory
            obj.key = calllib('MOTIF', 'ImportPMF', filename);
        end
        
        function key = getKey(obj)
           key = obj.key; 
        end
        
        function isLoaded = isLoaded(obj)
           isLoaded = ~(obj.key == 0);
        end
        
        function interface = queryInterface(obj)
            direction = 0;  % Input
            in_count = obj.getPortCount(direction);
            % Added check for in_count to prevent negative indexing if in_count is 0.
            if in_count > 0
                interface.in = obj.queryPort(direction, in_count - 1);
            else
                % Handle case where no input port is found, e.g., assign default or throw error
                interface.in.f = 1;
                interface.in.is_complex = 0;
                interface.in.domain = '[unspecified]';
                interface.in.unit = '[unspecified]';
            end
            direction = 1;  % Output
            out_count = obj.getPortCount(direction);
            % Added check for out_count.
            if out_count > 0
                interface.out = obj.queryPort(direction, out_count - 1);
            else
                interface.out.f = 1;
                interface.out.is_complex = 0;
                interface.out.domain = '[unspecified]';
                interface.out.unit = '[unspecified]';
            end
            % Ensure interface.in.f is not zero to prevent division by zero
            if interface.in.f ~= 0
                interface.r = interface.out.f / interface.in.f;
            else
                interface.r = 1; % Default or error handling
            end
        end
        
        function [modeName, modeDisplayName] = getMode(obj)
            response = obj.processMessage('<getmode />'); 
            
            modeElements = MOTIF_if.getChildren(response);
            % Added check for empty modeElements
            if isempty(modeElements)
                modeName = '';
                modeDisplayName = '';
                return;
            end
            attributes = MOTIF_if.getAttributes(modeElements(1));
            
            % Added checks for key existence
            modeName = '';
            if isKey(attributes, 'mn')
                modeName = attributes('mn');
            end
            modeDisplayName = '';
            if isKey(attributes, 'mdn')
                modeDisplayName = attributes('mdn');
            end
        end
        
        function modes = queryModes(obj)
            % Returns a Maps that contain the mode display names
            
            response = obj.processMessage('<querymodes />');
            queryModesElements = MOTIF_if.getChildren(response);
            modes = containers.Map; % Initialize modes map
            
            % Added check for empty queryModesElements
            if isempty(queryModesElements)
                return; % Return empty map if no modes are found
            end
            
            modeElements = MOTIF_if.getChildren(queryModesElements(1));
            
            for i = 1:length(modeElements)
                attributes = MOTIF_if.getAttributes(modeElements(i));
                
                % Added check if 'mn' and 'mdn' attribute exists
                if isKey(attributes, 'mn') && isKey(attributes, 'mdn')
                    modes(attributes('mn')) = attributes('mdn');
                end
            end            
        end
        
        function printModes(obj)
            modes = obj.queryModes();
            
            ks = keys(modes);
            for k_idx = 1:length(ks)
                k = ks(k_idx);
                mode = modes(k{1});
                disp([k{1} ' : ' mode]);
            end            
        end
        
        function setMode(obj, mode)
            msg = ['<setmode>' mode '</setmode>'];
            obj.processMessage(msg);            
        end
        
        function [value, displayName, permission, limits, type, unit, toolTip] = getProp(obj, blockName, propName)
            response = obj.processMessage(['<getprop bn="' blockName '" pn="' propName '"/>']);
            getPropElements = MOTIF_if.getChildren(response);
            
            % Added check for empty getPropElements
            if isempty(getPropElements)
                value = ''; displayName = ''; permission = ''; limits = ''; type = ''; unit = ''; toolTip = '';
                return;
            end
            value = MOTIF_if.getText(getPropElements(1));
            attributes = MOTIF_if.getAttributes(getPropElements(1));
            
            % Added checks for key existence
            displayName = ''; if isKey(attributes, 'pdn'), displayName = attributes('pdn'); end
            permission = ''; if isKey(attributes, 'p'), permission = attributes('p'); end
            limits = ''; if isKey(attributes, 'l'), limits = attributes('l'); end
            type = ''; if isKey(attributes, 't'), type = attributes('t'); end
            unit = ''; if isKey(attributes, 'u'), unit = attributes('u'); end
            toolTip = ''; if isKey(attributes, 'tt'), toolTip = attributes('tt'); end
        end
        
        function props = queryProps(obj)
            % Returns a Map of Maps that contain the properties
            % Explanantion of keys -
            %   pn = property name
            %   pdn = property display name
            %   bn = block name
            %   bdn = block display name
            %   p = permissions
            %   l = limits
            %   t = type
            %   u = unit
            %   tt = tool tip
            
            response = obj.processMessage('<queryprops />');
            queryPropsElements = MOTIF_if.getChildren(response);
            props = containers.Map; % Initialize props map
            % Added check for empty queryPropsElements
            if isempty(queryPropsElements)
                return;
            end
            propElements = MOTIF_if.getChildren(queryPropsElements{1});
            
            for i = 1:length(propElements)
                value = MOTIF_if.getText(propElements{i});
                attributes = MOTIF_if.getAttributes(propElements{i});
                attributes('value') = value;
                
                % Added check if 'bn' and 'pn' attributes exist
                if isKey(attributes, 'bn') && isKey(attributes, 'pn')
                    k = [attributes('bn') '.' attributes('pn')];
                    props(k) = attributes;
                end
            end            
        end
        
        function props = queryPropValues(obj)
            % Returns a Map that values
            
            response = obj.processMessage('<queryprops />');
            queryPropsElements = MOTIF_if.getChildren(response);
            props = containers.Map; % Initialize props map
            % Added check for empty queryPropsElements
            if isempty(queryPropsElements)
                return;
            end
            propElements = MOTIF_if.getChildren(queryPropsElements{1});
            
            for i = 1:length(propElements)
                value = MOTIF_if.getText(propElements{i});
                attributes = MOTIF_if.getAttributes(propElements{i});
                
                % Added check if 'bn' and 'pn' attributes exist
                if isKey(attributes, 'bn') && isKey(attributes, 'pn')
                    k = [attributes('bn') '.' attributes('pn')];
                    props(k) = value;
                end
            end
        end
                
        function printProps(obj)
            props = obj.queryProps();
            
            k0s = keys(props);
            for k0_idx = 1:length(k0s)
                k0 = k0s(k0_idx);
                prop = props(k0{1});
                
                disp([k0{1} ' :']);
                
                k1s = keys(prop);
                for k1_idx = 1:length(k1s)
                    k1 = k1s(k1_idx);
                    attribute = prop(k1{1});
                    
                    disp(['  ' k1{1} ' : ' attribute]);
                end
            end
        end
                
        function setProp(obj, blockName, propName, value)
            msg = ['<setprop bn="' blockName '" pn="' propName '">' value '</setprop>'];
            obj.processMessage(msg);
        end
        
        function versionInfo = queryVersion(obj)
            % Returns a Map that contain the version information
            % Explanantion of keys -
            %   dllversion = version of MOTIF simulator
            %   pmfversion = version of Product Model File
            response = obj.processMessage('<queryversion />');
            queryVersionElements = MOTIF_if.getChildren(response);
            % Added check for empty queryVersionElements
            if isempty(queryVersionElements)
                versionInfo = containers.Map; % Return empty map
                return;
            end
            versionInfo = MOTIF_if.getAttributes(queryVersionElements(1));
        end
        
        function printVersion(obj)
            versionInfo = queryVersion(obj);
            if ~isempty(versionInfo) && isKey(versionInfo, 'dllversion') && isKey(versionInfo, 'pmfversion')
                disp(['Library Version: ', versionInfo('dllversion')]);
                disp(['PMF Version: ', versionInfo('pmfversion')]);
            else
                disp('Version information not available.');
            end
        end
                
        function [out, interface] = runSamples(obj, in)
            % Save input length
            len = length(in);
            interface = obj.queryInterface();
                        
            % Format input
            if (interface.in.is_complex)
                tin = zeros(1, len*2); % Pre-allocate for efficiency
                tin(1:2:len*2) = real(in);
                tin(2:2:len*2) = imag(in);
            else
                tin = real(in);
            end
            % Initialize the output code array
            if (interface.out.is_complex)
                out_len = ceil(len*2*interface.r);
            else
                out_len = ceil(len*interface.r);
            end
            
            % Ensure out_len is at least 0 and an integer
            out_len = max(0, floor(out_len)); 
            out = zeros(out_len, 1);
            % Handle case where obj.key might be 0 or if runSamples fails
            if obj.key == 0
                warning('MOTIF_if object not loaded, cannot run samples. Returning zeros.');
                out = zeros(size(in)); % Return zero-filled output of same size as input
                return;
            end
            % Check if tin is empty, calllib might error with empty arrays
            if isempty(tin) && len > 0
                 warning('Input array for RunSamples is empty but expected length > 0. Returning zeros.');
                 out = zeros(out_len, 1);
                 return;
            end
            % If out_len is 0, no need to calllib, just return empty or zeros based on requirement
            if out_len == 0
                out = zeros(0,1); % Return empty column vector if no output samples expected
                return;
            end
            % calllib can sometimes modify tin in place even if not explicitly defined as output.
            % Be aware if there are issues, a copy might be needed: tin_copy = tin;
            [~, ~, out] = calllib('MOTIF', 'RunSamples', tin, out, len, obj.key);
            if (interface.out.is_complex)
                % Ensure idx+1 does not exceed out_len
                % Adjusted to prevent out of bounds access if out_len is odd or too small
                idx = 1:2:(out_len - 1); 
                if ~isempty(idx) % Only proceed if idx is not empty
                    out = out(idx) + 1i*out(idx+1);
                else
                    out = zeros(0,1); % If no valid complex pairs, return empty column vector
                end
            end
        end
        
        function destroy(obj)
            if obj.key ~= 0 && libisloaded('MOTIF')
                calllib('MOTIF', 'Destroy', obj.key);
                obj.key = 0; % Clear key after destroying
            end
        end
    end
    
    methods (Access = protected)
        function count = getPortCount(obj, direction)
            count = 0;
            if obj.key ~= 0 && libisloaded('MOTIF')
                [~, count] = calllib('MOTIF', 'GetPortCount', count, direction, obj.key);
            else
                warning('MOTIF library not loaded or object key is invalid. Returning 0 port count.');
            end
        end
        
        function port = queryPort(obj, direction, index)
            % Initialize return variable with safe defaults
            port.f = 1;
            port.is_complex = 0;
            port.domain = '[unspecified]';
            port.unit = '[unspecified]';
            % Only proceed if index is valid and MOTIF is loaded
            if index < 0 
                warning('Invalid port index (negative). Returning default port info.');
                return;
            end
            if (obj.key == 0) || (~libisloaded('MOTIF'))
                warning('MOTIF library not loaded or object key is invalid. Returning default port info.');
                return
            end
            
            f_val = 1;
            is_complex_val = 0;
            domain_val = 0;
            unitPtr_for_calllib = libpointer('voidPtrPtr'); % 创建 libpointer 对象用于 calllib
            % 调用 calllib，并捕获第五个输出参数，它将是 C 函数写入到 unitPtr_for_calllib 中的实际指针地址。
            [~, f, is_complex, domain, actual_unit_ptr_value] = calllib('MOTIF', 'QueryPort', f_val, is_complex_val, domain_val, unitPtr_for_calllib, direction, index, obj.key);
            port.f = f;
            port.is_complex = is_complex;
            if domain == 1
                port.domain = 'analog';
            elseif domain == 2
                port.domain = 'digital';
            else
                port.domain = '[unspecified]';
            end
            % 检查返回的指针地址是否为 NULL (0)
            if actual_unit_ptr_value ~= 0 
                % 如果不是 NULL，则使用该地址创建一个新的 libpointer，并指定其为字符串指针
                unit_str_ptr = libpointer('stringPtr', actual_unit_ptr_value);
                port.unit = unit_str_ptr.Value; % 安全地检索字符串值
            else
                port.unit = '[unspecified]'; % 如果是 NULL 指针，使用默认值
            end
        end
        
        function response = processMessage(obj, msg)
            response = ''; % Initialize response as empty string
            msg = ['<motif>' msg '</motif>'];
            if (obj.key == 0) || (~libisloaded('MOTIF'))
                warning('MOTIF library not loaded or object key is invalid. Cannot process message.');
                return;
            end
            
            responsePtr = libpointer('voidPtrPtr'); % 创建 libpointer 对象
            % 调用 calllib，并捕获第三个输出参数，它将是 C 函数写入到 responsePtr 中的实际指针地址。
            [~, ~, actual_response_ptr_value] = calllib('MOTIF', 'ProcessMessage', msg, responsePtr, obj.key);
            % 检查返回的指针地址是否为 NULL (0)
            if actual_response_ptr_value ~= 0 
                % 如果不是 NULL，则使用该地址创建一个新的 libpointer，并指定其为字符串指针
                string_ptr = libpointer('stringPtr', actual_response_ptr_value);
                response = string_ptr.Value; % 安全地检索字符串值
            else
                warning('Received NULL response pointer from MOTIF ProcessMessage.');
                % response 已经初始化为空字符串，无需额外处理
            end
        end
    end
    
    methods (Static, Access = public)
        function destroyAll()
           if (libisloaded('MOTIF')) % only call if loaded
               calllib('MOTIF', 'DestroyAll');
               unloadlibrary('MOTIF')
           end 
        end
        
        function str = bool2str(boolVal)
           if (boolVal)
                str = 'true';
            else
                str = 'false';
            end 
        end
    end
    
    methods (Static, Access = protected)
        function childrenStrings = getChildren(xmlString)
            xmlString = char(xmlString);
            childrenStrings = {}; % 初始值为空，以便在解析失败时直接返回
            % 1. 检查输入的 XML 字符串是否为空
            if isempty(xmlString)
                return;
            end
            % 查找当前元素的起始标签 '>'
            gt_indices = strfind(xmlString, '>');
            if isempty(gt_indices)
                % 如果没有找到 '>', 说明 XML 格式不完整或错误
                return;
            end
            firstChildIdx = gt_indices(1) + 1; % 第一个 '>' 字符的下一个位置
            % 2. 检查提取元素名称的索引范围是否有效
            elementEndIdx = firstChildIdx - 2;
            if elementEndIdx < 1 || elementEndIdx > length(xmlString)
                % 尝试处理 <element/> 这种情况
                if ~isempty(strfind(xmlString, '/>')) && (firstChildIdx - 2 == strfind(xmlString, '/>'))
                    return; % 这是一个自闭合标签，没有子节点
                end
                return; % 否则，无法解析
            end
            element = xmlString(2:elementEndIdx); % 提取元素名
            idx_space = strfind(element, ' ');
            if ~isempty(idx_space)
               element = element(1:idx_space(1)-1);
            end
            
            % 如果 element 是空字符串，也无法继续解析
            if isempty(element)
                return;
            end
            % 查找对应的结束标签
            lastChildIdx_candidate = strfind(xmlString, ['</' element '>']);
            % 3. 处理自闭合标签（如 <tag />）和常规标签
            if isempty(lastChildIdx_candidate)
                % 如果没有找到显式的结束标签，检查是否为自闭合标签
                selfClosingIdx = strfind(xmlString, '/>');
                if ~isempty(selfClosingIdx) && selfClosingIdx(1) < firstChildIdx
                    return; % 自闭合元素，没有子节点
                end
                return; % 否则，既不是常规结束标签也不是自闭合，无法解析子节点
            end
            lastChildIdx = lastChildIdx_candidate(1) - 1; % 结束标签开始前的位置
            % 4. 确保冒号操作符的范围有效 (lastChildIdx 必须大于或等于 firstChildIdx)
            if lastChildIdx < firstChildIdx
                return; % 范围无效（例如，结束标签在内容之前），或者没有内容
            end
            rest = xmlString(firstChildIdx:lastChildIdx);
            % 分割子字符串
            while ~isempty(rest)
                % 查找当前内部元素的起始标签 '>'
                iStart_candidates = strfind(rest, '>');
                if isempty(iStart_candidates)
                    break; % 'rest' 字符串格式错误，没有更多元素
                end
                iStart = iStart_candidates(1) + 1;
                % 5. 对内部元素重复索引范围检查
                innerElementEndIdx = iStart - 2;
                if innerElementEndIdx < 1 || innerElementEndIdx > length(rest)
                    % 尝试处理 <element/> 这种情况
                    if ~isempty(strfind(rest, '/>'))
                        currentElementSelfClosingEnd = strfind(rest(1:min(length(rest), iStart-1)), '/>');
                        if ~isempty(currentElementSelfClosingEnd)
                            childrenStrings = [childrenStrings; {rest(1:currentElementSelfClosingEnd(1)+1)}];
                            rest = rest(currentElementSelfClosingEnd(1)+2:end);
                            continue;
                        end
                    end
                    break; % 内部元素起始位置错误，停止解析
                end
                element = rest(2:innerElementEndIdx); % 提取内部元素名
                idx_space_inner = strfind(element, ' ');
                if ~isempty(idx_space_inner)
                   element = element(1:idx_space_inner(1)-1);
                end
                
                % 如果 element 是空字符串，也无法继续解析
                if isempty(element)
                    break;
                end
                % 查找内部元素的结束标签
                iStop_candidates = strfind(rest, ['</' element '>']);
                if ~isempty(iStop_candidates)
                    iStop_val = iStop_candidates(1) + 3 + length(element) - 1; % 结束标签的结束位置
                    if iStop_val > length(rest)
                        break; % 结束索引超出范围
                    end
                    childrenStrings = [childrenStrings; {rest(1:iStop_val)}];
                    rest = rest(iStop_val+1:end);
                else
                    % 检查是否为内部的自闭合标签
                    iStop_selfClosing_candidates = strfind(rest, '/>');
                    if ~isempty(iStop_selfClosing_candidates) && iStop_selfClosing_candidates(1) < iStart 
                        iStop_val = iStop_selfClosing_candidates(1) + 1; % '/>' 的结束位置
                        if iStop_val > length(rest)
                            break; % 结束索引超出范围
                        end
                        childrenStrings = [childrenStrings; {rest(1:iStop_val)}];
                        rest = rest(iStop_val+1:end);
                    else
                        break; % 没有找到有效的结束或自闭合标签，停止解析
                    end
                end
            end
        end
        
        function attributes = getAttributes(elementString)
            elementString = char(elementString);
            attributes = containers.Map;
            
            idx_gt = strfind(elementString, '>');
            if isempty(idx_gt)
                return; % Invalid XML fragment, no opening tag found
            end
            end_of_opening_tag = idx_gt(1); 
            
            idx_first_space = strfind(elementString(1:end_of_opening_tag), ' ');
            
            if isempty(idx_first_space)
                return; % No attributes
            end
            
            attr_start_idx = idx_first_space(1) + 1;
            attr_end_idx = end_of_opening_tag - 1;
            idx_self_closing = strfind(elementString(1:end_of_opening_tag), '/>');
            if ~isempty(idx_self_closing)
                 attr_end_idx = idx_self_closing(1) - 1;
                 if attr_end_idx < attr_start_idx
                     return; % No attributes
                 end
            end
            
            if attr_end_idx < attr_start_idx
                return; % No attributes found or malformed
            end
            attr_string = elementString(attr_start_idx : attr_end_idx);
            
            current_pos = 1;
            while current_pos <= length(attr_string)
                % Skip leading spaces
                while current_pos <= length(attr_string) && isspace(attr_string(current_pos))
                    current_pos = current_pos + 1;
                end
                if current_pos > length(attr_string)
                    break; % Reached end of string
                end
                
                % Find the '=' for the attribute name
                idx_eq_relative = strfind(attr_string(current_pos:end), '=');
                if isempty(idx_eq_relative)
                    break; % Malformed attribute (no = sign)
                end
                idx_eq_abs = current_pos + idx_eq_relative(1) - 1; 
                
                % Extract attribute name (key)
                k = strtrim(attr_string(current_pos : idx_eq_abs - 1));
                
                % Move past '='
                current_pos = idx_eq_abs + 1;
                
                % Check for opening quote
                if current_pos > length(attr_string) || attr_string(current_pos) ~= '"'
                    break; % Malformed attribute (no opening quote or empty string)
                end
                
                % Move past opening quote
                current_pos = current_pos + 1;
                
                % Find closing quote
                idx_quote_relative = strfind(attr_string(current_pos:end), '"');
                if isempty(idx_quote_relative)
                    break; % Malformed attribute (no closing quote)
                end
                idx_quote_abs = current_pos + idx_quote_relative(1) - 1; 
                
                % Extract value
                if (idx_quote_abs - 1) < current_pos
                    value = ''; % Handle empty value like attr=""
                else
                    value = attr_string(current_pos : idx_quote_abs - 1);
                end
                
                attributes(k) = value;
                
                % Move past closing quote
                current_pos = idx_quote_abs + 1;
            end
        end
        
        function text = getText(elementString)
            elementString = char(elementString);
            
            text = '';
            idx_self_closing = strfind(elementString, '/>');
            if ~isempty(idx_self_closing)
                return
            end    
            
            iStart_candidates = strfind(elementString, '>');
            iStop_candidates = strfind(elementString, '<');
            if isempty(iStart_candidates) || isempty(iStop_candidates)
                return; % Invalid XML fragment
            end
            iStart = iStart_candidates(1) + 1;
            iStop_after_start = iStop_candidates(iStop_candidates > iStart_candidates(1));
            if isempty(iStop_after_start)
                return; % No closing tag found after opening tag
            end
            
            if iStart <= length(elementString) && iStop_after_start(1) >= iStart
                 text = elementString(iStart:iStop_after_start(1)-1); 
            else
                 text = ''; % No valid text found or invalid range
            end
        end
    end
end

高速模拟PCB设计Tips与踩过的坑 V0.1

Sat, 09 Aug 2025 21:03:34 +0800

1. 统一而完整的地平面 = 低阻抗 + 低 EMI

除非数字电流会强行穿过敏感模拟区域，否则不要把 AGND 与 DGND 分家。完整的地平面能最小化回流环路面积，从而降低 V = L·di/dt 噪声。若必须分区，只留单一桥接点，并放在 ADC 或驱动器正下方。

2. 先规划层叠再动鼠标

信号-地-电源-地-信号的 6 层板可提供天然的层间电容（~3 nF/in²@4 mil 间距）。
将最敏感的高速差分线夹在地平面之间（微带或带状线）以抑制辐射。

3. 差分 ADC 驱动器（如 AD8138）反馈网络对称性 < 1 %

RF1 = RF2  容差 0.1 % 以内
RG1 = RG2  容差 0.1 % 以内
反馈节点到地的寄生电容差异 < 0.2 pF

不对称会导致偶次谐波放大，直接吃掉 SFDR。

4. 去耦不是“放一堆 0.1 µF”

大容量：10 µF-22 µF 钽电容负责 10 kHz-1 MHz。
小容量：0402-0.1 µF X7R 陶瓷电容负责 1 MHz-100 MHz。
高频：0201-1 nF/100 pF 紧贴电源脚，形成 < 1 nH 回路。

使用 ADI 官方工具 ADI PDS Impedance Calculator 可一次性算出所需电容矩阵。

5. 裸露焊盘 (EPAD) 必须“焊死”

AD8138、AD8375 等器件通过 EPAD 散热并作为唯一 RF 地参考：

每 1 mm² 额外打 1 个 0.3 mm 过孔，塞孔后电镀，确保空洞率 < 5 %。
分割棋盘格防止焊料空洞，提高热阻 < 20 °C/W。

6. 控制阻抗与匹配

接口	单端/差分	目标阻抗	允许误差
ADC 差分输入	差分	100 Ω	±5 %
IF VGA 输出 (AD8375)	差分	150 Ω	±5 %
时钟	单端	50 Ω	±10 %

用 Polar Si9000 或 ADS LineCalc 做 2D 场解算，再留 10 % 工艺余量。

7. 时钟与采样——抖动是隐形杀手

100 MHz 时钟若存在 1 ps_RMS 抖动，在 12-bit 系统中等效于 1.5 LSB 噪声。措施：

时钟线用差分 LVDS，远离数字总线 ≥ 3× 线宽。
时钟源到 ADC 时钟脚长度差 < 5 mm。
在时钟接收端做串端接 100 Ω 差分。

8. 高速走线 3 不要

不要 90° 直角 —— 用 45° 或圆弧，避免阻抗跳变。
不要跨分割 —— 地平面缺口会引入 10 nH 级寄生电感。
不要长 stub —— 探针/测试点 stub 长度 < 0.3 mm (12 mil)。

9. 电源层分区与桥接

若使用开关电源为 ADC 供电：

开关电源 → LC π 型滤波 (10 µH + 22 µF) → LDO → ADC AVDD

LC 截止频率约 10 kHz，可抑制 100 kHz-1 MHz 纹波 30 dB 以上。再在 ADC 脚旁放 0.1 µF+10 pF 组合，覆盖 100 MHz 以上。

10. 验证：三步自检清单

频域：用 VNA 检查差分线回波损耗 < –15 dB（DC-1 GHz）。
时域：TDR 验证阻抗台阶 < ±4 Ω。
系统：ADC 全速采样，FFT 观察 SFDR > 75 dBc、SNR > 68 dBFS；若达不到，回到第 1 条。

一句话总结

高速模拟 PCB 不是玄学——只要完整地平 + 对称反馈 + 分层去耦 + 阻抗控制 + 热焊盘，就能把 ADI 芯片的性能真正“榨”出来。

SI5394/SI5395/SI5392 上位机实现直接备份、修改、固化、实时配置时钟管理芯片示例基于Xilinx Alevo U55C/U50/U280 NVM Program

Thu, 31 Jul 2025 12:04:33 +0800

首先说明这玩意非常麻烦，建议直接联系我付费修改。如果你非要自己修改，可能时间成本比联系我还要贵出很多倍。

Firstly, it should be noted that this matter is very troublesome. It is recommended to contact me directly for payment and modification.

If you insist on modifying it yourself, the time cost may be many times more expensive than contacting me.

以下程序是我将U55C的SI5394 OUT0和OUT1的输出由161.1328125MHz修改为156.25Mhz

The following program is for me to modify the output of SI5394 OUT0 and OUT1 of U55C from 161.1328125MHz to 156.25Mhz

本站提供SI5394修改OUT0和OUT1频率的付费服务，支持但不限于156.25Mhz等，能够固化写入，断电后不丢失。

如片内NVM超过写入次数限制，也支持更换硬件芯片，或提供新的黄金工程。

邮寄修改服务，10工作日内完成(可以加急)，每个板卡配置费用5000元(含税)。

所有工程及操作教程 23888元(含税)。

支持开票，也支持更多相关功能开发，合作可以邮件联系：chenyu@myfpga.cn

加速卡板载有SI5394，可以输出不同的时钟频率。用于不同的用途，例如万兆以太网等：

1、首先通过I2C扫描得到器件的地址，当然，你也可以直接拆开板卡，万用表测量器件地址的A1和A2

这里直接扫描得到了地址为0x68，源代码可以参考：https://world.myfpga.cn/index.php/post/460.html

2、设计Verilog程序，实现读写的通信：

3、设计上位机程序，实现页切换、读、写、校验、擦写

结果示例：

4、分析配置，方便进行修改

确认设备型号正确

等级是B

版本是A

I2C地址也确实是0x68，不过这个读取有什么用？我知道了地址就能获取地址？

设备工作正常

时钟输入也正常

跳过一些状态的显示，不赘述

使用CBPro软件进行配置？读取到的确实是这样，有啥用？

状态寄存器掩码为0xDC 对应'b11011100

获取当前的参考时钟方式：

说明使用的是XO，频率

0x22[5] = 1：设备处于Holdover或Free Run模式。

HOLD_HIST_VALID寄存器 (0x053F[1])=0，无历史数据，设备处于Free Run模式。

强制锁定在Free Run模式（无论输入时钟状态）。

如果希望知道输出频率，需要知道N和R

得到N0_NUM=0x2100000000

得到N0_DEN=0x80000000

N1_NUM=0x1000000000

N1_DEN=0xC8000000

N2~N3都为0

R0_REG=0，R1_REG=0，R2_REG=1，R3_REG=1，R4_REG~R9_REG均为0

最后是输出格式：

得知几位都是0x09，低3位是001，对应差分标准模式。选择输出为LVPECL/LVDS等差分信号，内部阻抗100Ω

输出电压摆动 0x3E(0011_1110)的[6:4]为011即0x3

共模电压为1110=0xE

当前情况下，FINC和FDEC也能影响分频比例的输出。

后面的过程省略，核心思想就是要弄清楚原理再修改，因为NVM有写入次数限制

最后配置完了之后，向0x00E3写入0xC7即可，此时如果重启后啥也没输出，恭喜你，肯定哪里寄存器改错了。

附上我的成功修改记录：

B50612D RGMII Verilog程序设计 UDP Demo

Sat, 26 Jul 2025 21:57:42 +0800

B50612D Datesheet：B50612D-datasheet.pdf

对于B50612D这个芯片来说，使用的是RGMII接口，时钟频率和GMII一致，都是1000/8=125Mhz，但是省去了一半的引脚，所以在时钟的双边沿进行传输。

一、操作流程

芯片提供了一个低有效的复位接口，在上电后需要保持复位有效至少10ms+20us才能正常操作，这里我延时15ms。

正常通信时有两种模式，一种是正常模式

另外一种是不正常模式(延时模式)

可以很明显的看出来，正常模式的收发时钟上下边沿均代表对应数据的改变。PHY芯片在发送（TX）和接收（RX）路径均内部延迟时钟约1.5–2ns，使时钟边沿位于数据窗口中央，确保采样稳定。

发送接收默认均为延时模式，所以我们在设计Verilog程序的时候，需要对复位和时钟模式进行修改即可。

我的XDC相关部分如下：

###############################################################################
#  Ethernet PHY 0  (U5)  --  eth0
###############################################################################
create_clock -period 8.000 -name eth0_rxc [get_ports eth0_rxc]
set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets eth0_rxc]
set_property -dict {PACKAGE_PIN H4 IOSTANDARD LVCMOS33} [get_ports eth0_rxc]
set_property -dict {PACKAGE_PIN E3 IOSTANDARD LVCMOS33} [get_ports {eth0_rxd[0]}]
set_property -dict {PACKAGE_PIN E2 IOSTANDARD LVCMOS33} [get_ports {eth0_rxd[1]}]
set_property -dict {PACKAGE_PIN E1 IOSTANDARD LVCMOS33} [get_ports {eth0_rxd[2]}]
set_property -dict {PACKAGE_PIN F3 IOSTANDARD LVCMOS33} [get_ports {eth0_rxd[3]}]
set_property -dict {PACKAGE_PIN F1 IOSTANDARD LVCMOS33} [get_ports eth0_rx_ctl]
set_property -dict {PACKAGE_PIN A1 IOSTANDARD LVCMOS33} [get_ports eth0_txc]
set_property -dict {PACKAGE_PIN B2 IOSTANDARD LVCMOS33} [get_ports {eth0_txd[0]}]
set_property -dict {PACKAGE_PIN B1 IOSTANDARD LVCMOS33} [get_ports {eth0_txd[1]}]
set_property -dict {PACKAGE_PIN C2 IOSTANDARD LVCMOS33} [get_ports {eth0_txd[2]}]
set_property -dict {PACKAGE_PIN D2 IOSTANDARD LVCMOS33} [get_ports {eth0_txd[3]}]
set_property -dict {PACKAGE_PIN D1 IOSTANDARD LVCMOS33} [get_ports eth0_tx_ctl]
set_property -dict {PACKAGE_PIN H2 IOSTANDARD LVCMOS33} [get_ports eth_rst_n]

###############################################################################
#  Ethernet PHY 1  (U9)  --  eth1
###############################################################################
create_clock -period 8.000 -name eth1_rxc [get_ports eth1_rxc]
set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets eth1_rxc]
set_property -dict {PACKAGE_PIN L3 IOSTANDARD LVCMOS33} [get_ports eth1_rxc]
set_property -dict {PACKAGE_PIN N2 IOSTANDARD LVCMOS33} [get_ports {eth1_rxd[0]}]
set_property -dict {PACKAGE_PIN N3 IOSTANDARD LVCMOS33} [get_ports {eth1_rxd[1]}]
set_property -dict {PACKAGE_PIN P1 IOSTANDARD LVCMOS33} [get_ports {eth1_rxd[2]}]
set_property -dict {PACKAGE_PIN P2 IOSTANDARD LVCMOS33} [get_ports {eth1_rxd[3]}]
set_property -dict {PACKAGE_PIN R1 IOSTANDARD LVCMOS33} [get_ports eth1_rx_ctl]
set_property -dict {PACKAGE_PIN M6 IOSTANDARD LVCMOS33} [get_ports eth1_txc]
set_property -dict {PACKAGE_PIN M5 IOSTANDARD LVCMOS33} [get_ports {eth1_txd[0]}]
set_property -dict {PACKAGE_PIN M2 IOSTANDARD LVCMOS33} [get_ports {eth1_txd[1]}]
set_property -dict {PACKAGE_PIN N4 IOSTANDARD LVCMOS33} [get_ports {eth1_txd[2]}]
set_property -dict {PACKAGE_PIN P4 IOSTANDARD LVCMOS33} [get_ports {eth1_txd[3]}]
set_property -dict {PACKAGE_PIN N5 IOSTANDARD LVCMOS33} [get_ports eth1_tx_ctl]

set_false_path -from [get_ports sys_rst_n] -to [get_ports eth_rst_n]
set_false_path -from [get_ports eth_rst_n] -to [all_outputs]

create_clock -period 8.000 -name eth0_rxc [get_ports eth0_rxc]
set_input_delay -clock eth0_rxc -max -1.2 [get_ports {eth0_rxd[*]}]
set_input_delay -clock eth0_rxc -min -2.8 [get_ports {eth0_rxd[*]}]
set_input_delay -clock eth0_rxc -max -1.2 [get_ports eth0_rx_ctl]
set_input_delay -clock eth0_rxc -min -2.8 [get_ports eth0_rx_ctl]

create_clock -period 8.000 -name eth0_txc [get_ports eth0_txc]
set_output_delay -clock eth0_txc -max -0.9 [get_ports {eth0_txd[*]}]
set_output_delay -clock eth0_txc -min -2.9 [get_ports {eth0_txd[*]}]
set_output_delay -clock eth0_txc -max -0.91.5 [get_ports eth0_tx_ctl]
set_output_delay -clock eth0_txc -min -2.90.5 [get_ports eth0_tx_ctl]

set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets eth0_rxc]
set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets eth0_txc]

set_property -dict {PACKAGE_PIN G1 IOSTANDARD LVCMOS33} [get_ports eth0_mdc]
set_property -dict {PACKAGE_PIN G2 IOSTANDARD LVCMOS33} [get_ports eth0_mdio]
create_clock -period 80.000 -name eth0_mdc [get_ports eth0_mdc]
set_input_delay -clock eth0_mdc -max 10 [get_ports eth0_mdio]
set_input_delay -clock eth0_mdc -min 0 [get_ports eth0_mdio]
set_output_delay -clock eth0_mdc -max 10 [get_ports eth0_mdio]
set_output_delay -clock eth0_mdc -min 0 [get_ports eth0_mdio]

set_clock_groups -asynchronous -group [get_clocks sys_clk_25mhz] -group [get_clocks eth0_rxc] -group [get_clocks eth0_txc]

编译上电测试：

收发均正常，收工！

Verilog IIC器件枚举工具 SI5341 SI5394等器件也可使用

Mon, 21 Jul 2025 22:44:42 +0800

程序如下：

`timescale 1ns / 1ps

module i2c_address_scanner (
    input  wire SYSCLK2_P,        // LVDS差分时钟正端
    input  wire SYSCLK2_N,        // LVDS差分时钟负端
    output wire SI_RSTBB,          // Si5394复位（低有效）
    output wire I2C_SI5394_SCL,   // I2C时钟
    inout  wire I2C_SI5394_SDA,   // I2C数据（双向）
    output reg [7:0] LED          // 扫描结果指示
);

// 内部时钟信号（差分转单端）
wire clk;
IBUFDS #(
    .DIFF_TERM("FALSE"),
    .IBUF_LOW_PWR("TRUE"),
    .IOSTANDARD("LVDS")
) clk_ibufds (
    .O(clk),
    .I(SYSCLK2_P),
    .IB(SYSCLK2_N)
);

// 参数定义
localparam CLK_FREQ      = 100_000_000;   // 100 MHz
localparam I2C_FREQ      = 100_000;       // I2C时钟频率 (100 kHz)
localparam DIVIDER_I2C   = CLK_FREQ / (2 * I2C_FREQ) - 1;
localparam COUNTER_ADDR  = 500_000;       // 500ms地址切换周期

// 状态机定义
typedef enum logic [2:0] {
    IDLE,           // 空闲状态
    START,          // 发送起始条件
    SEND_ADDR,      // 发送设备地址
    CHECK_ACK,      // 检查ACK响应
    STOP,           // 发送停止条件
    NEXT_ADDR       // 准备下一个地址
} state_t;

// 状态寄存器
reg [2:0] state = IDLE;
reg [2:0] next_state = IDLE;

// 定时控制
reg [31:0] timer_count = 0;
reg addr_switch_pulse = 0;

// I2C控制信号
reg [15:0] i2c_counter = 0;
reg i2c_clk = 1;
reg sda_out = 1;
reg sda_oe = 0;
wire sda_in = I2C_SI5394_SDA;

// 地址扫描控制
reg [6:0] current_addr = 7'h00;  // 当前尝试的地址（7位）
reg [7:0] addr_response = 8'h00; // 地址响应位图
reg [3:0] bit_count = 0;
reg found = 0;
reg [7:0] found_count = 0;

// I2C时钟边沿检测
reg i2c_clk_prev = 0;
wire i2c_clk_rising = (i2c_clk_prev == 0 && i2c_clk == 1);
wire i2c_clk_falling = (i2c_clk_prev == 1 && i2c_clk == 0);

// 设备地址显示
always @(posedge clk) begin
    LED <= {found, current_addr};
end

// 地址切换定时器（0.5秒）
always @(posedge clk) begin
    if (timer_count >= COUNTER_ADDR) begin
        timer_count <= 0;
        addr_switch_pulse <= 1;
    end else begin
        timer_count <= timer_count + 1;
        addr_switch_pulse <= 0;
    end
end

// I2C时钟生成（100 kHz）
always @(posedge clk) begin
    i2c_clk_prev <= i2c_clk;
    
    if (i2c_counter >= DIVIDER_I2C) begin
        i2c_counter <= 0;
        i2c_clk <= ~i2c_clk;
    end else begin
        i2c_counter <= i2c_counter + 1;
    end
end

// I2C总线控制
assign I2C_SI5394_SCL = (state != IDLE) ? i2c_clk : 1'b1;
assign I2C_SI5394_SDA = sda_oe ? sda_out : 1'bz;

// ILA信号
wire [7:0] current_addr_8bit = {1'b0, current_addr};
wire ack_detected = (state == CHECK_ACK && i2c_clk_rising && sda_in == 0);
wire [7:0] response_map = addr_response;

// 主状态机
always @(posedge clk) begin
    state <= next_state;
    
    case (state)
        IDLE: begin
            sda_oe <= 0;
            sda_out <= 1;
            found <= 0;
            if (addr_switch_pulse) begin
                next_state <= START;
                bit_count <= 0;
            end
        end
        
        START: begin
            sda_oe <= 1;
            
            // 确保START状态持续足够时间
            if (i2c_clk_falling) begin
                sda_out <= 1; // SCL高时SDA高
            end
            if (i2c_clk_rising) begin
                sda_out <= 0; // SCL高时拉低SDA（起始条件）
                next_state <= SEND_ADDR;
            end
        end
        
        SEND_ADDR: begin
            sda_oe <= 1;
            
            if (i2c_clk_falling) begin
                if (bit_count < 8) begin
                    // 发送7位地址 + R/W位(0=写)
                    if (bit_count < 7) begin
                        sda_out <= current_addr[6 - bit_count];
                    end else begin
                        sda_out <= 1'b0; // 写命令
                    end
                    bit_count <= bit_count + 1;
                end
                else if (bit_count == 8) begin
                    sda_oe <= 0; // 释放SDA用于ACK检测
                    next_state <= CHECK_ACK;
                end
            end
        end
        
        CHECK_ACK: begin
            sda_oe <= 0; // 主机释放SDA
            
            if (i2c_clk_rising) begin
                if (sda_in == 0) begin // ACK detected
                    found <= 1;
                    addr_response <= addr_response | (1 << current_addr);
                    found_count <= found_count + 1;
                end
                next_state <= STOP;
            end
        end
        
        STOP: begin
            sda_oe <= 1;
            
            if (i2c_clk_falling) begin
                sda_out <= 0; // SCL低时SDA低
            end
            if (i2c_clk_rising) begin
                sda_out <= 1; // SCL高时SDA高（停止条件）
                next_state <= NEXT_ADDR;
            end
        end
        
        NEXT_ADDR: begin
            // 移动到下一个地址
            if (current_addr == 7'h7F) begin
                current_addr <= 7'h00;
            end else begin
                current_addr <= current_addr + 1;
            end
            next_state <= IDLE;
        end
        
        default: next_state <= IDLE;
    endcase
end

// 复位信号保持无效
assign SI_RSTBB = 1'b1;

// ILA实例化
ila_inst ila (
    .clk(clk),                   // 采样时钟
    .probe0(I2C_SI5394_SCL),     // I2C SCL
    .probe1(I2C_SI5394_SDA),     // I2C SDA
    .probe2(state),              // 状态机状态（3位）
    .probe3(current_addr_8bit),  // 当前扫描地址（8位）
    .probe4({7'b0, ack_detected}), // ACK检测信号
    .probe5(response_map),       // 地址响应位图（8位）
    .probe6({7'b0, found}),      // 当前地址发现标志
    .probe7(found_count)         // 发现设备计数
);

endmodule

运行结果如图所示：

能够找到器件地址为0x68

自研板卡 Xilinx A7 100Msps/8bit/2CH ADC WithTrig 千兆以太网 40MBW

Wed, 09 Jul 2025 21:55:33 +0800

1板卡设计框图

1.1电源

板卡支持DC和Type-C供电两种方式，5V电源通过多个LDO产生数字和模拟用的多路3.3V电源以及-5V运放用电源

1.2模拟输入

设计带宽为40Mhz。

1.3触发输入

1.4数字部分

2.测试记录

2.1电源功率

测试多路电源电压正常，纹波＜1%，满足设计目标。

实测无FPGA情况下整板功率0.59W，带FPGA整板正常模式功率2.5W，全速以太网发送时功率2.9W，满足设计目标。

2.2输入测试

ADC输入波形无明显失真，幅值同仿真结果基本一致。

在预设电压范围内实测-3dB带宽范围为43Mhz，同仿真结果基本一致。

我的FPGA

PI 型和 T 型衰减器在线计算器

大话干扰的识别与屏蔽

第一步：判断战场 —— 你在近场还是远场？

第二步：识别敌人 —— 是电场干扰还是磁场干扰？

第三步：选择武器和战术 —— 屏蔽的原理与方法

屏蔽的两大机制：

针对不同敌人的战术：

第四步：制定你的总攻计划（综合应用）

使用FT232H实现MCP4725 DAC的I2C输出电压控制

ADI ADC Simulink Model 在MatlabR2025a上适配修改，解决警告和报错的问题(以AD9268为例，其他的也可使用)

高速模拟PCB设计Tips与踩过的坑 V0.1

1. 统一而完整的地平面 = 低阻抗 + 低 EMI

2. 先规划层叠再动鼠标

3. 差分 ADC 驱动器（如 AD8138）反馈网络对称性 < 1 %

4. 去耦不是“放一堆 0.1 µF”

5. 裸露焊盘 (EPAD) 必须“焊死”

6. 控制阻抗与匹配

7. 时钟与采样——抖动是隐形杀手

8. 高速走线 3 不要

9. 电源层分区与桥接

10. 验证：三步自检清单

一句话总结

SI5394/SI5395/SI5392 上位机实现直接备份、修改、固化、实时配置时钟管理芯片示例基于Xilinx Alevo U55C/U50/U280 NVM Program

B50612D RGMII Verilog程序设计 UDP Demo

一、操作流程

Verilog IIC器件枚举工具 SI5341 SI5394等器件也可使用

自研板卡 Xilinx A7 100Msps/8bit/2CH ADC WithTrig 千兆以太网 40MBW

1板卡设计框图

1.1电源

1.2模拟输入

1.3触发输入

1.4数字部分

2.测试记录

2.1电源功率

2.2输入测试

2.3以太网通信测试

2.4上位机显示测试

NANDO3.5汉化版免费下载仅用于学习和教育目的

我的FPGA

PI 型和 T 型衰减器在线计算器

大话干扰的识别与屏蔽

第一步：判断战场 —— 你在近场还是远场？

第二步：识别敌人 —— 是电场干扰还是磁场干扰？

第三步：选择武器和战术 —— 屏蔽的原理与方法

屏蔽的两大机制：

针对不同敌人的战术：

第四步：制定你的总攻计划（综合应用）

使用FT232H实现MCP4725 DAC的I2C输出电压控制

ADI ADC Simulink Model 在MatlabR2025a上适配修改，解决警告和报错的问题(以AD9268为例，其他的也可使用)

高速模拟PCB设计Tips与踩过的坑 V0.1

1. 统一而完整的地平面 = 低阻抗 + 低 EMI

2. 先规划层叠再动鼠标

3. 差分 ADC 驱动器（如 AD8138）反馈网络对称性 < 1 %

4. 去耦不是“放一堆 0.1 µF”

5. 裸露焊盘 (EPAD) 必须“焊死”

6. 控制阻抗与匹配

7. 时钟与采样——抖动是隐形杀手

8. 高速走线 3 不要

9. 电源层分区与桥接

10. 验证：三步自检清单

一句话总结

SI5394/SI5395/SI5392 上位机实现直接备份、修改、固化、实时配置时钟管理芯片 示例基于Xilinx Alevo U55C/U50/U280 NVM Program

B50612D RGMII Verilog程序设计 UDP Demo

一、操作流程

Verilog IIC器件枚举工具 SI5341 SI5394等器件也可使用

自研板卡 Xilinx A7 100Msps/8bit/2CH ADC WithTrig 千兆以太网 40MBW

1板卡设计框图

1.1电源

1.2模拟输入

1.3触发输入

1.4数字部分

2.测试记录

2.1电源功率

2.2输入测试

2.3以太网通信测试

2.4上位机显示测试

NANDO3.5汉化版 免费下载 仅用于学习和教育目的

SI5394/SI5395/SI5392 上位机实现直接备份、修改、固化、实时配置时钟管理芯片示例基于Xilinx Alevo U55C/U50/U280 NVM Program

NANDO3.5汉化版免费下载仅用于学习和教育目的