int main(int argc, char **argv) {
parse_args(argc, argv);
srslte_prach_t *p = (srslte_prach_t*)malloc(sizeof(srslte_prach_t));
bool high_speed_flag = false;
cf_t preamble[MAX_LEN];
memset(preamble, 0, sizeof(cf_t)*MAX_LEN);
cf_t preamble_sum[MAX_LEN];
memset(preamble_sum, 0, sizeof(cf_t)*MAX_LEN);
srslte_prach_init(p,
N_ifft_ul,
preamble_format,
root_seq_idx,
high_speed_flag,
zero_corr_zone);
uint32_t seq_index = 0;
uint32_t frequency_offset = 0;
uint32_t indices[64];
uint32_t n_indices = 0;
for(int i=0;i<64;i++)
indices[i] = 0;
for(seq_index=0;seq_index<n_seqs;seq_index++)
{
srslte_prach_gen(p,
seq_index,
frequency_offset,
preamble);
for(int i=0;i<p->N_cp+p->N_seq;i++)
{
preamble_sum[i] += preamble[i];
}
}
uint32_t prach_len = p->N_seq;
if(preamble_format == 2 || preamble_format == 3)
prach_len /= 2;
srslte_prach_detect(p, 0, &preamble_sum[p->N_cp], prach_len, indices, &n_indices);
if(n_indices != n_seqs)
return -1;
for(int i=0;i<n_seqs;i++)
{
if(indices[i] != i)
return -1;
}
srslte_prach_free(p);
free(p);
printf("Done\n");
exit(0);
}
int srslte_prach_init_cfg(srslte_prach_t *p, srslte_prach_cfg_t *cfg, uint32_t nof_prb)
{
return srslte_prach_init(p,
srslte_symbol_sz(nof_prb),
cfg->config_idx,
cfg->root_seq_idx,
cfg->hs_flag,
cfg->zero_corr_zone);
}
int main(int argc, char** argv)
{
parse_args(argc, argv);
srslte_prach_t prach;
bool high_speed_flag = false;
cf_t preamble[MAX_LEN];
memset(preamble, 0, sizeof(cf_t)*MAX_LEN);
srslte_prach_cfg_t prach_cfg;
ZERO_OBJECT(prach_cfg);
prach_cfg.config_idx = config_idx;
prach_cfg.hs_flag = high_speed_flag;
prach_cfg.freq_offset = 0;
prach_cfg.root_seq_idx = root_seq_idx;
prach_cfg.zero_corr_zone = zero_corr_zone;
if (srslte_prach_init(&prach, srslte_symbol_sz(nof_prb))) {
return -1;
}
if (srslte_prach_set_cfg(&prach, &prach_cfg, nof_prb)) {
ERROR("Error initiating PRACH object\n");
return -1;
}
uint32_t seq_index = 0;
uint32_t indices[64];
uint32_t n_indices = 0;
for(int i=0;i<64;i++)
indices[i] = 0;
for(seq_index=0;seq_index<64;seq_index++)
{
srslte_prach_gen(&prach, seq_index, 0, preamble);
uint32_t prach_len = prach.N_seq;
struct timeval t[3];
gettimeofday(&t[1], NULL);
srslte_prach_detect(&prach, 0, &preamble[prach.N_cp], prach_len, indices, &n_indices);
gettimeofday(&t[2], NULL);
get_time_interval(t);
printf("texec=%ld us\n", t[0].tv_usec);
if(n_indices != 1 || indices[0] != seq_index)
return -1;
}
srslte_prach_free(&prach);
srslte_dft_exit();
printf("Done\n");
exit(0);
}
int main(int argc, char** argv)
{
parse_args(argc, argv);
srslte_prach_t prach;
bool high_speed_flag = false;
cf_t preamble[MAX_LEN];
memset(preamble, 0, sizeof(cf_t)*MAX_LEN);
cf_t preamble_sum[MAX_LEN];
memset(preamble_sum, 0, sizeof(cf_t)*MAX_LEN);
srslte_prach_cfg_t prach_cfg;
ZERO_OBJECT(prach_cfg);
prach_cfg.config_idx = preamble_format;
prach_cfg.hs_flag = high_speed_flag;
prach_cfg.freq_offset = 0;
prach_cfg.root_seq_idx = root_seq_idx;
prach_cfg.zero_corr_zone = zero_corr_zone;
if (srslte_prach_init(&prach, srslte_symbol_sz(nof_prb))) {
return -1;
}
if (srslte_prach_set_cfg(&prach, &prach_cfg, nof_prb)) {
ERROR("Error initiating PRACH object\n");
return -1;
}
uint32_t seq_index = 0;
uint32_t frequency_offset = 0;
uint32_t indices[64];
uint32_t n_indices = 0;
for(int i=0;i<64;i++)
indices[i] = 0;
srslte_prach_set_detect_factor(&prach, 10);
for(seq_index=0;seq_index<n_seqs;seq_index++)
{
srslte_prach_gen(&prach, seq_index, frequency_offset, preamble);
for (int i = 0; i < prach.N_cp + prach.N_seq; i++) {
preamble_sum[i] += preamble[i];
}
}
uint32_t prach_len = prach.N_seq;
if (preamble_format == 2 || preamble_format == 3) {
prach_len /= 2;
}
srslte_prach_detect(&prach, 0, &preamble_sum[prach.N_cp], prach_len, indices, &n_indices);
if (n_indices != n_seqs) {
return -1;
}
for (int i = 0; i < n_seqs; i++) {
if (indices[i] != i) {
return -1;
}
}
srslte_prach_free(&prach);
srslte_dft_exit();
printf("Done\n");
exit(0);
}
int main(int argc, char **argv) {
parse_args(argc, argv);
srslte_prach_t *p = (srslte_prach_t*)malloc(sizeof(srslte_prach_t));
bool high_speed_flag = false;
cf_t preamble[MAX_LEN];
memset(preamble, 0, sizeof(cf_t)*MAX_LEN);
srslte_prach_init(p,
srslte_symbol_sz(nof_prb),
preamble_format,
root_seq_idx,
high_speed_flag,
zero_corr_zone);
uint32_t flen = srslte_sampling_freq_hz(nof_prb)/1000;
printf("Generating PRACH\n");
bzero(preamble, flen*sizeof(cf_t));
srslte_prach_gen(p,
seq_idx,
frequency_offset,
preamble);
uint32_t prach_len = p->N_seq;
srslte_vec_save_file("generated",preamble,prach_len*sizeof(cf_t));
cf_t *buffer = malloc(sizeof(cf_t)*flen*nof_frames);
// Send through UHD
void *uhd;
printf("Opening UHD device...\n");
if (cuhd_open(uhd_args, &uhd)) {
fprintf(stderr, "Error opening uhd\n");
exit(-1);
}
printf("Subframe len: %d samples\n", flen);
printf("Set TX/RX rate: %.2f MHz\n", cuhd_set_rx_srate(uhd, srslte_sampling_freq_hz(nof_prb)) / 1000000);
printf("Set RX gain: %.1f dB\n", cuhd_set_rx_gain(uhd, uhd_gain));
printf("Set TX gain: %.1f dB\n", cuhd_set_tx_gain(uhd, uhd_gain));
printf("Set TX/RX freq: %.2f MHz\n", cuhd_set_rx_freq(uhd, uhd_freq) / 1000000);
cuhd_set_tx_srate(uhd, srslte_sampling_freq_hz(nof_prb));
cuhd_set_tx_freq_offset(uhd, uhd_freq, 8e6);
sleep(1);
cf_t *zeros = calloc(sizeof(cf_t),flen);
FILE *f = NULL;
if (output_filename) {
f = fopen(output_filename, "w");
}
srslte_timestamp_t tstamp;
cuhd_start_rx_stream(uhd);
uint32_t nframe=0;
while(nframe<nof_frames) {
printf("Rx subframe %d\n", nframe);
cuhd_recv_with_time(uhd, &buffer[flen*nframe], flen, true, &tstamp.full_secs, &tstamp.frac_secs);
nframe++;
if (nframe==9 || nframe==8) {
srslte_timestamp_add(&tstamp, 0, 2e-3);
if (nframe==8) {
cuhd_send_timed2(uhd, zeros, flen, tstamp.full_secs, tstamp.frac_secs, true, false);
printf("Transmitting zeros\n");
} else {
cuhd_send_timed2(uhd, preamble, flen, tstamp.full_secs, tstamp.frac_secs, true, true);
printf("Transmitting PRACH\n");
}
}
}
if (f) {
fwrite(&buffer[10*flen], flen*sizeof(cf_t), 1, f);
}
if (f) {
fclose(f);
}
srslte_prach_free(p);
free(p);
printf("Done\n");
exit(0);
}
/* the gateway function */
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if (nrhs != NOF_INPUTS) {
help();
return;
}
uint32_t n_ul_rb = 0;
if (mexutils_read_uint32_struct(UECFG, "NULRB", &n_ul_rb)) {
mexErrMsgTxt("Field NULRB not found in UE config\n");
return;
}
int r = srslte_symbol_sz(n_ul_rb);
if (r < 0) {
mexErrMsgTxt("Invalid NULRB\n");
return;
}
uint32_t N_ifft_ul = (uint32_t) r;
uint32_t sf_idx = 0;
mexutils_read_uint32_struct(UECFG, "NSubframe", &sf_idx);
uint32_t nframe = 0;
mexutils_read_uint32_struct(UECFG, "NFrame", &nframe);
uint32_t preamble_format = 0;
mexutils_read_uint32_struct(PRACHCFG, "Format", &preamble_format);
uint32_t root_seq_idx = 0;
mexutils_read_uint32_struct(PRACHCFG, "SeqIdx", &root_seq_idx);
uint32_t seq_idx = 0;
mexutils_read_uint32_struct(PRACHCFG, "PreambleIdx", &seq_idx);
uint32_t zero_corr_zone = 0;
mexutils_read_uint32_struct(PRACHCFG, "CyclicShiftIdx", &zero_corr_zone);
uint32_t high_speed_flag = 0;
mexutils_read_uint32_struct(PRACHCFG, "HighSpeed", &high_speed_flag);
uint32_t timing_offset = 0;
mexutils_read_uint32_struct(PRACHCFG, "TimingOffset", &timing_offset);
uint32_t frequency_offset = 0;
mexutils_read_uint32_struct(PRACHCFG, "FreqOffset", &frequency_offset);
srslte_prach_t prach;
if (srslte_prach_init(&prach, N_ifft_ul, preamble_format, root_seq_idx, high_speed_flag, zero_corr_zone)) {
mexErrMsgTxt("Error initiating PRACH\n");
return;
}
uint32_t nof_samples = srslte_sampling_freq_hz(n_ul_rb) * 0.001;
cf_t *signal = srslte_vec_malloc(sizeof(cf_t) * nof_samples);
if (!signal) {
mexErrMsgTxt("malloc");
return;
}
bzero(signal, sizeof(cf_t) * nof_samples);
if (srslte_prach_gen(&prach, seq_idx, frequency_offset, signal)) {
mexErrMsgTxt("Error generating PRACH\n");
return;
}
srslte_vec_sc_prod_cfc(signal, 1.0/sqrtf(N_ifft_ul), signal, nof_samples);
if (nlhs >= 0) {
mexutils_write_cf(signal, &plhs[0], nof_samples, 1);
}
free(signal);
srslte_prach_free(&prach);
return;
}
