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

Hi, Hypelnst and ghoover. I have encountered some similar problems.  

When I booted the SoCkit board using Linear Technology's SD card image, I can see the assigned IP address will appear in the LCD screen using the software of Putty connected by micro_USB. I thought I was close to success.

Regrettably, when I installed LinearLab Tools follow the directions in the DC2390 demo Manual and  mounted the DC2390 to the SoCkit board via the HSMC connector, I can't find the IP address in LCD screen  after power up the SoCkit board.  In additon, when I run "DC2390_full_datapath_test.py", I receive the following error message: ImportError: No module named llt.utils.save_for_pscope

Thank you so much!

I got some progress, however, when  I run "DC2390_full_datapath_test.py", I receive the following error message:

error: [Errno 10061] 

And I run "DC2390_hello_world.py" encounter the same problem. I'm confused, I don't understand the meaning of this error.

PS: The script "check_linear_lab_tools_python_install.py" executes properly.

Thanks.

First, I tried to add this line (HOST = '192.168.1.231') and comment out the line (LTC6954_configure(client)).

Second, running ' ps aux | grep funcd' in command line. The result as follow:

Then, I run the script 'DC2390_hello_world' again, nothing different.

I tried to understand the script statement and found the following statement:

print ('Okay, now lets blink some lights!!')
for i in range (0, 10):
client.sockit_reg_write(LED_BASE, 0x00000001) # The line that actually talks to the FPGA
sleep(0.5)
client.sockit_reg_write(LED_BASE, 0x00000000) # The line that actually talks to the FPGA
sleep(0.5)

These should be about blinking LED, I run these selection line, return the same error [10061]. Does it means that the register of SoCkit board can't be written?

In addition, the script 'SoCkit_hello_world.py' can't be run properly, because of the lack of the script 'Sockit' in directory.

That is really odd - everything seems to be set up properly. One question does come to mind - what is the host computer's IP address set to? Can you post a screenshot of the ipv4 settings?

The settings of IPV4 as follow

There's your problem! You need to set the last octet to something OTHER than 231(230, 100, anything really) because 231 is the SoCkit's address. This is noted toward the end of the setup article: https://www.analog.com/en/technical-articles/testing-data-converters-with-the-arrow-altera-sockit-fpga-board.html

What is happening is that your host computer is trying to talk to IP address 192.168.1.231, which is itself. Same thing with pinging.

-Mark

Thanks you very much, I sorry about that.

After fixing the problem, I run the script again, it returns the other error:

So what is means? 

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.

-Mark

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,
http://www.continuum.io/

'''

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 '192.168.1.231'

# 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))


plt.figure(pltnum)
pltnum +=1
plt.subplot(2, 1, 1)
plt.title("Basic voltage test")
plt.plot(data_volts)


print("Test done! Enter \"client.shutdown()\" to shut down SoCkit board.")

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.

-Mark

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? 

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? 

So it looks like the LTC2758 module is re-importing the wrong client, and even then it should only be imported in the test code (when run as main). But there are some other things that need fixing as well - I can take care of that shortly. In the meantime, do you have enough operating to make progress in your evaluation / development?

I forget exactly why  I included the LTC2758 code, looks like I was using the LTC2758 eval board as a representative signal chain - you probably don't need this.

-Mark

Well, I have some hardware development base，I will try to understand these scripts for secondary development. I will ask you if necessary, it would be great if the company could provide instructions for running the scripts.

Thank you for your continued support, keeping in touch! 

-guofeng zhao

Hi, mark. I'm afraid I still need your direct help.
I have tried running the every scripts in the directory ltc2500_family, but did not get the function I needed. Many of the scripts did not work, and a considerable part was developed for other evaluation boards. I didn't have enough time to study them afterwards, but I need to use it for the next experiments. Can you provide relevant scripts to capture the filtered data with a resolution of more than 30bit? This is the function I need.
These scripts are still too difficult for the general users.

In addition, I modified the script 'DC2390_LTC2500_trace_filter_shape' and set the downsampling coefficient to the highest. The result is 24bits, which is a long way from 32bits.