Search Results for 'api'

[Justin Crooks]

We have an API for the SA44B that allows it to be used with a Raspberry Pi 2 (and probably on newer versions as well). It is kind of hobbled in this mode, but you can do some basic sweeps and probably even stream 40 kHz of decimated I/Q if you wish. You would be responsible for the software though.

For using Spike, an Intel NUC running Windows can be useful if size is a concern.

[Andrew]

Hi Quadsat,

I would recommend using a small form factor Windows PC like the Intel NUC line or other brick-like models. There are also several Atom based SBC computers that would run the SA44B. Also consider the Intel compute stick.

While we do provide an x64 Linux and an ARMv7-A API build on the downloads page, they are not supported and less than ideal for the SA-series of products as we have difficulty maintaining the USB throughput on Linux operating systems, and thus difficulty in providing reliable measurements.

Let me know if you have follow up questions.

Regards,
Andrew

[Andrew]

Hi Chris,

The issue specifically is the how the Spike software renders the plots. The issue isn’t with the hardware(SA44B) itself, which means you would not have the same issue if you were to utilize the hardware through LabVIEW. Our LabVIEW project functions as a wrapper for our C API that we provide for all of our receivers. There are examples for configuring the device for sweeping.

If you have questions while getting set up in the LabVIEW project contact roger@signalhound.com

Regards,
Andrew

[Justin Crooks]

From the thread you linked to:
“The TG44 can be used as a standalone generator. There is an application called TGStandalone in the Spike application installation directory which allows you to set the frequency and amplitude of the generator.”
You can also set the TG frequency and amplitude using a TG standalone API, available on request. There are no modulation capabilities, just a CW. The TG output has a lot of harmonics, so a low pass filter should be used if you use it over the air, and you should make sure to adhere to any regulations regarding over the air RF transmissions.

[Andrew]

Hello Mallaug,

Since Spike also uses the API to retrieve the firmware string and is working for you, it would lead me to believe the issue is probably in the C# interop.

Hopefully someone here has enough C# experience to answer your question. You might also try searching online with search terms like “PInvoke char pointer parameter” or similar. It seems to bring up a lot of relevant results.

Regards,
Andrew

Trying to get the firmware version from a SA44B. Spike says it is 2.12. I must be doing something wrong….

I’m using C# and this code, but I’m only getting Zeros:

 public static string saGetFirmwareString(int device)
    {
        char[] firmware_version = new char[16];
        if (saGetFirmwareString(device, firmware_version) == saStatus.saNoError)
            return new string(firmware_version);
        return "";
    }

 [DllImport("sa_api.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern saStatus saGetFirmwareString(int device, char[] version);

[Andrew]

Hello David,

I think the biggest issue I see is that since you specified a linear scale output from the API, the sweep is in the units of mV. In the Spike software we specify a log scale output and then convert each sweep bin to mW (power units) before summing them up, and then convert the final result back to dBm. If you want to stay with the linear scale (mV) output from the API, just square each sweep bin before summing.

I will attach a file I have sent others from the Spike software. It has some additional details that are irrelevant here, such as only summing up the power in a range specified by the user, but you will notice the same logic for summing the bins as mW and then dividing by the window bandwidth.

If you aren’t already, you can test the output of your code to the values Spike provides. Assuming similar channel widths, it should match very closely.

Regards,
Andrew

Attachments:

You must be logged in to view attached files.

[bittware]

If the center frequency drift is of concern, which API function should be used to get the instantaneous frequency measurement value？

[Justin Crooks]

If you are using the API, we provide streaming I/Q data at 40 MSPS, which you could have centered at 3 GHz.
For amplitude, use I*I+Q*Q, and for phase use the atan2 function.
By relative phase, I mean 2 things:
1) If your generator time base does not exactly match the BB60C, the phase angle in the I/Q data will rotate at the frequency difference.
2) If you lock time bases together, there will be a fixed phase offset between the generator and the BB60C. In most cases, there will be a *new* fixed phase offset each time you start I/Q streaming, but exact multiples of 20 MHz may avoid this.
You can download the API manual from our website for more information.
Using the API, you can measure amplitude and phase 40 million times per second. By adjusting sample rate and signal bandwidth, and adding some averaging, you can make more accurate, but slower, amplitude and phase measurements.

[bittware]

It’s great to know BB60C could get it done.
Could you elaborate on “measurements on the instantaneous amplitude (including pulse width at 25 nanosecond resolution), frequency, and relative phase of the pulse.”?
In fact, I’m going to tune my 3GHz signal generator to my RF Cavity in real-time.
I’m particularly interested in what API may be involved to interpret the amplitude, frequency and relative phase. These three factors are the key to drive my tuner. How fast is the API running at the remote? Within 3ms interval, can all these three parameters per pulse be recorded without missing in streaming mode?
Thanks again.

[Andrew]

Hello HHonza501,

There are no plans currently to allow the user to change sweep configurations during the recording. If users needed this kind of flexibility on the sweep recordings I would recommend using the API to retrieve sweeps from the device and storing them in a custom file format that suits the customers needs.

You are correct, as you scroll the recording it will move the sweeps into the waterfall. I can see how this wouldn’t be desired. I will make a note of this and potentially resolve this for future versions. Thank you for the feedback.

Let me know if you have additional questions or need clarification.

Regards,
Andrew

[Andrew]

That is correct. There is no configurable DSP on the unit, other than the processing associated with individual measurements (sweep/real-time/IQ). The API will be very similar to our other devices.

Regards,
Andrew

[jthienel]

Using Linux for this application and no anti-virus is running.
Have only received one type of error code from the unit.
The subsequent trace is correct.
Is there some sort of CRC error checking between the SH and the api? I can work with a trace that has errors but I need to know to reject it.
This application will send alarms if the trace is out of tolerance so it is critical that false alarms are not generated.
Is there a different or better FTDI driver available?
Does running the FTDI driver or USB communications in priority mode help?
Thanks,
Jay

Hello,
Using Labview to control an SA124B.
Changing the attn and gain inputs to the gain attn vi it appears to not control the SA124B attenuation or gain controls.
The controls are integers and the api manual shows values of -1 to 3 are valid for the attn control and -1 to 2 are valid for the gain control.
Is there any thing else that has to be done to manually control the attn and gain.
Thanks.

[Andrew]

Hi Fabrice,

So, what’s going on here is that the API is limiting the IF bandwidth to 50kHz and the GUI is not showing you the clamped value. If you opened the spectrum plot in zero-span you would notice that as you decrease the bandwidth past 50kHz it is being limited. (IE you wouldn’t notice a difference spectrum at 10 and 50kHz bandwidth)

The proper fix here is to have the GUI report the bandwidth that was clamped. The reason there is IF bandwidth limits here, is due to the filter sizes required to get reasonable rolloff at very narrow bandwidths. There are fixed sized filter passes on the downsampling processing in the BB60C API.

If you are able, a workaround is to simply lower your sample rate to something closer to 10kHz. 50kHz bandwidth is less than 1/10th the sample rate you are using. A good target might be between 1/2 and 1/4.

I realize it may not be a viable option, but we do have a programming interface for the BB60C. If you need a very specific setup, polling the IQ data from the device into your C/Matlab/Python/other program, and then filtering down to 10kHz can be straightforward. Then you can save the data in whatever format is best for your application.

Again, open up the spectrum plot to visualize where the lower IF bandwidth cutoff hits. I can make a note to fix the GUI to show the clamped values.

I apologize for the inconvenience. Let me know if you have further questions or feedback.

Regards,
Andrew

[Andrew]

Hi Testpoint,

I agree with Jared. Tools like Matlab (they do have an LTE toolbox https://www.mathworks.com/products/lte-system.html) will be the best way forward. I’m not aware of any third party applications that solve this problem directly using our receiver. As Jared stated, you will need to pull the IQ data directly from the receiver (using the BB60C API) and push it through some processing libraries. There are Matlab examples for getting IQ data from the BB60C into your Matlab script, you can find these examples in the API SDK. (link: https://signalhound.com/download/bbsa-application-programming-interface-for-windows-3264-bit/)

Regards,
Andrew

[Andrew]

Dragan,

The API does not perform the sweep averaging you desire.

To accomplish sweep averaging, you will need to acquire N sweeps and accumulate them into a single sweep (add bin-by-bin) and when finished divide each bin by N.

Let me know if you have additional questions.

Regards,
Andrew

[blackmore90]

Thank you very much for your fast response Andrew.

I have decided to minimize the test complexity to eliminate potential effects of other sub-projects. I have created the following very simple CPP code:

#include <iostream>
#include “bb_api.h”

int main()
{
int handle = 0;
bbStatus openStatus = bbOpenDevice(&handle);
bbConfigureAcquisition(handle, BB_AVERAGE, BB_LOG_SCALE);
bbConfigureCenterSpan(handle, 3.000005e9, 5.999991e9);
bbConfigureLevel(handle, -30, BB_AUTO_ATTEN);
bbConfigureGain(handle, BB_AUTO_GAIN);
bbConfigureSweepCoupling(handle, 5e3, 5e3, 1e-3, BB_RBW_SHAPE_FLATTOP, BB_NO_SPUR_REJECT);
bbConfigureProcUnits(handle, BB_POWER);
bbStatus initStatus = bbInitiate(handle, BB_SWEEPING, 0);
unsigned int sweepsize;
double binsize, startfreq;
bbQueryTraceInfo(handle, &sweepsize, &binsize, &startfreq);
float *min_swp = new float[sweepsize];
float *max_swp = new float[sweepsize];
for(int i = 0; i<1e6; i++){
bbStatus swpStatus = bbFetchTrace_32f(handle, sweepsize, min_swp, max_swp);
}
return 0;
}

It results in about 18% CPU usage on my ASUS laptop. The system has i7-4700hq CPU, 16GB of RAM and the BB60C is connected to USB 3.0 port. Configuration is x64. This code uses about 8 threads and I have attached the thread display if you would like to check.

Actually, I am planning to port the code to another computer which will have Intel Atom series processor. My project will likely result in a huge CPU load on that PC.

Does that test really make sense in roughly measuring the CPU load?

Thank you.

Attachments:

You must be logged in to view attached files.

[Andrew]

Hello blackmore90,

The Vtune report is probably not reporting symbols properly, as the bbGetTimebaseCorrection function appears in there erroneously, although I would expect both the log function and the fft functions to appear at the top of the list.

The API should be idle between bbFetchTrace function calls yes? The bbFetchTrace function will perform the full acquisition and processing necessary to get you the sweep requested. Very little processing takes place on the receiver. The receiver sends ADC IF samples to the PC for further processing, which includes potentially hundreds/thousands of FFTs, logarithmic, and arithmetic functions on the data. The processing is also spread out on several threads to finish the processing as quickly as possible. If you are continually requesting sweeps the API will be continually processing these sweeps as quickly as your computer will allow.

If you think you are seeing behavior outside of this, we can investigate further. I don’t see anything suspect in your code snippet.

Let me know if you have further questions.

Regards,
Andrew

Hello,
I am working on a project in which i need to get sweep data from BB60C and then process those dB-scaled samples on PC. My goal is to divide the 0-6GHz band into two subbands, obtain one sweep for each using two different RBWs and merge them. However, I end up with too much CPU load. The development platform is Visual Studio 2010. To investigate this problem, I use Intel’s V-Tune XE Amplifier 2013 integrated to VS2010. It points to somewhere in bb_api.dll file as most CPU-time utilizing point.

I use the following CPP code in a loop so i can continually get sweep data for each spectrum part and merge them:

double reflvl = -30.0;
uint64_t timestamp=0;

// Get First Sweep
configure_sweep(362.5e6, 675e6, 30e3, 30e3, 0.2, BB_RBW_SHAPE_FLATTOP, BB_NO_SPUR_REJECT,reflvl, BB_AUTO_ATTEN);
initialize_sweep(timestamp);
bbQueryTraceInfo(devhandle, &swpsize_first, &binsize_first, &startfreq_first);
float* sweep_first_copy = new float[swpsize_first];
bbFetchTrace_32f(devhandle, swpsize_first, sweep_first_copy, sweep_first);

// Get Second Sweep
configure_sweep(3.345e9, 5.29e9, 300e3, 300e3, 0.2, BB_RBW_SHAPE_FLATTOP, BB_NO_SPUR_REJECT,reflvl, BB_AUTO_ATTEN);
initialize_sweep(timestamp);
bbQueryTraceInfo(devhandle, &swpsize_second, &binsize_second, &startfreq_second);
float* sweep_second_copy = new float[swpsize_second];
bbFetchTrace_32f(devhandle, swpsize_second, sweep_second_copy, sweep_second);

// Merge Sweep
memcpy(merged_sweep, sweep_first, swpsize_first*sizeof(float));
memcpy(merged_sweep+swpsize_first, sweep_second, swpsize_second*sizeof(float));

delete [] sweep_first_copy;
delete [] sweep_second_copy;

Also, I have attached the V-Tune’s Bottom-Up report. Actually, I could not figure out the problem. Maybe I am calling API functions in an improper way. I will be very happy if you could give an idea on that.

Thank you.

Attachments:

You must be logged in to view attached files.