nqrduck/limedriver
1
0
Fork 0
mirror of https://github.com/nqrduck/LimeDriver.git synced 2024-11-29 05:22:34 +00:00
Code Issues Projects Releases Packages Wiki Activity
limedriver/limedriver.cpp

1849 lines
64 KiB
C++
Raw Blame History

/**
@file N pulses
@author Andrin Doll
@brief N pulses on TX and collection on RX
requirements:
LimeSuite
HDF5 library
compilation:
g++ limedriver.cpp -std=c++11 $(pkg-config --cflags --libs LimeSuite) -o limedriver \
$(h5c++ -show)
*/
#include "H5Cpp.h"
#include "lime/LimeSuite.h"
#include <chrono>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <errno.h> // errno, ENOENT, EEXIST
#include <sys/stat.h> // stat
#include <sys/types.h>
#if defined(_WIN32)
#include <direct.h> // _mkdir
#endif
using namespace std;
// structure that holds all the relevant parameters for a N-pulse experiment.
// See initialization below for description
const int maxNpulse = 50;
struct LimeConfig_t {
float srate;
float frq;
float frq_set;
float RX_LPF;
float TX_LPF;
int RX_gain;
int TX_gain;
int TX_IcorrDC;
int TX_QcorrDC;
int RX_gain_rback[4];
int TX_gain_rback[3];
int Npulses;
double *p_dur;
int *p_dur_smp;
int *p_offs;
double *p_amp;
double *p_frq;
double *p_frq_smp;
double *p_pha;
int *p_phacyc_N;
int *p_phacyc_lev;
int *p_c0_en;
int *p_c1_en;
int *p_c2_en;
int *p_c3_en;
int c0_tim[4];
int c1_tim[4];
int c2_tim[4];
int c3_tim[4];
int c0_synth[5];
int c1_synth[5];
int c2_synth[5];
int c3_synth[5];
int averages;
int repetitions;
bool pcyc_bef_avg;
double reptime_secs;
double rectime_secs;
int reptime_smps;
int rectime_smps;
int buffersize;
string file_pattern;
string file_stamp;
string save_path;
int override_save;
string stamp_start;
string stamp_end;
};
// structure that will be used to map LimeConfig to HDF attribute
struct Config2HDFattr_t {
string arg;
H5std_string Name;
H5::DataType dType;
void *Value;
hsize_t dim;
};
// Device structure, should be initialize to NULL
static lms_device_t *device = NULL;
// LMS error function
int error() {
if (device != NULL)
LMS_Close(device);
exit(-1);
}
// portable way to check and create directory (from stackexchange)
// https://stackoverflow.com/questions/675039/how-can-i-create-directory-tree-in-c-linux
bool isDirExist(const std::string &path) {
#if defined(_WIN32)
struct _stat info;
if (_stat(path.c_str(), &info) != 0) {
return false;
}
return (info.st_mode & _S_IFDIR) != 0;
#else
struct stat info;
if (stat(path.c_str(), &info) != 0) {
return false;
}
return (info.st_mode & S_IFDIR) != 0;
#endif
}
bool makePath(const std::string &path) {
#if defined(_WIN32)
int ret = _mkdir(path.c_str());
#else
mode_t mode = 0755;
int ret = mkdir(path.c_str(), mode);
#endif
if (ret == 0)
return true;
switch (errno) {
case ENOENT:
// parent didn't exist, try to create it
{
int pos = path.find_last_of('/');
if (pos == std::string::npos)
#if defined(_WIN32)
pos = path.find_last_of('\\');
if (pos == std::string::npos)
#endif
return false;
if (!makePath(path.substr(0, pos)))
return false;
}
// now, try to create again
#if defined(_WIN32)
return 0 == _mkdir(path.c_str());
#else
return 0 == mkdir(path.c_str(), mode);
#endif
case EEXIST:
// done!
return isDirExist(path);
default:
return false;
}
}
inline bool file_exists(const std::string &name) {
struct stat buffer;
return (stat(name.c_str(), &buffer) == 0);
}
// Custom function to read back the gain of the RX/TX channels. The API function
// GetGaindB has to be avoided, as it also modifies the gain, which is useless
// and dangerous..
// int GetGainRXTX(array< int, 4>* RXgain, array<int,3>* TXgain) {
int GetGainRXTX(int *RXgain, int *TXgain) {
// RX gain: LNA, TIA and PGA
uint16_t gain_lna, gain_tia, gain_pga;
if (LMS_ReadParam(device, LMS7_G_LNA_RFE, &gain_lna) != 0)
error();
if (LMS_ReadParam(device, LMS7_G_TIA_RFE, &gain_tia) != 0)
error();
if (LMS_ReadParam(device, LMS7_G_PGA_RBB, &gain_pga) != 0)
error();
// convert to actual gain
// TX gain: PAD and TBB
uint16_t gain_pad, gain_tbb;
if (LMS_ReadParam(device, LMS7_LOSS_LIN_TXPAD_TRF, &gain_pad) != 0)
error();
if (LMS_ReadParam(device, LMS7_CG_IAMP_TBB, &gain_tbb) != 0)
error();
// convert to actual gain
// TXpad
const int pmax = 52;
if (gain_pad > 10)
TXgain[1] = pmax - 10 - 2 * (gain_pad - 10);
else
TXgain[1] = pmax - gain_pad;
// TBB gain: linear to dB. Impossible to obtain like this. It is calibrated to
// an optimum value, called opt_gain_tbb. This is only available if a
// calibration is done. However, as long as the TXgain is below 43+12 = 55 dB,
// gain is fully determined by TX PAD
TXgain[2] = gain_tbb;
// TXgain[2] = 20.0*log10((float_type)gain_tbb / (float_type) opt_gain_tbb);
// from LMS7002.cpp
// RFE LNA
int gmax = 30;
if (gain_lna >= 9)
RXgain[1] = gmax + (gain_lna - 15);
else
RXgain[1] = gmax + 3 * (gain_lna - 11);
// RFE TIA
gmax = 12;
switch (gain_tia) {
case 3:
RXgain[2] = gmax - 0;
break;
case 2:
RXgain[2] = gmax - 3;
break;
case 1:
RXgain[2] = gmax - 12;
break;
}
// RBB PGA
RXgain[3] = gain_pga - 12;
// Sum to first element, adding that mysterious +12+0.5 as it is done in the
// API
RXgain[0] = RXgain[1] + RXgain[2] + RXgain[3] + 12 + 0.5;
TXgain[0] = TXgain[1] + 0 * TXgain[2] + 12 + 0.5;
// Print in function to ease debugging
cout << "TX: " << TXgain[0] << " dB : " << TXgain[1] << " dB PAD, "
<< TXgain[2] << " setting of BB + 12 dB" << endl;
cout << "RX: " << RXgain[0] << " dB : " << RXgain[1] << " dB LNA, "
<< RXgain[2] << " dB TIA, " << RXgain[3] << " dB PGA + 12 dB" << endl;
return 0;
}
int main(int argc, char **argv) {
const double pi = acos(-1);
LimeConfig_t LimeCfg;
LimeCfg.Npulses = 2; // Number of pulses, default value
// check if nPulses has been given as argument, so that all the arrays are
// initialized with proper size
for (int ii_arg = 1; ii_arg < argc; ii_arg++) {
if (strcmp(argv[ii_arg], "-npu") == 0 && ii_arg + 1 < argc) {
LimeCfg.Npulses = atoi(argv[ii_arg + 1]);
break;
}
}
// ----------------------------------------------------------------------------------
// set all the DEFAULT parameters. Command line arguments allow for
// modification!
LimeCfg.srate = 30.72e6; // sample rate of the IF DAC/ADC
LimeCfg.frq = 50e6; // LO carrier frequency
LimeCfg.RX_gain = 20; // total gain of the receiver
LimeCfg.TX_gain = 30; // total gain of the transmitter
LimeCfg.RX_LPF = 5e6; // IF lowpass of the receiver
LimeCfg.TX_LPF = 130e6; // IF lowpass of the transmitter
LimeCfg.TX_IcorrDC =
-32; // DC corr to TX mixer at IF (evaluate with LimeSuiteGUI)
LimeCfg.TX_QcorrDC = 50; // DC corr to TX mixer at IF
// Allocate the arrays with pulse parametes
LimeCfg.p_dur = new double[LimeCfg.Npulses]; // pulse duration (secs)
LimeCfg.p_offs = new int[LimeCfg.Npulses]; // pulse time offset
LimeCfg.p_amp = new double[LimeCfg.Npulses]; // pulse digital IF amplitude
LimeCfg.p_frq =
new double[LimeCfg.Npulses]; // pulse digital IF frequency (unit: Hz)
LimeCfg.p_pha = new double[LimeCfg.Npulses]; // pulse digital IF phase
LimeCfg.p_phacyc_N =
new int[LimeCfg.Npulses]; // number of pulse phases (cycled within 2*pi,
// must be at least 1)
LimeCfg.p_phacyc_lev =
new int[LimeCfg.Npulses]; // stacking level of phase cycle (for eventual
// coupling)
LimeCfg.p_c0_en = new int[LimeCfg.Npulses]; // pulse-wise enable of marker c0
LimeCfg.p_c1_en = new int[LimeCfg.Npulses]; // pulse-wise enable of marker c1
LimeCfg.p_c2_en = new int[LimeCfg.Npulses]; // pulse-wise enable of marker c2
LimeCfg.p_c3_en = new int[LimeCfg.Npulses]; // pulse-wise enable of marker c3
// and set standard values
for (int ii = 0; ii < LimeCfg.Npulses; ii++) {
LimeCfg.p_dur[ii] = 2e-6;
LimeCfg.p_offs[ii] =
(4080 * 3) /
(LimeCfg.Npulses + 1); // distribute them evenly within the buffer...
LimeCfg.p_amp[ii] = 1.0;
LimeCfg.p_frq[ii] = 4.0 / LimeCfg.p_dur[0];
LimeCfg.p_pha[ii] = 0.0;
LimeCfg.p_phacyc_N[ii] = 1;
LimeCfg.p_phacyc_lev[ii] = 0;
LimeCfg.p_c0_en[ii] = 1;
LimeCfg.p_c1_en[ii] = 1;
LimeCfg.p_c2_en[ii] = 1;
LimeCfg.p_c3_en[ii] = 1;
}
// Timing of TTL controls: [enabled? , pre, offs, post]
int c0_tim[4] = {0, 70, 56, -5};
int c1_tim[4] = {0, 70, 56, -5};
int c2_tim[4] = {0, 70, 56, -5};
int c3_tim[4] = {0, 70, 56, -5};
// Use TTL channel as synth: [enabled? , half-period, strt, PSK shift, PSK
// adv]
int c0_synth[5] = {0, 500, 0, 0, 0};
int c1_synth[5] = {0, 500, 0, 0, 0};
int c2_synth[5] = {0, 500, 0, 0, 0};
int c3_synth[5] = {0, 500, 0, 0, 0};
LimeCfg.averages = 6; // number of averages
LimeCfg.repetitions = 4; // number of repetions
LimeCfg.reptime_secs = 4e-3; // repetition time
LimeCfg.rectime_secs = 0.2e-3; // duration of acquisition window
LimeCfg.buffersize = 4080 * 3; // number of samples in buffer
LimeCfg.pcyc_bef_avg = 0; // phase cycle before average
LimeCfg.file_pattern = "test"; // identifier when saving the file
LimeCfg.save_path = "./asdf/"; // path to save the file to
LimeCfg.override_save = 0; // default: save data
// that's it for the parameters
// ----------------------------------------------------------------------------------
// .. copy here those arrays ...
memcpy(LimeCfg.c0_tim, c0_tim, 4 * sizeof *LimeCfg.c0_tim);
memcpy(LimeCfg.c1_tim, c1_tim, 4 * sizeof *LimeCfg.c1_tim);
memcpy(LimeCfg.c2_tim, c2_tim, 4 * sizeof *LimeCfg.c2_tim);
memcpy(LimeCfg.c3_tim, c3_tim, 4 * sizeof *LimeCfg.c3_tim);
memcpy(LimeCfg.c0_synth, c0_synth, 5 * sizeof *LimeCfg.c0_synth);
memcpy(LimeCfg.c1_synth, c1_synth, 5 * sizeof *LimeCfg.c1_synth);
memcpy(LimeCfg.c2_synth, c2_synth, 5 * sizeof *LimeCfg.c2_synth);
memcpy(LimeCfg.c3_synth, c3_synth, 5 * sizeof *LimeCfg.c3_synth);
// and add the timestamp for the file
auto now = std::chrono::system_clock::now();
auto itt = std::chrono::system_clock::to_time_t(now);
std::ostringstream stringstream;
stringstream << std::put_time(localtime(&itt), "%G%m%d_%H%M%S");
LimeCfg.file_stamp = stringstream.str();
LimeCfg.stamp_start = stringstream.str();
LimeCfg.stamp_end =
stringstream.str(); // will be overwritten just before data is written
// allocate other variables that depend on Npulses
LimeCfg.p_dur_smp = new int[LimeCfg.Npulses];
LimeCfg.p_frq_smp = new double[LimeCfg.Npulses];
// LimeCfg as attributes for writing to HDF and for parsing command line input
// This is all done 'manually', since there is no reflection in cpp.. at least
// not by default
struct Config2HDFattr_t HDFattr[] = {
{"sra", "SampleRate [Hz]", H5::PredType::IEEE_F32LE, &LimeCfg.srate, 1},
{"lof", "LO Frequency [Hz]", H5::PredType::IEEE_F32LE, &LimeCfg.frq, 1},
{"rlp", "RX LowPass BW [Hz]", H5::PredType::IEEE_F32LE, &LimeCfg.RX_LPF,
1},
{"tlp", "TX LowPass BW [Hz]", H5::PredType::IEEE_F32LE, &LimeCfg.TX_LPF,
1},
{"rgn", "RX Gain [dB]", H5::PredType::NATIVE_INT, &LimeCfg.RX_gain, 1},
{"tgn", "TX Gain [dB]", H5::PredType::NATIVE_INT, &LimeCfg.TX_gain, 1},
{"///", "RX Gain readback [dB]", H5::PredType::NATIVE_INT,
&LimeCfg.RX_gain_rback, 4},
{"///", "TX Gain readback [dB]", H5::PredType::NATIVE_INT,
&LimeCfg.TX_gain_rback, 3},
{"tdq", "TX DC-correction Q", H5::PredType::NATIVE_INT,
&LimeCfg.TX_QcorrDC, 1},
{"tdi", "TX DC-correction I", H5::PredType::NATIVE_INT,
&LimeCfg.TX_IcorrDC, 1},
{"npu", "Number of Pulses", H5::PredType::NATIVE_INT, &LimeCfg.Npulses,
1},
{"pdr", "Pulse Duration [s]", H5::PredType::IEEE_F64LE, LimeCfg.p_dur,
(hsize_t)LimeCfg.Npulses},
{"pof", "Pulse Offset [Sa]", H5::PredType::NATIVE_INT, LimeCfg.p_offs,
(hsize_t)LimeCfg.Npulses},
{"pam", "IF Pulse Amplitude", H5::PredType::IEEE_F64LE, LimeCfg.p_amp,
(hsize_t)LimeCfg.Npulses},
{"pfr", "IF Pulse Frequency [Hz]", H5::PredType::IEEE_F64LE,
LimeCfg.p_frq, (hsize_t)LimeCfg.Npulses},
{"pph", "IF Pulse Phase", H5::PredType::IEEE_F64LE, LimeCfg.p_pha,
(hsize_t)LimeCfg.Npulses},
{"pcn", "Nmbr of Phasecycles", H5::PredType::NATIVE_INT,
LimeCfg.p_phacyc_N, (hsize_t)LimeCfg.Npulses},
{"pcl", "Level of Phasecycle", H5::PredType::NATIVE_INT,
LimeCfg.p_phacyc_lev, (hsize_t)LimeCfg.Npulses},
{"///", "Pulse Duration [Sa]", H5::PredType::NATIVE_INT,
LimeCfg.p_dur_smp, (hsize_t)LimeCfg.Npulses},
{"///", "IF Pulse Frequency [1/Sa]", H5::PredType::IEEE_F64LE,
LimeCfg.p_frq_smp, (hsize_t)LimeCfg.Npulses},
{"t0d", "Trigger0 Timing [Sa]", H5::PredType::NATIVE_INT, &LimeCfg.c0_tim,
4},
{"t1d", "Trigger1 Timing [Sa]", H5::PredType::NATIVE_INT, &LimeCfg.c1_tim,
4},
{"t2d", "Trigger2 Timing [Sa]", H5::PredType::NATIVE_INT, &LimeCfg.c2_tim,
4},
{"t3d", "Trigger3 Timing [Sa]", H5::PredType::NATIVE_INT, &LimeCfg.c3_tim,
4},
{"t0s", "Trigger0 Synth [Sa]", H5::PredType::NATIVE_INT,
&LimeCfg.c0_synth, 5},
{"t1s", "Trigger1 Synth [Sa]", H5::PredType::NATIVE_INT,
&LimeCfg.c1_synth, 5},
{"t2s", "Trigger2 Synth [Sa]", H5::PredType::NATIVE_INT,
&LimeCfg.c2_synth, 5},
{"t3s", "Trigger3 Synth [Sa]", H5::PredType::NATIVE_INT,
&LimeCfg.c3_synth, 5},
{"t0p", "Trigger0 Enable", H5::PredType::NATIVE_INT, LimeCfg.p_c0_en,
(hsize_t)LimeCfg.Npulses},
{"t1p", "Trigger1 Enable", H5::PredType::NATIVE_INT, LimeCfg.p_c1_en,
(hsize_t)LimeCfg.Npulses},
{"t2p", "Trigger2 Enable", H5::PredType::NATIVE_INT, LimeCfg.p_c2_en,
(hsize_t)LimeCfg.Npulses},
{"t3p", "Trigger3 Enable", H5::PredType::NATIVE_INT, LimeCfg.p_c3_en,
(hsize_t)LimeCfg.Npulses},
{"nrp", "Nmbr of Repetitions", H5::PredType::NATIVE_INT,
&LimeCfg.repetitions, 1},
{"nav", "Nmbr of Averages", H5::PredType::NATIVE_INT, &LimeCfg.averages,
1},
{"trp", "Repetition Time [s]", H5::PredType::IEEE_F64LE,
&LimeCfg.reptime_secs, 1},
{"tac", "Acquisition Time [s]", H5::PredType::IEEE_F64LE,
&LimeCfg.rectime_secs, 1},
{"///", "Repetition Time [Sa]", H5::PredType::NATIVE_INT,
&LimeCfg.reptime_smps, 1},
{"///", "Acquisition Time [Sa]", H5::PredType::NATIVE_INT,
&LimeCfg.rectime_smps, 1},
{"bsz", "Buffersize", H5::PredType::NATIVE_INT, &LimeCfg.buffersize, 1},
{"pba", "Pcyc before Avg if >0", H5::PredType::NATIVE_INT,
&LimeCfg.pcyc_bef_avg, 1},
{"fpa", "Filename Pattern",
H5::StrType(H5::PredType::C_S1, LimeCfg.file_pattern.length() + 1),
(void *)LimeCfg.file_pattern.c_str(), 1},
{"spt", "Save Path",
H5::StrType(H5::PredType::C_S1, LimeCfg.save_path.length() + 1),
(void *)LimeCfg.save_path.c_str(), 1},
{"nos", "Don't save if >0", H5::PredType::NATIVE_INT,
&LimeCfg.override_save, 1},
{"fst", "Filename Timestamp",
H5::StrType(H5::PredType::C_S1, LimeCfg.file_stamp.length() + 1),
(void *)LimeCfg.file_stamp.c_str(), 1},
{"///", "Exp Start Timestamp",
H5::StrType(H5::PredType::C_S1, LimeCfg.stamp_start.length() + 1),
(void *)LimeCfg.stamp_start.c_str(), 1},
{"///", "Exp End Timestamp",
H5::StrType(H5::PredType::C_S1, LimeCfg.stamp_end.length() + 1),
(void *)LimeCfg.stamp_end.c_str(), 1}};
int no_of_attr = sizeof(HDFattr) / sizeof(Config2HDFattr_t);
// iterate through arguments to parse eventual user input
// (exposing the actual content of the struct to python would be nicer...)
bool parse_prob = false;
int curr_attr = -1;
int curr_attr_last = -1;
int attr2read = 0;
int attr2read_last = 0;
int attr_read = 0;
for (int ii_arg = 1; ii_arg < argc; ii_arg++) {
// get the attribute for the argument based on '-' (which also is there for
// negative numbers..)
if (argv[ii_arg][0] == '-') {
if ((strlen(argv[ii_arg] + 1) != 3) && (attr2read == 0)) {
cout << "Invalid argument " << ii_arg << ": " << argv[ii_arg] << endl;
parse_prob = true;
continue;
}
// find matching attribute
curr_attr_last = curr_attr;
attr2read_last = attr2read;
curr_attr = -1;
for (int ii_attr = 0; ii_attr < no_of_attr; ii_attr++) {
if (strcmp(argv[ii_arg] + 1, HDFattr[ii_attr].arg.c_str()) == 0) {
curr_attr = ii_attr;
attr2read = HDFattr[ii_attr].dim;
attr_read = 0;
cout << "Found argument " << HDFattr[curr_attr].arg << ": "
<< HDFattr[curr_attr].Name << endl;
}
}
// found nothing
if (curr_attr == -1 && attr2read_last == 0) {
cout << "Could not find valid attribute for argument " << ii_arg << ": "
<< argv[ii_arg] << endl;
parse_prob = true;
// found something, but did not read the previous arguments
} else if (curr_attr > -1 && attr2read_last > 0) {
cout << "Missing argument: " << attr2read_last
<< " value missing for argument " << HDFattr[curr_attr_last].arg
<< endl;
parse_prob = true;
}
// found nothing and did not read the previous arguments: a negative
// number
if (curr_attr == -1 && attr2read_last > 0) {
// restore the attribute and it as number
curr_attr = curr_attr_last;
attr2read = attr2read_last;
} else
// all other cases: jump to the next argument
continue;
}
// parse the value from the current attribute
if (curr_attr != -1 && attr2read != 0) {
// differentiate between the different types of input based on the
// H5::DataType float values
if (HDFattr[curr_attr].dType == H5::PredType::IEEE_F32LE) {
*((float *)HDFattr[curr_attr].Value + attr_read) = atof(argv[ii_arg]);
attr2read--;
attr_read++;
// cout << "Got value " << atof(argv[ii_arg]) << " from " <<
// argv[ii_arg] << endl;
}
// double values
if (HDFattr[curr_attr].dType == H5::PredType::IEEE_F64LE) {
*((double *)HDFattr[curr_attr].Value + attr_read) =
(double)atof(argv[ii_arg]);
attr2read--;
attr_read++;
// cout << "Got value " << (double) atof(argv[ii_arg]) << " from " <<
// argv[ii_arg] << endl;
}
// integer values
if (HDFattr[curr_attr].dType == H5::PredType::NATIVE_INT) {
*((int *)HDFattr[curr_attr].Value + attr_read) = atoi(argv[ii_arg]);
attr2read--;
attr_read++;
// cout << "Got value " << atoi(argv[ii_arg]) << " from " <<
// argv[ii_arg] << endl;
}
// strings: stored as std::string in LimeCfg and as Cstring in HDFattr..
// --> explicitly treat strings, these are anyhow just a few for file/path
// info
if (strcmp(HDFattr[curr_attr].arg.c_str(), "spt") == 0) {
LimeCfg.save_path = argv[ii_arg];
HDFattr[curr_attr].dType =
H5::StrType(H5::PredType::C_S1, LimeCfg.save_path.length() + 1);
HDFattr[curr_attr].Value = (void *)LimeCfg.save_path.c_str();
attr2read--;
attr_read++;
}
if (strcmp(HDFattr[curr_attr].arg.c_str(), "fpa") == 0) {
LimeCfg.file_pattern = argv[ii_arg];
HDFattr[curr_attr].dType =
H5::StrType(H5::PredType::C_S1, LimeCfg.file_pattern.length() + 1);
HDFattr[curr_attr].Value = (void *)LimeCfg.file_pattern.c_str();
attr2read--;
attr_read++;
}
if (strcmp(HDFattr[curr_attr].arg.c_str(), "fst") == 0) {
LimeCfg.file_stamp = argv[ii_arg];
HDFattr[curr_attr].dType =
H5::StrType(H5::PredType::C_S1, LimeCfg.file_stamp.length() + 1);
HDFattr[curr_attr].Value = (void *)LimeCfg.file_stamp.c_str();
attr2read--;
attr_read++;
}
} else if (attr2read == 0) {
cout << "Problem with argument " << HDFattr[curr_attr].arg
<< ": There is an input that is not clear, probably one input more "
"than required! "
<< endl;
parse_prob = true;
}
}
// check if the last argument had all the values
if (attr2read > 0) {
cout << "Missing argument: " << attr2read << " value missing for argument "
<< HDFattr[curr_attr].arg << endl;
parse_prob = true;
}
if (parse_prob) {
cout << "Exiting due to problem with provided arguments! Valid arguments "
"are (exept -///, which cannot be set by the user):"
<< endl;
string datatype;
for (int ii_attr = 0; ii_attr < no_of_attr; ii_attr++) {
// get the datatype
if (HDFattr[ii_attr].dType == H5::PredType::IEEE_F32LE)
datatype = "float";
else if (HDFattr[ii_attr].dType == H5::PredType::IEEE_F64LE)
datatype = "double";
else if (HDFattr[ii_attr].dType == H5::PredType::NATIVE_INT)
datatype = "int";
else
datatype = "string";
cout << "-" << HDFattr[ii_attr].arg << " " << left << setw(30)
<< HDFattr[ii_attr].Name << ": " << HDFattr[ii_attr].dim << "x "
<< datatype << endl;
}
return 1;
}
// convert input in seconds/Hz to samples
for (int ii = 0; ii < LimeCfg.Npulses; ii++) {
LimeCfg.p_dur_smp[ii] = round(LimeCfg.p_dur[ii] * LimeCfg.srate);
LimeCfg.p_frq_smp[ii] = LimeCfg.p_frq[ii] / LimeCfg.srate;
}
// check directory first
if (makePath(LimeCfg.save_path) == 0) {
cout << "Problem entering the specified path: " << LimeCfg.save_path
<< endl;
return 1;
}
// Find devices
int n;
lms_info_str_t list[8]; // should be large enough to hold all detected devices
if ((n = LMS_GetDeviceList(list)) <
0) // NULL can be passed to only get number of devices
error();
cout << "Devices found: " << n << endl; // print number of devices
if (n < 1)
return -1;
// open the first device
if (LMS_Open(&device, list[0], NULL))
error();
/*
//print available antennae names
//select antenna port
lms_name_t antenna_list[10]; //large enough list for antenna names.
//Alternatively, NULL can be passed to LMS_GetAntennaList() to obtain
number of antennae if ((n = LMS_GetAntennaList(device, LMS_CH_RX, 0,
antenna_list)) < 0) error();
// get and print antenna index and name
if ((n = LMS_GetAntenna(device, LMS_CH_RX, 0)) < 0) error();
cout << "Automatically selected RX LNA: " << n << ": " <<
antenna_list[n] << endl;
*/
// Get number of channels
if ((n = LMS_GetNumChannels(device, LMS_CH_RX)) < 0)
error();
cout << "Number of RX channels: " << n << endl;
if ((n = LMS_GetNumChannels(device, LMS_CH_TX)) < 0)
error();
cout << "Number of TX channels: " << n << endl;
// check if the settings are already there
float_type frq_read;
if (LMS_GetLOFrequency(device, LMS_CH_RX, 0, &frq_read) != 0)
error();
float_type srate_read, rf_rate;
if (LMS_GetSampleRate(device, LMS_CH_RX, 0, &srate_read, &rf_rate) != 0)
error();
bool frqdev = fabs(frq_read - LimeCfg.frq) > 1.0;
bool sratedev = fabs(srate_read - LimeCfg.srate) > 1.0;
// Getting the gain
int RXgain[4];
int TXgain[3];
GetGainRXTX(RXgain, TXgain);
bool rgndev = RXgain[0] != LimeCfg.RX_gain;
bool tgndev = TXgain[0] != LimeCfg.TX_gain;
if (TXgain[0] > 55 && LimeCfg.TX_gain > 55) {
tgndev = false;
cout << "Unable to check for variation in TXgain setting, since it is "
"impossible to retrieve it for TXgain > 55 dB without altering the "
"RF performance. Eventual changes in the TXgain are thus not taken "
"into account."
<< endl;
}
/*
// Similar as with the built in GetGaindB function, the GetLPFBW function is
also affecting the actual reading of the LPF. It is actually not entirely
clear why this happens, as compared to the GetGaindB function, where it is
evident that some calibration is done..
// Accordingly, one must take care that the LPFBW is set right at the
beginning when opening the device float_type LPFBW, LPFBW2; // lowpass
bandwidth if (LMS_GetLPFBW(device, LMS_CH_RX, 0, &LPFBW) != 0) error(); bool
rlpfdev = LPFBW != LimeCfg.RX_LPF; if (LMS_GetLPFBW(device, LMS_CH_TX, 0,
&LPFBW2) != 0) error(); bool tlpfdev = LPFBW2 != LimeCfg.TX_LPF;
*/
// initialize if the frequency is different
// if (frqdev || sratedev || tgndev || rgndev || rlpfdev || tlpfdev || true) {
if (frqdev || sratedev || tgndev || rgndev) {
// just to re-assure why there is another setup
cout << "Re-initialization of parameters ... " << endl;
if (frqdev)
cout << "... due to LOfrequency deviation by " << frq_read - LimeCfg.frq
<< " from " << LimeCfg.frq << endl;
if (sratedev)
cout << "... due to samplerate deviation by "
<< srate_read - LimeCfg.srate << " from " << LimeCfg.srate << endl;
if (rgndev)
cout << "... due to RX gain deviation by " << RXgain[0] - LimeCfg.RX_gain
<< " from " << LimeCfg.RX_gain << endl;
if (tgndev)
cout << "... due to TX gain deviation by " << TXgain[0] - LimeCfg.TX_gain
<< " from " << LimeCfg.TX_gain << endl;
// if (rlpfdev) cout << "... due to RX LPF deviation by " << LPFBW -
// LimeCfg.RX_LPF << " from " << LimeCfg.RX_LPF << endl; if (tlpfdev) cout
// << "... due to TX LPF deviation by " << LPFBW2 - LimeCfg.TX_LPF << " from
// " << LimeCfg.TX_LPF << endl;
// First mute the TX output, as the init commands create a lot of garbage
if (LMS_WriteParam(device, LMS7_PD_TLOBUF_TRF, 1) != 0)
error();
if (LMS_SetGaindB(device, LMS_CH_TX, 0, 0) != 0) {
cout << "Initializing device first!" << endl;
// this might fail for a freshly connected device
// --> init the device
if (LMS_Init(device) != 0)
error();
// retry
if (LMS_SetGaindB(device, LMS_CH_TX, 0, 0) != 0)
error();
}
if (LMS_SetNormalizedGain(device, LMS_CH_TX, 0, 0.0) != 0)
error();
// Set RX center frequency
if (LMS_SetLOFrequency(device, LMS_CH_RX, 0, LimeCfg.frq) != 0)
error();
// Set TX center frequency
if (LMS_SetLOFrequency(device, LMS_CH_TX, 0, LimeCfg.frq) != 0)
error();
// Read back the updated frequency for later storage
if (LMS_GetLOFrequency(device, LMS_CH_RX, 0, &frq_read) != 0)
error();
// Enable RX channel
// Channels are numbered starting at 0
if (LMS_EnableChannel(device, LMS_CH_RX, 0, true) != 0)
error();
// Enable TX channels
if (LMS_EnableChannel(device, LMS_CH_TX, 0, true) != 0)
error();
// apply DC offset in TxTSP
uint16_t DC_I, DC_Q, DC_EN;
DC_EN = 0;
if (LMS_WriteParam(device, LMS7_DCCORRI_TXTSP, LimeCfg.TX_IcorrDC) != 0)
error();
if (LMS_WriteParam(device, LMS7_DCCORRQ_TXTSP, LimeCfg.TX_QcorrDC) != 0)
error();
if (LMS_WriteParam(device, LMS7_DC_BYP_TXTSP, DC_EN) != 0)
error();
/*
// read back DC offset in TxTSP
if (LMS_ReadParam(device, LMS7_DCCORRI_TXTSP, &DC_I) != 0) error();
if (LMS_ReadParam(device, LMS7_DCCORRQ_TXTSP, &DC_Q) != 0) error();
if (LMS_ReadParam(device, LMS7_DC_BYP_TXTSP, &DC_EN) != 0) error();
cout << "TxTSP DC corr (EN, I, Q): " << DC_EN << ", " << DC_I << ", " <<
DC_Q << endl;
*/
// print available antennae names
// select antenna port
lms_name_t antenna_list[10]; // large enough list for antenna names.
// Alternatively, NULL can be passed to LMS_GetAntennaList() to obtain
// number of antennae
if ((n = LMS_GetAntennaList(device, LMS_CH_RX, 0, antenna_list)) < 0)
error();
cout << "Available RX LNAs:\n"; // print available antennae names
for (int i = 0; i < n; i++)
cout << i << ": " << antenna_list[i] << endl;
// get and print antenna index and name
if ((n = LMS_GetAntenna(device, LMS_CH_RX, 0)) < 0)
error();
cout << "Automatically selected RX LNA: " << n << ": " << antenna_list[n]
<< endl;
// manually select antenna
if (LMS_SetAntenna(device, LMS_CH_RX, 0, LMS_PATH_LNAL) != 0)
error();
// get and print antenna index and name
if ((n = LMS_GetAntenna(device, LMS_CH_RX, 0)) < 0)
error();
cout << "Manually selected RX LNA: " << n << ": " << antenna_list[n]
<< endl;
// select antenna port
// Alternatively, NULL can be passed to LMS_GetAntennaList() to obtain
// number of antennae
if ((n = LMS_GetAntennaList(device, LMS_CH_TX, 0, antenna_list)) < 0)
error();
cout << "Available TX pathways:\n"; // print available antennae names
for (int i = 0; i < n; i++)
cout << i << ": " << antenna_list[i] << endl;
// get and print print antenna index and name
if ((n = LMS_GetAntenna(device, LMS_CH_TX, 0)) < 0)
error();
cout << "Automatically selected TX pathway: " << n << ": "
<< antenna_list[n] << endl;
// manually select antenna
int mychoice = LMS_PATH_TX1;
if (LimeCfg.frq > 1500e6)
mychoice = LMS_PATH_TX2;
if (LMS_SetAntenna(device, LMS_CH_TX, 0, mychoice) != 0)
error();
// get and print print antenna index and name
if ((n = LMS_GetAntenna(device, LMS_CH_TX, 0)) < 0)
error();
cout << "Manually selected TX pathway: " << n << ": " << antenna_list[n]
<< endl;
// Set sample rate, w/o oversampling, so that we can remove the invsinc
// filter
if (LMS_SetSampleRate(device, LimeCfg.srate, 1) != 0)
error();
// Invsinc, which removes that non-causal wiggle in timedomain
if (LMS_WriteParam(device, LMS7_ISINC_BYP_TXTSP, 1) != 0)
error();
// CMIX: Disable, as it is not used
if (LMS_WriteParam(device, LMS7_CMIX_BYP_TXTSP, 1) != 0)
error();
if (LMS_WriteParam(device, LMS7_CMIX_BYP_RXTSP, 1) != 0)
error();
// experiment with the GFIR filters
// if (LMS_SetGFIRLPF(device, LMS_CH_RX, 0, 1, 0.5e6) != 0) error(); //
// Works nicely. Allows, for instance, to perform narrowband observation
// together with CMIX
// Remute the TX output here, as the init commands create a lot of garbage
if (LMS_WriteParam(device, LMS7_PD_TLOBUF_TRF, 1) != 0)
error();
// Set RX and TX to the gain values
if (LMS_SetGaindB(device, LMS_CH_TX, 0, LimeCfg.TX_gain) != 0)
error();
if (LMS_SetGaindB(device, LMS_CH_RX, 0, LimeCfg.RX_gain) != 0)
error();
cout << "After gain setting: " << endl;
GetGainRXTX(RXgain, TXgain);
// special for low frequency operation: LNA gain saturates rather early ->
// reduce lna gain and increase pga ( and even though we have that function
// GetGainRXTX(), we need to re-read the values here explicitly, since
// we need to operate on the actual settings of the LMS Parameter, and not
// the gain values )
uint16_t gain_lna, gain_tia, gain_pga;
if (LMS_ReadParam(device, LMS7_G_LNA_RFE, &gain_lna) != 0)
error();
if (LMS_ReadParam(device, LMS7_G_TIA_RFE, &gain_tia) != 0)
error();
if (LMS_ReadParam(device, LMS7_G_PGA_RBB, &gain_pga) != 0)
error();
// cout << "Indiv gain addr: " << gain_lna << " LNA, " << gain_tia << " TIA,
// " << gain_pga << " PGA" << endl; gain_lna > 7 means a gain beyond
// gmax-12. Convert that to gains in dB
uint16_t crit_val = 7;
uint16_t gain_corr = (gain_lna - crit_val);
if (gain_corr > 2)
gain_corr += 4; // gain steps of 1 dB for gain_lna > 9
else
gain_corr *= 3; // gain steps of 3 dB for gain_lna <= 9
// eventually put this to the pga gain
if (gain_corr > 0) {
if (LMS_WriteParam(device, LMS7_G_LNA_RFE, crit_val) != 0)
error();
if (LMS_WriteParam(device, LMS7_G_PGA_RBB, gain_pga + gain_corr) != 0)
error();
}
GetGainRXTX(RXgain, TXgain);
// Get allowed LPF bandwidth range
lms_range_t range;
if (LMS_GetLPFBWRange(device, LMS_CH_RX, &range) != 0)
error();
cout << "RX LPF bandwitdh range: " << range.min / 1e6 << " - "
<< range.max / 1e6 << " MHz\n\n";
if (LMS_GetLPFBWRange(device, LMS_CH_TX, &range) != 0)
error();
cout << "TX LPF bandwitdh range: " << range.min / 1e6 << " - "
<< range.max / 1e6 << " MHz\n\n";
if (LMS_SetLPFBW(device, LMS_CH_RX, 0, LimeCfg.RX_LPF) != 0)
error();
if (LMS_SetLPFBW(device, LMS_CH_TX, 0, LimeCfg.TX_LPF) != 0)
error();
float_type LPFBW; // lowpass bandwidth
if (LMS_GetLPFBW(device, LMS_CH_RX, 0, &LPFBW) != 0)
error();
cout << "RX LPFBW: " << LPFBW / 1e6 << " MHz" << endl;
if (LMS_GetLPFBW(device, LMS_CH_TX, 0, &LPFBW) != 0)
error();
cout << "TX LPFBW: " << LPFBW / 1e6 << " MHz" << endl;
// Set limelight interface to TRXIQ, as the std value (JESD) will not
// communicate
if (LMS_WriteParam(device, LMS7_LML1_MODE, 0) != 0)
error();
if (LMS_WriteParam(device, LMS7_LML2_MODE, 0) != 0)
error();
// Unmute the TX output, as the init commands are now written
if (LMS_WriteParam(device, LMS7_PD_TLOBUF_TRF, 0) != 0)
error();
}
// read back values that tend to depend on the specific configuration
memcpy(LimeCfg.TX_gain_rback, TXgain, 3 * sizeof *LimeCfg.TX_gain_rback);
memcpy(LimeCfg.RX_gain_rback, RXgain, 4 * sizeof *LimeCfg.RX_gain_rback);
const int chCount = 1; // number of RX/TX streams
// Initialize acquisition data buffer
int buffersize = LimeCfg.buffersize; // complex samples per buffer
// note that proper scheduling requires buffersize that is a multiple of 1360
// (12bit RX) and 1020 (16bit TX) accordingly, buffersize needs to be a
// multiple of 4080, which is 3*1360 and 4*1020
if (buffersize % 4080 != 0) {
cout << "Problem with requested buffersize of " << LimeCfg.buffersize
<< ", as it is not a multiple of 4080." << endl;
LMS_Close(device);
return 1;
}
int timestampOffset = 0; // for offsets between TX and RX timestamps
int bufferOffset = 0; // to correct for those offsets
int16_t *buffers[chCount];
for (int ii = 0; ii < chCount; ++ii) {
buffers[ii] = new int16_t[buffersize *
2]; // buffer to hold complex values (2*samples)
}
// Streaming Setup
lms_stream_t rx_streams[chCount];
lms_stream_t tx_streams[chCount];
int N_buffers_per_fifo =
96; // Number of buffers that can be put onto the fifo
// Initialize streams
// All streams setups should be done before starting streams. New streams
// cannot be set-up if at least stream is running.
for (int ii = 0; ii < chCount; ++ii) {
rx_streams[ii].channel = ii; // channel number
rx_streams[ii].fifoSize =
buffersize * N_buffers_per_fifo; // fifo size in samples
rx_streams[ii].throughputVsLatency = 0.5; // some middle ground
rx_streams[ii].isTx = false; // RX channel
rx_streams[ii].dataFmt = lms_stream_t::LMS_FMT_I12; // 12-bit integers
if (LMS_SetupStream(device, &rx_streams[ii]) != 0)
error();
tx_streams[ii].channel = ii; // channel number
tx_streams[ii].fifoSize =
buffersize * N_buffers_per_fifo; // fifo size in samples
tx_streams[ii].throughputVsLatency = 0.5; // some middle ground
tx_streams[ii].isTx = true; // TX channel
tx_streams[ii].dataFmt = lms_stream_t::LMS_FMT_I16; // 16-bit float
if (LMS_SetupStream(device, &tx_streams[ii]) != 0)
error();
}
// gather parameters for the TX pulse
// first get all the phase-cycles
// which at first requires few maximum quantities....
// .... the number of levels ...
int max_lev = 0;
for (int ii_pls = 0; ii_pls < LimeCfg.Npulses; ii_pls++)
if (LimeCfg.p_phacyc_lev[ii_pls] > max_lev)
max_lev = LimeCfg.p_phacyc_lev[ii_pls];
// check if there are no gaps in the level specification
bool found_level[max_lev + 1];
bool level_problem = false;
for (int ii = 0; ii < max_lev + 1; ii++) {
found_level[ii] = false;
for (int ii_pls = 0; ii_pls < LimeCfg.Npulses; ii_pls++)
if (LimeCfg.p_phacyc_lev[ii_pls] == ii)
found_level[ii] = true;
if (!found_level[ii])
level_problem = true;
}
if (level_problem) {
cout << "Problem with specified phase cycle levels: ";
for (int ii_pls = 0; ii_pls < LimeCfg.Npulses; ii_pls++)
cout << setw(5) << left << LimeCfg.p_phacyc_lev[ii_pls];
cout << endl;
cout << "A consecutive level numbering is required, but level/s ";
for (int ii = 0; ii < max_lev + 1; ii++)
if (!found_level[ii])
cout << setw(2) << left << ii;
cout << " is/are missing!" << endl;
LMS_Close(device);
return 1;
}
// ... the maximum number of phase cycles per level ...
int *steps_per_lev = new int[max_lev + 1];
for (int ii = 0; ii < max_lev + 1; ii++)
steps_per_lev[ii] = 0;
int curr_lev_steps; // to make the code more readable...
for (int ii = 0; ii < LimeCfg.Npulses; ii++) {
curr_lev_steps = steps_per_lev[LimeCfg.p_phacyc_lev[ii]];
if (LimeCfg.p_phacyc_N[ii] > curr_lev_steps)
steps_per_lev[LimeCfg.p_phacyc_lev[ii]] = LimeCfg.p_phacyc_N[ii];
}
// ... which gives the total number of phase variations ...
int num_phavar = 1;
int steps_incr[max_lev + 1] = {
1}; // .. and the number of steps where phase is constant ...
for (int ii = 0; ii < max_lev + 1; ii++) {
if (ii > 0)
steps_incr[ii] = steps_incr[ii - 1] * steps_per_lev[ii - 1];
num_phavar *= steps_per_lev[ii];
}
// ... which allows to construct the entire phase table ...
double pha_tab[num_phavar][LimeCfg.Npulses];
double pha_incr, curr_pha;
int step_incr = 1;
for (int ii_pls = 0; ii_pls < LimeCfg.Npulses; ii_pls++) {
// retrieve the phase increment
if (LimeCfg.p_phacyc_N[ii_pls] != 0)
pha_incr = 1.0 / LimeCfg.p_phacyc_N[ii_pls];
else
pha_incr = 1.0;
curr_pha = 0;
// get the step increment
step_incr = steps_incr[LimeCfg.p_phacyc_lev[ii_pls]];
// start to fill the table
for (int ii_pha = 0; ii_pha < num_phavar; ii_pha++) {
// eventually increment the phase
if ((ii_pha > 0) && (ii_pha % step_incr == 0))
curr_pha += pha_incr;
pha_tab[ii_pha][ii_pls] = fmod(curr_pha, 1.0);
}
}
// debug: print that phase table
cout << "Phase Table : " << endl;
for (int ii_pha = 0; ii_pha < num_phavar; ii_pha++) {
for (int ii_pls = 0; ii_pls < LimeCfg.Npulses; ii_pls++) {
cout << setw(10) << left << pha_tab[ii_pha][ii_pls];
}
cout << endl;
}
// get the number of buffers that are required in order to fit the entire
// experiment
long exc_len = 0;
int exc_buffers;
int pulsedur, pulseoffs;
pulseoffs = 0;
for (int ii_pls = 0; ii_pls < LimeCfg.Npulses; ii_pls++) {
pulsedur = LimeCfg.p_dur_smp[ii_pls]; // duration of pulse in samples
pulseoffs += LimeCfg.p_offs[ii_pls]; // offset of pulse in samples
if (pulseoffs + pulsedur > exc_len)
exc_len = pulseoffs + pulsedur;
}
exc_buffers = ceil((double)exc_len / (double)buffersize);
cout << "Exc_len " << exc_len << " and buffersize " << buffersize << endl;
cout << "A total of " << exc_buffers
<< " excitation buffers is required to fit the experiment" << endl;
// TX buffers
// int16_t tx_buffer[num_phavar][exc_buffers][2*buffersize]; // buffer to
// hold complex values (2* samples), including phase cycles
// TODO: put in the same way as the acq buffer, i.e. as an array of pointers.
// Otherwise, there is a limitation in space that can be used
int16_t *tx_buffer[num_phavar][exc_buffers];
for (int ii = 0; ii < num_phavar; ++ii) {
for (int jj = 0; jj < exc_buffers; ++jj) {
tx_buffer[ii][jj] = new int16_t[2 * buffersize];
}
}
int16_t tx_buffer_1st[2 * buffersize]; // buffer to hold complex values
float fsmpI, fsmpQ;
int16_t smpI, smpQ;
// init with zero, as we add to it
for (int ii = 0; ii < 2 * buffersize; ii++) {
for (int jj = 0; jj < exc_buffers; jj++) {
for (int ll = 0; ll < num_phavar; ll++)
tx_buffer[ll][jj][ii] = 0;
}
}
// pulse parameters
double pulsefrq, pulseamp, pulsepha;
double w;
int buffoffs;
pulseoffs = 0;
for (int ii_pls = 0; ii_pls < LimeCfg.Npulses; ii_pls++) {
pulsedur = LimeCfg.p_dur_smp[ii_pls]; // duration of pulse in samples
pulseoffs += LimeCfg.p_offs[ii_pls]; // offset of pulse in samples
pulsefrq = LimeCfg.p_frq_smp[ii_pls]; // frequency of pulse in samples
pulseamp = LimeCfg.p_amp[ii_pls]; // relative amplitude of pulses
pulsepha = LimeCfg.p_pha[ii_pls]; // phase of pulse
for (int ll = 0; ll < num_phavar;
ll++) { // generate TX Pulse for different phases
buffoffs = 0;
for (int jj = 0; jj < exc_buffers;
jj++) { // distribute 'long experiment' amongst buffers
for (int ii = 0; ii < buffersize;
ii++) { // generate TX Pulse point by point
if ((ii + buffoffs >= pulseoffs) &
(ii + buffoffs < pulsedur + pulseoffs)) {
w = 2 * pi * (ii + buffoffs) * pulsefrq; // frequency*time
w = 2 * pi * (ii - pulseoffs) *
pulsefrq; // re-put absolute phase, which is better suited for
// pulsed experiments. The inclusion of buffoffs above
// was actually intended for CW type experiments,
// which were put separately in CW_AFC_engine.
fsmpI = pulseamp * cos(w + pulsepha + 2 * pi * pha_tab[ll][ii_pls]);
fsmpQ = pulseamp * sin(w + pulsepha + 2 * pi * pha_tab[ll][ii_pls]);
// convert to int16 ...
smpI = 2047.0 * fsmpI;
smpQ = 2047.0 * fsmpQ;
// ... with 4 LSB at 0 for marker
if (tx_streams[0].dataFmt == lms_stream_t::LMS_FMT_I16) {
smpI = smpI << 4;
smpQ = smpQ << 4;
}
// add to buffer
tx_buffer[ll][jj][2 * ii] += smpI;
tx_buffer[ll][jj][2 * ii + 1] += smpQ;
} else {
// fsmpI = 0.0;
// fsmpQ = 0.0;
}
}
buffoffs += buffersize; // jump to next buffer
}
}
// Pulse Marker for timing relative to pulse flanks
// TODO: we might need some gate joining and one should also warn if the
// triggers do not fit into the buffer
if (tx_streams[0].dataFmt == lms_stream_t::LMS_FMT_I16) {
int *curr_marker;
int *curr_marker_en;
// marker channel for that offset
for (int ii_c = 0; ii_c < 4;
ii_c++) { // iterate through the four marker channels
// get the proper configuration of the trigger channel
switch (ii_c) {
case 0:
curr_marker = LimeCfg.c0_tim;
curr_marker_en = LimeCfg.p_c0_en;
break;
case 1:
curr_marker = LimeCfg.c1_tim;
curr_marker_en = LimeCfg.p_c1_en;
break;
case 2:
curr_marker = LimeCfg.c2_tim;
curr_marker_en = LimeCfg.p_c2_en;
break;
case 3:
curr_marker = LimeCfg.c3_tim;
curr_marker_en = LimeCfg.p_c3_en;
break;
default:
break;
}
// check if the channel is activated
if (curr_marker[0] == 0 || curr_marker_en[ii_pls] == 0)
continue;
// set trigger with bitset operation
for (int ll = 0; ll < num_phavar; ll++) {
buffoffs = 0;
for (int jj = 0; jj < exc_buffers;
jj++) { // distribute 'long experiment' amongst buffers
for (int ii = 0; ii < 2 * buffersize;
ii++) { // set trigger point by point
if ((ii + buffoffs >=
2 * pulseoffs + curr_marker[2] - curr_marker[1]) &
(ii + buffoffs < 2 * pulsedur + 2 * pulseoffs +
curr_marker[2] + curr_marker[3])) {
tx_buffer[ll][jj][ii] |= 1 << ii_c;
}
}
buffoffs += 2 * buffersize; // jump to next buffer
}
}
}
}
}
// Synth Marker for CW sync stuff
// Use TTL channel as synth: [enabled? , half-period, strt, PSK shift, PSK
// adv]
int synthstart = 0;
int wrapped_phase = 0;
if (tx_streams[0].dataFmt == lms_stream_t::LMS_FMT_I16) {
int *curr_synth;
// marker channel for that offset
for (int ii_c = 0; ii_c < 4;
ii_c++) { // iterate through the four marker channels
// get the proper configuration of the trigger channel
switch (ii_c) {
case 0:
curr_synth = LimeCfg.c0_synth;
break;
case 1:
curr_synth = LimeCfg.c1_synth;
break;
case 2:
curr_synth = LimeCfg.c2_synth;
break;
case 3:
curr_synth = LimeCfg.c3_synth;
break;
default:
break;
}
cout << curr_synth[1] << endl;
// check if the channel is activated
if (curr_synth[0] == 0)
continue;
// set trigger with bitset operation
synthstart = curr_synth[2];
for (int ll = 0; ll < num_phavar; ll++) {
buffoffs = 0;
// eventually advance the synth coupled to the phase cycle
if (curr_synth[4] > 0) {
if ((ll % curr_synth[4]) == 0)
synthstart += curr_synth[3];
}
for (int jj = 0; jj < exc_buffers;
jj++) { // distribute 'long experiment' amongst buffers
for (int ii = 0; ii < 2 * buffersize;
ii++) { // set trigger point by point
// wrap the phase counter
wrapped_phase =
int(int(ii + buffoffs + synthstart) % int(2 * curr_synth[1]));
// wrapped_phase = 0;
// test = (wrapped_phase < curr_synth[1]);
if (wrapped_phase < curr_synth[1]) {
tx_buffer[ll][jj][ii] |= 1 << ii_c;
}
}
buffoffs += 2 * buffersize; // jump to next buffer
}
}
}
}
// generate empty TX Pulse at beginning
for (int ii = 0; ii < buffersize; ii++) {
tx_buffer_1st[2 * ii] = 0.0;
tx_buffer_1st[2 * ii + 1] = 0.0;
}
// calculate the repetition and recording time in samples as mutliple of
// buffer size in this way, we do not need to do any exhaustive sample
// alignment strategies
long rep_offset, rec_len;
rep_offset = ceil(LimeCfg.reptime_secs * LimeCfg.srate / (double)buffersize) *
buffersize;
rec_len = ceil(LimeCfg.rectime_secs * LimeCfg.srate / (double)buffersize) *
buffersize;
// write back to LimeCfg so that these are stored in the file
LimeCfg.reptime_smps = rep_offset;
LimeCfg.rectime_smps = rec_len;
if (rec_len > rep_offset) {
cout << "Recording length of " << rec_len
<< " samples cannot be longer than repetition time (" << rep_offset
<< " Samples)" << endl;
error();
}
cout << "Rep and rectimes: " << rep_offset << ", " << rec_len << endl;
cout << "Rep and rectimes in bufperiods: " << rep_offset / buffersize << ", "
<< rec_len / buffersize << endl;
// Buffer for acqisition signal: integer datatype, so that we can have a
// sufficient number of averages of acquired 16 bit data into the 32 bit
// buffer for some reason, there are segfaults here when acqbuf_size becomes
// something on the order of 100
int acqbuf_size = LimeCfg.repetitions * num_phavar;
// int acqbuf[acqbuf_size][2*rec_len]; // causes segfaults with large
// arrays...
// init as non-contiguous memory (which will require writing as chunks to
// HDF5)
int *acqbuf[acqbuf_size];
for (int ii = 0; ii < acqbuf_size; ++ii) {
acqbuf[ii] = new int[2 * rec_len];
}
// brute-force initialization by zero ( memset(acqbuf, 0,
// acqbuf_size*2*rec_len); ) did not work...
for (int ii = 0; ii < acqbuf_size; ii++) {
for (int jj = 0; jj < 2 * rec_len; jj++) {
acqbuf[ii][jj] = 0;
}
}
// Streaming
lms_stream_meta_t rx_metadata; // Use metadata for additional control over
// sample receive function behavior
rx_metadata.flushPartialPacket = false; // currently has no effect in RX
rx_metadata.waitForTimestamp = false; // currently has no effect in RX
lms_stream_meta_t tx_metadata; // Use metadata for additional control over
// sample send function behavior
tx_metadata.flushPartialPacket =
false; // do not force sending of incomplete packet
tx_metadata.waitForTimestamp = true; // Enable synchronization to HW timestamp
lms_stream_status_t status; // To check the FIFO
// counters to keep track of the transmission FIFO
int TXFIFO_slots = N_buffers_per_fifo;
int ii_TXavg = 0;
int ii_TXpcyc = 0;
int ii_TXoffset = 0;
int ii_TXrep = 0;
int ii_sent = 0;
double init_delay_s = 10e-3; // delay in seconds until TX packets are
// forwarded from FPGA to the FPRF
long next_TXtimestamp =
ceil((init_delay_s * LimeCfg.srate) / (double)buffersize) * buffersize;
long last_TXtimestamp =
0; // this one stores the last timestamp of the beginning of a repetition
// Timestamps to schedule the acquisition
long next_RXtimestamp = 0;
long last_RXtimestamp = 0;
// Acquisition loop
auto t1 = chrono::high_resolution_clock::now();
auto t2 = t1;
int samplesRead;
int samplesReadSum = 0;
int rcvattempts = 0;
int ii_rep = 0; // number of repetions
int ii_pcyc = 0; // number of phase cycle
int ii_avg = 0; // number of averages
int ii_acq = 0; // number of complete acquisitions
int samples2Acquire =
0; // number of samples to acquire in current acquisition
int validSamples = 0; // number of valid samples in current datapacket
int *acqbuf_pos; // pointer to acqbuffer
int *delayedacqbuf_pos; // pointer to acqbuffer for delayed fwd
bool acquiring = false; // RX stream to acqbuffer?
bool acquire = true; // disable one single acquisition in acq loop
bool delayedAcqbufFwd = false; // to delay the forwarding of the acqbuffer
int ndebug = 100;
// Start streaming
for (int i = 0; i < chCount; ++i) {
LMS_StartStream(&rx_streams[i]);
LMS_StartStream(&tx_streams[i]);
}
// pre-fill the TX fifo
for (int ii_TXbuff = 0; ii_TXbuff < N_buffers_per_fifo; ii_TXbuff++) {
// save the TX timestamp to the current packet
tx_metadata.timestamp = next_TXtimestamp;
// First packet is special, since it is cut off in some weird way
if (ii_TXbuff == 0) {
LMS_SendStream(&tx_streams[0], tx_buffer_1st, buffersize, &tx_metadata,
1000); // so we put zeros
TXFIFO_slots--;
// advance TX timestamp for the next packet
next_TXtimestamp += rep_offset;
next_RXtimestamp = next_TXtimestamp; // ... and do not wait for it
last_TXtimestamp = next_TXtimestamp;
continue; // proceed the for loop with the first actual TX packet
}
// Put data to FIFO
LMS_SendStream(&tx_streams[0], tx_buffer[ii_TXpcyc][ii_TXoffset],
buffersize, &tx_metadata, 1000);
// Update TX FIFO counters
TXFIFO_slots--;
ii_sent++;
// advance the tx_buffer counter
ii_TXoffset++;
next_TXtimestamp += buffersize;
if (ii_TXoffset == exc_buffers) {
ii_TXoffset = 0;
next_TXtimestamp = last_TXtimestamp + rep_offset;
last_TXtimestamp = next_TXtimestamp;
if (LimeCfg.pcyc_bef_avg > 0) {
ii_TXpcyc++;
if (ii_TXpcyc == num_phavar) {
ii_TXpcyc = 0;
ii_TXavg++;
if (ii_TXavg == LimeCfg.averages) {
ii_TXavg = 0;
ii_TXrep++;
// in case the entire experiment fits within the TX FIFO
if (ii_TXrep == LimeCfg.repetitions)
break;
}
}
} else {
ii_TXavg++;
if (ii_TXavg == LimeCfg.averages) {
ii_TXavg = 0;
ii_TXpcyc++;
if (ii_TXpcyc == num_phavar) {
ii_TXpcyc = 0;
ii_TXrep++;
// in case the entire experiment fits within the TX FIFO
if (ii_TXrep == LimeCfg.repetitions)
break;
}
}
}
} else {
// if there is still data to be put on the buffer
}
}
/*
// Check for the TX buffer and keep it filled
LMS_GetStreamStatus(tx_streams, &status); //Obtain TX stream stats
if (status.fifoFilledCount != 0) cout << TXFIFO_slots <<" TXFIFO slots
free before start: " << status.fifoFilledCount << " samples of " <<
status.fifoSize << " with HW stamp " << status.timestamp <<" at RX
timestamp" << rx_metadata.timestamp << endl;
*/
// Main acquisition loop
while (ii_acq < LimeCfg.repetitions * LimeCfg.averages * num_phavar) {
// Receive samples
if (acquire) {
samplesRead = LMS_RecvStream(&rx_streams[0], buffers[0], buffersize,
&rx_metadata, 1000);
rcvattempts++;
samplesReadSum += samplesRead;
}
if (ndebug < 10) {
cout << rx_metadata.timestamp << ", " << samplesReadSum << endl;
ndebug++;
LMS_GetStreamStatus(rx_streams, &status); // Obtain RX stream stats
cout << "Rx stream info: " << status.overrun << ", " << status.underrun
<< status.droppedPackets << ", " << status.overrun << ", actually "
<< status.fifoFilledCount << endl;
}
// check if the scheduled timestamp is coming here
// if (rx_metadata.timestamp >= next_RXtimestamp) {
if ((rx_metadata.timestamp >= next_RXtimestamp - samplesRead + 1) &&
acquire) {
// Advance acqbuf in case that there is not an ongoing acquisition (just
// in the case of gap-free acquisition, that has usually a timestamp
// offset)
if (acquiring == false) {
acqbuf_pos = acqbuf[ii_rep * num_phavar + ii_pcyc];
samples2Acquire = rec_len;
} else {
delayedacqbuf_pos = acqbuf[ii_rep * num_phavar + ii_pcyc];
delayedAcqbufFwd = true;
}
acquiring = true;
// advance counters
if (LimeCfg.pcyc_bef_avg > 0) {
ii_pcyc++;
if (ii_pcyc == num_phavar) {
ii_pcyc = 0;
ii_avg++;
if (ii_avg == LimeCfg.averages) {
ii_avg = 0;
ii_rep++;
}
}
} else {
ii_avg++;
if (ii_avg == LimeCfg.averages) {
ii_avg = 0;
ii_pcyc++;
if (ii_pcyc == num_phavar) {
ii_pcyc = 0;
ii_rep++;
}
}
}
// store the offset
timestampOffset =
(signed long)next_RXtimestamp - (signed long)rx_metadata.timestamp;
// Important debug message in general, will however only be printed in
// case the offset gets positive (which will inevidably run into a
// segfault and is related to a too fast samplingrate combined with a too
// small rectime_secs)
if (timestampOffset < 0) {
cout << "Next acq: rep " << ii_rep << ", avg " << ii_avg << ", pcyc "
<< ii_pcyc << " : sched/act tstamp: " << next_RXtimestamp << ", "
<< rx_metadata.timestamp
<< " Diff to last: " << next_RXtimestamp - last_RXtimestamp
<< " Offset: "
<< (signed long)rx_metadata.timestamp -
(signed long)next_RXtimestamp
<< " currently processing " << samplesRead
<< " RX samples with delayed fwd " << delayedAcqbufFwd << endl;
}
// advance to the forthcoming RX timestamp and keep the current one
next_RXtimestamp += rep_offset;
last_RXtimestamp = rx_metadata.timestamp;
}
acquire = true;
// copy RX data into acquisition buffer
if (acquiring) {
// standard case: copy everything, without offset
bufferOffset = 0;
validSamples = buffersize;
// first packet: consider eventual timestamp offset
if (samples2Acquire == rec_len) {
bufferOffset = timestampOffset;
validSamples = buffersize - bufferOffset;
// last packet with timestamp offset: just get the tail without offset
} else if (samples2Acquire < buffersize) {
validSamples = samples2Acquire;
}
for (int ii_acqbuf = 0; ii_acqbuf < 2 * (validSamples); ii_acqbuf++)
acqbuf_pos[ii_acqbuf] += (int)buffers[0][ii_acqbuf + 2 * bufferOffset];
samples2Acquire -= validSamples;
// advance position in acquisition buffer
acqbuf_pos += 2 * validSamples;
if (samples2Acquire == 0) {
ii_acq++;
// check for continuous RX with timestamp offset, where we would
// actually still have valid samples to copy in the buffer
if (delayedAcqbufFwd) {
// put pointer to right place
acqbuf_pos = delayedacqbuf_pos;
samples2Acquire = rec_len;
delayedAcqbufFwd = false;
// important: rerun this entire block without getting a new data or
// forwarding the timestamp packet. We still need to copy the part
// beyond the validsamples to the next acqbuf position
acquire = false;
} else {
// standard case: signal that the acquisition is finished and wait for
// the next scheduled timestamp
acquiring = false;
}
}
}
// Check for the TX buffer and keep it filled
if (ii_TXrep < LimeCfg.repetitions) {
LMS_GetStreamStatus(tx_streams, &status); // Obtain TX stream stats
TXFIFO_slots = (status.fifoSize - status.fifoFilledCount) / buffersize;
}
/*
// debug
if (TXFIFO_slots > 0) cout << TXFIFO_slots << " free fifo slots to fill" <<
endl;
*/
// re-fill the TX fifo
while (TXFIFO_slots > 0) {
// save the TX timestamp to the current packet
tx_metadata.timestamp = next_TXtimestamp;
// Put data to FIFO
LMS_SendStream(&tx_streams[0], tx_buffer[ii_TXpcyc][ii_TXoffset],
buffersize, &tx_metadata, 1000);
// Update TX counters
TXFIFO_slots--;
ii_sent++;
// advance the tx_buffer counter
ii_TXoffset++;
next_TXtimestamp += buffersize;
if (ii_TXoffset == exc_buffers) {
ii_TXoffset = 0;
next_TXtimestamp = last_TXtimestamp + rep_offset;
last_TXtimestamp = next_TXtimestamp;
if (LimeCfg.pcyc_bef_avg > 0) {
ii_TXpcyc++;
if (ii_TXpcyc == num_phavar) {
ii_TXpcyc = 0;
ii_TXavg++;
if (ii_TXavg == LimeCfg.averages) {
ii_TXavg = 0;
ii_TXrep++;
// in case the experiment is finished
if (ii_TXrep == LimeCfg.repetitions)
;
TXFIFO_slots = 0;
}
}
} else {
ii_TXavg++;
if (ii_TXavg == LimeCfg.averages) {
ii_TXavg = 0;
ii_TXpcyc++;
if (ii_TXpcyc == num_phavar) {
ii_TXpcyc = 0;
ii_TXrep++;
// in case the experiment is finished
if (ii_TXrep == LimeCfg.repetitions)
TXFIFO_slots = 0;
}
}
}
}
}
}
// Stop streaming
for (int i = 0; i < chCount; ++i) {
LMS_StopStream(&rx_streams[i]); // stream is stopped but can be started
// again with LMS_StartStream()
LMS_StopStream(&tx_streams[i]);
}
for (int i = 0; i < chCount; ++i) {
LMS_DestroyStream(
device,
&rx_streams[i]); // stream is deallocated and can no longer be used
LMS_DestroyStream(device, &tx_streams[i]);
delete[] buffers[i];
}
//-------------------------------------------------------------------------------------
// SAVE TO HDF5
//-------------------------------------------------------------------------------------
if (LimeCfg.override_save == 0) {
// Open HDF5 file
string filename;
// check for save_path delimiter
if (LimeCfg.save_path.back() == '/')
filename = LimeCfg.save_path + LimeCfg.file_stamp + "_" +
LimeCfg.file_pattern + ".h5";
else
filename = LimeCfg.save_path + '/' + LimeCfg.file_stamp + "_" +
LimeCfg.file_pattern + ".h5";
cout << filename << endl;
H5::H5File *h5f;
// create or open
if (file_exists(filename))
h5f = new H5::H5File(filename, H5F_ACC_RDWR);
else
h5f = new H5::H5File(filename, H5F_ACC_EXCL);
// Check for the number of datasets already in there (only >0 if an external
// file_stamp is provided or if the program is called more than once within
// a second..)
hsize_t num_obj = 0;
H5Gget_num_objs(h5f->getId(),
&num_obj); // if success, num_obj will be assigned the
// number of objects in the group
// write dataset to HDF5 file
// 1. specify datatype and dimensions and dataset name
H5::DataType saveDataType(H5::PredType::NATIVE_INT);
hsize_t saveDataDim[] = {(hsize_t)acqbuf_size, (hsize_t)2 * rec_len};
string DataName = "Acqbuf_";
std::ostringstream oss;
oss << setfill('0') << setw(2) << num_obj;
DataName += oss.str();
H5std_string saveDataName(DataName.c_str());
// 2. allocate dataspace and init
// set parameters to have a chunked file, so that each acquired trace is one
// chunk
H5::DSetCreatPropList cparms;
hsize_t chunk_dims[2] = {1, saveDataDim[1]};
cparms.setChunk(2, chunk_dims);
int fill_val = 0;
cparms.setFillValue(H5::PredType::NATIVE_INT, &fill_val);
H5::DataSpace mspace1(2, saveDataDim);
H5::DataSet dataset =
h5f->createDataSet(saveDataName, saveDataType, mspace1, cparms);
// write with standard procedure
// dataset.write( acqbuf, saveDataType); // requires contiguous memory of
// the entire acqbuf, which does not work for large buffers
// write row-wise
H5::DataSpace fspace_row = dataset.getSpace();
hsize_t offset[2] = {0, 0};
hsize_t dims_row[2] = {1, saveDataDim[1]};
H5::DataSpace mspace_row(
1, &saveDataDim[1]); // contiguous memory space of data to write
for (int ii = 0; ii < acqbuf_size; ii++) {
fspace_row.selectHyperslab(H5S_SELECT_SET, dims_row, offset);
dataset.write(acqbuf[ii], saveDataType, mspace_row, fspace_row);
offset[0] += 1; // advance to next row
}
// get the timestamp at the end of the experiment ...
now = std::chrono::system_clock::now();
itt = std::chrono::system_clock::to_time_t(now);
stringstream.str("");
stringstream.clear();
stringstream << std::put_time(localtime(&itt), "%G%m%d_%H%M%S");
// ... and write it to the appropriate index
for (int ii_attr = 0; ii_attr < no_of_attr; ii_attr++) {
if (strcmp("Exp End Timestamp", HDFattr[ii_attr].Name.c_str()) == 0) {
LimeCfg.stamp_end = stringstream.str();
HDFattr[ii_attr].dType =
H5::StrType(H5::PredType::C_S1, LimeCfg.stamp_end.length() + 1);
HDFattr[ii_attr].Value = (void *)LimeCfg.stamp_end.c_str();
}
}
// write the attributes
for (int ii = 0; ii < no_of_attr; ii++) {
H5::DataSpace *tmpSpace = new H5::DataSpace();
// special case: arrays
if (HDFattr[ii].dim > 1) {
delete tmpSpace;
H5::DataSpace *tmpSpace = new H5::DataSpace(1, &HDFattr[ii].dim);
}
H5std_string concat("-" + HDFattr[ii].arg + " " + HDFattr[ii].Name);
// H5::Attribute attribute = h5f->createAttribute(concat,
// HDFattr[ii].dType, *tmpSpace); // write the attribute to the file
H5::Attribute attribute = dataset.createAttribute(
concat, HDFattr[ii].dType,
*tmpSpace); // write the attribute to the dataset
attribute.write(HDFattr[ii].dType, HDFattr[ii].Value);
delete tmpSpace;
}
// special attribute for N pulses: the phase table, which is certainly of
// use in evaluation
hsize_t phatab_len = LimeCfg.Npulses * num_phavar;
H5::DataSpace *tmpSpace = new H5::DataSpace(1, &phatab_len);
H5std_string concat("-/// Phase Table");
H5::Attribute attribute = dataset.createAttribute(
concat, H5::PredType::IEEE_F64LE,
*tmpSpace); // write the attribute to the dataset
attribute.write(H5::PredType::IEEE_F64LE, &pha_tab);
delete tmpSpace;
// close file
h5f->close();
delete h5f;
cout << "Written to HDFfile as " << saveDataDim[0] << " by "
<< saveDataDim[1] << " array" << endl;
}
// Close device
LMS_Close(device);
return 0;
}
Reference in a new issue View git blame Copy permalink