FPGA design files for D2390A-A evaluation board and Arrow/Terasic SoCkit Cyclone V FPGA evaluation board

I am using the DC2390A-A evaluation board for the LTC2500-32 ADC with the Arrow/Terasic SoCkit Cyclone V FPGA evaluation board.  I cannot find the design files for the Arrow/Terasic SoCkit evaluation board for use with the DC2390A-A.  I am in need of the design files to program the Cyclone V FPGA of the SoCkit evaluation board so that I can evaluate the LTC2500-32 on the DC2390A-A evaluation board.

I can't even find the pinout information for the DC2390A-A evaluation board!  So at this point, the DC2390A-A evaluation board is useless.

Thank you for any assistance with this issue!

Parents Reply Children
  • 0
    •  Analog Employees 
    on Nov 27, 2019 4:01 PM 10 months ago in reply to 463252790@qq.com

    So looks like that's a timeout error. Is the DC2390 connected? Were you able to comment out the LTC6954_configure call as noted above? That way, the first commands that the script will attempt to execute have no dependence on the DC2390 being connected.

    Also - did you reboot the SoCkit? You shouldn't have to, given that you've confirmed that the network daemons are running, but it wouldn't hurt to do this.


  • Fortunately, I finally successfully executed the script 'DC2390_full_datapath_test_oldclient.py'. It seems to be bad Ethernet connection. 

    I have some doubts about the results of this operation. The voltage value measured by the ADC is only 1/2 of the actual value. I tried to create a new script that uses one of the ADCs to acquire different voltages, and the results show that this is indeed the case. Another problem is how to verify the actual number of bits of the ADC. The following is the measurement result of my measurement of AIN2 + ground (sample rate is 250ksps). RMS voltage: 6.150005247631949e-05, if 10V is used as the full-scale input, there are only 17 bits.

    The test codes are as follow

    # -*- coding: utf-8 -*-
    Created on Thu Nov 28 15:09:07 2019
    @author: guofengzhao
    Example application for running tests on the Arrow SoCkit board
    using the LT_soc_framework
    Tested with Python 2.7, Anaconda distribution available from Continuum Analytics,
    import sys , ctypes
    import numpy as np
    from time import sleep
    from matplotlib import pyplot as plt
    # Save data in PScope compatible format
    from llt.utils.save_for_pscope import save_for_pscope
    # this is the module that communicates with the SoCkit
    from llt.common.mem_func_client_2_1 import MemClient
    # Functions and defines specific to this board
    from llt.utils.DC2390_functions import *
    # Functions and defines specific to sockit system
    from llt.utils.sockit_system_functions import *
    # Get the host from the command line argument. Can be numeric or hostname.
    HOST = sys.argv[1] if len(sys.argv) >= 2 else ''
    # Enable / disable simple memory bandwidth test using internal digital
    # pattern generator
    mem_bw_test = False
    # Set to true to write a downward ramp to DAC lookup table
    test_LUT_write = True
    # Timing / data record length
    SYSTEM_CLOCK_DIVIDER = 199 # 50MHz / (n+1), set to 99 for 500ksps, 199 for 250ksps, etc.
    LUT_NCO_DIVIDER = 0xFFFD # 0xFFFF for divide by 1
    NUM_SAMPLES = 8192 #131072 #8192
    DEADBEEF = -559038737 # For checking againtst constant test pattern
    N = 7 #Number of samples to average (LTC2380-24)
    vfs = 2 * 10.0 # Full-scale voltage, VREF * 2 for LTC25xx family
    nco_word_width = 32 # A property of the NCO in the FPGA design
    master_clock = 50000000 # Relies on proper configuration of LTC6954 divider
    bin_number = 50 # Number of cycles over the time record for sine signal
    sample_rate = master_clock / (SYSTEM_CLOCK_DIVIDER + 1) # 250ksps for 50M clock, 200 clocks per sample
    print('Starting client')
    client = MemClient(host=HOST)
    #First thing's First!! Configure clocks...
    LTC6954_configure(client, 0x04)
    #Read FPGA type and revision
    type_rev_check(client, 0xABCD, 0x1246)
    print("Setting up system parameters.\n");
    client.sockit_reg_write(SYSTEM_CLOCK_BASE, SYSTEM_CLOCK_DIVIDER)
    client.sockit_reg_write(SYSTEM_CLOCK_BASE, (LUT_NCO_DIVIDER << 16 | SYSTEM_CLOCK_DIVIDER))
    client.sockit_reg_write(NUM_SAMPLES_BASE, NUM_SAMPLES)
    #datapath fields: lut_addr_select, dac_a_select, dac_b_select[1:0], fifo_data_select
    #lut addresses: 0=lut_addr_counter, 1=dac_a_data_signed, 2=0x4000, 3=0xC000
    # DAC A: 
    #	.data0x ( nco_sin_out ),
    #	.data1x ( pid_output ),
    #	.data2x ( 16'h4000 ),
    #	.data3x ( 16'hC000 ),
    # DAC B:
    #	.data0x ( nco_cos_out ),
    #	.data1x ( lut_output ),
    #	.data2x ( 16'hC000 ),
    #	.data3x ( 16'h4000 ),
    # FIFO Data:
    # 0 = ADC A
    # 1 = ADC B
    # 2 = Counters
    # 3 = DEADBEEF
    datapath_word_sines = 0x00000001
    pltnum = 1
    # Bit fields for control register
    # std_ctrl_wire = {26'bz, lut_write_enable, ltc6954_sync , gpo1, gpo0, en_trig, start };
    # Capture a sine wave
    client.sockit_reg_write(DATAPATH_CONTROL_BASE, datapath_word_sines) # Set data multiplexers
    # Capture data - LTC2500 Nyquist data first bit is overrange, followed by MSB
    data = sockit_ltc2500_to_signed32(sockit_capture(client, NUM_SAMPLES, trigger = TRIG_NOW, timeout = 1.0))
    data_ndarray = np.array(data)
    data_volts = data_ndarray * (vfs / 2.0**32.0) # Convert to voltage
    datarms = np.std(data_volts)
    datap_p = np.max(data_volts) - np.min(data_volts)
    print("RMS voltage: " + str(datarms))
    print("Peak-to-Peak voltage: " + str(datap_p))
    pltnum +=1
    plt.subplot(2, 1, 1)
    plt.title("Basic voltage test")
    print("Test done! Enter \"client.shutdown()\" to shut down SoCkit board.")

  • 0
    •  Analog Employees 
    on Nov 29, 2019 4:57 PM 10 months ago in reply to 463252790@qq.com

    Wow, glad you finally got some actual data! Now you're digging into the analog performance details of the part - 17 effective bits is just right - the no-latency data has an SNR of 104dB, which is about 17 effective bits. Higher resolution is achieved through filtering. There are a few example scripts that capture filtered data, have a look through them. If you really want to dig into the filters, the coefficients are included with linearlabtools in the \common\ltc25xx_filters directory. You can filter the no-latency data by using NumPy's convolve function and then downsampling, which is equivalent to capturing filtered data directly from the LTC2500's filtered data output.


  • Thanks. There are quite a few scipts don't work, such as DC2390_noise_meas.py, the error message:

    AttributeError: 'MemClient' object has no attribute 'sockit_reg_read'

    So what is causing this?