PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- adding simple successive cancellation to PRACH detection 

- adding testing for same and for offset detection
This commit is contained in:
yagoda 2020-05-26 12:38:54 +02:00 committed by Justin Tallon
parent 1bd3e76f98
commit 4d8888aae6
3 changed files with 238 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lib/include/srslte/phy/phch/prach.h
View File

@ -71,7 +71,7 @@ typedef struct SRSLTE_API {
cf_t dft_seqs[64][839]; // DFT-precoded seqs
uint32_t root_seqs_idx[64]; // Indices of root seqs in seqs table
uint32_t N_roots; // Number of root sequences used in this configuration
cf_t* td_signals[64];
// Containers
cf_t* ifft_in;
cf_t* ifft_out;
@ -94,6 +94,7 @@ typedef struct SRSLTE_API {
float peak_values[65];
uint32_t peak_offsets[65];
uint32_t num_ra_preambles;
bool successive_cancellation;
srslte_tdd_config_t tdd_config;
uint32_t current_prach_idx;
@ -117,8 +118,15 @@ typedef struct {
uint32_t num_ra_preambles;
bool hs_flag;
srslte_tdd_config_t tdd_config;
bool enable_successive_cancellation;
} srslte_prach_cfg_t;
typedef struct {
int idx;
float offset;
float factor;
} srslte_prach_cancellation_t;
typedef struct SRSLTE_API {
uint32_t f;
uint32_t t0;

116
lib/src/phy/phch/prach.c
View File

@ -48,12 +48,7 @@ float save_corr[4096];
int srslte_prach_set_cell_(srslte_prach_t* p,
uint32_t N_ifft_ul,
uint32_t config_idx,
uint32_t root_seq_index,
bool high_speed_flag,
uint32_t zero_corr_zone_config,
srslte_tdd_config_t* tdd_config,
uint32_t num_ra_preambles);
srslte_prach_cfg_t* cfg);
uint32_t srslte_prach_get_preamble_format(uint32_t config_idx)
{
@ -331,12 +326,7 @@ int srslte_prach_set_cfg(srslte_prach_t* p, srslte_prach_cfg_t* cfg, uint32_t no
{
return srslte_prach_set_cell_(p,
srslte_symbol_sz(nof_prb),
cfg->config_idx,
cfg->root_seq_idx,
cfg->hs_flag,
cfg->zero_corr_zone,
&cfg->tdd_config,
cfg->num_ra_preambles);
cfg);
}
int srslte_prach_init(srslte_prach_t* p, uint32_t max_N_ifft_ul)
@ -400,30 +390,26 @@ int srslte_prach_init(srslte_prach_t* p, uint32_t max_N_ifft_ul)
int srslte_prach_set_cell_(srslte_prach_t* p,
uint32_t N_ifft_ul,
uint32_t config_idx,
uint32_t root_seq_index,
bool high_speed_flag,
uint32_t zero_corr_zone_config,
srslte_tdd_config_t* tdd_config,
uint32_t num_ra_preambles)
srslte_prach_cfg_t* cfg)
{
int ret = SRSLTE_ERROR;
if (p != NULL && N_ifft_ul < 2049 && config_idx < 64 && root_seq_index < MAX_ROOTS) {
if (p != NULL && N_ifft_ul < 2049 && cfg->config_idx < 64 && cfg->root_seq_idx < MAX_ROOTS) {
if (N_ifft_ul > p->max_N_ifft_ul) {
ERROR("PRACH: Error in set_cell(): N_ifft_ul must be lower or equal max_N_ifft_ul in init()\n");
return -1;
}
uint32_t preamble_format = srslte_prach_get_preamble_format(config_idx);
p->config_idx = config_idx;
uint32_t preamble_format = srslte_prach_get_preamble_format(cfg->config_idx);
p->config_idx = cfg->config_idx;
p->f = preamble_format;
p->rsi = root_seq_index;
p->hs = high_speed_flag;
p->zczc = zero_corr_zone_config;
p->rsi = cfg->root_seq_idx;
p->hs = cfg->hs_flag;
p->zczc = cfg->zero_corr_zone;
p->detect_factor = PRACH_DETECT_FACTOR;
p->num_ra_preambles = num_ra_preambles;
if (tdd_config) {
p->tdd_config = *tdd_config;
p->num_ra_preambles = cfg->num_ra_preambles;
p->successive_cancellation = cfg->enable_successive_cancellation;
if (&cfg->tdd_config) {
p->tdd_config = cfg->tdd_config;
}
// Determine N_zc and N_cs
@ -508,6 +494,11 @@ int srslte_prach_set_cell_(srslte_prach_t* p,
p->T_seq = prach_Tseq[p->f] * SRSLTE_LTE_TS;
p->T_tot = (prach_Tseq[p->f] + prach_Tcp[p->f]) * SRSLTE_LTE_TS;
if (p->successive_cancellation) {
for (int i = 0; i < 64; i++) {
p->td_signals[i] = srslte_vec_malloc(sizeof(cf_t) * (p->N_seq + p->N_cp));
}
}
ret = SRSLTE_SUCCESS;
} else {
ERROR("Invalid parameters\n");
@ -552,7 +543,9 @@ int srslte_prach_gen(srslte_prach_t* p, uint32_t seq_index, uint32_t freq_offset
for (int i = 0; i < p->N_seq; i++) {
signal[p->N_cp + i] = p->ifft_out[i % p->N_ifft_prach];
}
if (p->td_signals[seq_index]) {
memcpy(p->td_signals[seq_index], signal, (p->N_seq + p->N_cp)*sizeof(cf_t));
}
ret = SRSLTE_SUCCESS;
}
@ -573,6 +566,36 @@ int srslte_prach_detect(srslte_prach_t* p,
{
return srslte_prach_detect_offset(p, freq_offset, signal, sig_len, indices, NULL, NULL, n_indices);
}
void srslte_prach_cancellation (srslte_prach_t* p, cf_t *signal, uint32_t begin, int sig_len, srslte_prach_cancellation_t prach_cancel)
{
cf_t sub[sig_len];
memcpy(sub,&p->td_signals[p->root_seqs_idx[prach_cancel.idx]][p->N_cp], sig_len*sizeof(cf_t));
srslte_vec_sc_prod_cfc(sub, prach_cancel.factor, sub, p->N_seq);
int offset = (int) (prach_cancel.offset*sig_len*DELTA_F_RA);
srslte_vec_sub_ccc(&signal[offset], sub, &signal[offset], sig_len);
srslte_dft_run(&p->fft, signal, p->signal_fft);
memcpy(p->prach_bins, &p->signal_fft[begin], p->N_zc * sizeof(cf_t));
}
bool srslte_prach_have_stored(srslte_prach_t* p,int current_idx, uint32_t* indices, uint32_t n_indices) {
for(int i = 0; i < n_indices; i++) {
if (indices[i] == current_idx) {
return true;
}
}
return false;
}
float srslte_prach_set_offset(srslte_prach_t* p, int n_win) {
float corr = 1.0;
if (p->peak_offsets[n_win] > 30) {
corr = 1.9;
}
if (p->peak_offsets[n_win] > 250) {
corr = 1.91;
}
return corr * p->peak_offsets[n_win] / (DELTA_F_RA * p->N_zc);
}
int srslte_prach_detect_offset(srslte_prach_t* p,
uint32_t freq_offset,
@ -590,6 +613,8 @@ int srslte_prach_detect_offset(srslte_prach_t* p,
ERROR("srslte_prach_detect: Signal length is %d and should be %d\n", sig_len, p->N_ifft_prach);
return SRSLTE_ERROR_INVALID_INPUTS;
}
int cancellation_idx = -2;
srslte_prach_cancellation_t prach_cancel;
// FFT incoming signal
srslte_dft_run(&p->fft, signal, p->signal_fft);
@ -603,7 +628,10 @@ int srslte_prach_detect_offset(srslte_prach_t* p,
uint32_t begin = PHI + (K * k_0) + (K / 2);
memcpy(p->prach_bins, &p->signal_fft[begin], p->N_zc * sizeof(cf_t));
int loops = (p->successive_cancellation)?p->num_ra_preambles:1;
for (int l = 0; l < loops; l++) {
float max_to_cancel = 0;
cancellation_idx = -1;
for (int i = 0; i < p->num_ra_preambles; i++) {
cf_t* root_spec = p->dft_seqs[p->root_seqs_idx[i]];
@ -645,30 +673,38 @@ int srslte_prach_detect_offset(srslte_prach_t* p,
if (max_peak > p->detect_factor * corr_ave) {
for (int j = 0; j < n_wins; j++) {
if (p->peak_values[j] > p->detect_factor * corr_ave) {
// printf("saving prach correlation\n");
// memcpy(save_corr, p->corr, p->N_zc*sizeof(float));
if (indices) {
if (p->successive_cancellation) {
if (max_peak > max_to_cancel) {
cancellation_idx = (i * n_wins) + j;
max_to_cancel = max_peak;
prach_cancel.idx = cancellation_idx;
prach_cancel.offset = srslte_prach_set_offset(p,j);
prach_cancel.factor = sqrt((max_peak/2)/((sig_len/2)*p->N_zc*p->N_zc));
}
if (srslte_prach_have_stored(p,((i * n_wins) + j),indices, *n_indices)) {
break;
}
}
indices[*n_indices] = (i * n_wins) + j;
}
if (peak_to_avg) {
peak_to_avg[*n_indices] = p->peak_values[j] / corr_ave;
}
if (t_offsets) {
float corr = 1.8;
if (p->peak_offsets[j] > 30) {
corr = 1.9;
}
if (p->peak_offsets[j] > 250) {
corr = 1.91;
}
t_offsets[*n_indices] = corr * p->peak_offsets[j] / (DELTA_F_RA * p->N_zc);
t_offsets[*n_indices] = srslte_prach_set_offset(p,j);
}
(*n_indices)++;
}
}
}
}
if (cancellation_idx != -1) {
srslte_prach_cancellation(p, signal, begin, sig_len, prach_cancel);
} else {
break;
}
}
ret = SRSLTE_SUCCESS;
}

119
lib/src/phy/phch/test/prach_test_multi.c
View File

@ -27,11 +27,16 @@
#include <time.h>
#include <unistd.h>
#include <strings.h>
#include "srslte/srslte.h"
#include <time.h>
#include "srslte/phy/phch/prach.h"
#include "srslte/phy/utils/debug.h"
char* input_file_name = NULL;
#define MAX_LEN 70176
int offset = -1;
uint32_t nof_prb = 6;
uint32_t preamble_format = 0;
uint32_t root_seq_idx = 0;
@ -39,6 +44,10 @@ uint32_t zero_corr_zone = 1;
uint32_t n_seqs = 64;
uint32_t num_ra_preambles = 0; // use default
bool test_successive_cancellation = false;
bool test_offset_calculation = false;
srslte_filesource_t fsrc;
void usage(char* prog)
{
printf("Usage: %s\n", prog);
@ -52,7 +61,7 @@ void usage(char* prog)
void parse_args(int argc, char** argv)
{
int opt;
while ((opt = getopt(argc, argv, "Nfrzn")) != -1) {
while ((opt = getopt(argc, argv, "Nfrznio")) != -1) {
switch (opt) {
case 'N':
nof_prb = (uint32_t)strtol(argv[optind], NULL, 10);
@ -69,6 +78,12 @@ void parse_args(int argc, char** argv)
case 'n':
n_seqs = (uint32_t)strtol(argv[optind], NULL, 10);
break;
case 'i':
input_file_name = argv[optind];
break;
case 'o':
offset = (uint32_t)strtol(argv[optind], NULL, 10);
break;
default:
usage(argv[0]);
exit(-1);
@ -76,26 +91,83 @@ void parse_args(int argc, char** argv)
}
}
void stagger_prach_powers(srslte_prach_t prach, cf_t *preamble, cf_t* preamble_sum, int freq_offset, int n_seqs, int *offsets) {
for (int seq_index = 0; seq_index < n_seqs; seq_index++) {
srslte_prach_gen(&prach, seq_index, freq_offset, preamble);
if (seq_index == 0) {
srslte_vec_sc_prod_cfc(preamble, 0.1, preamble, prach.N_cp + prach.N_seq);
}
if (seq_index == 1) {
srslte_vec_sc_prod_cfc(preamble, 0.4, preamble, prach.N_cp + prach.N_seq);
}
if (seq_index == 2) {
srslte_vec_sc_prod_cfc(preamble, 0.07, preamble, prach.N_cp + prach.N_seq);
}
if (seq_index == 3) {
srslte_vec_sc_prod_cfc(preamble,0.6, preamble, prach.N_cp + prach.N_seq);
}
if (seq_index == 4) {
srslte_vec_sc_prod_cfc(preamble, 1, preamble, prach.N_cp + prach.N_seq);
}
if (seq_index == 5) {
srslte_vec_sc_prod_cfc(preamble, 0.05, preamble, prach.N_cp + prach.N_seq);
}
for (int i = 0; i < prach.N_cp + prach.N_seq; i++) {
preamble_sum[i] += preamble[i];
}
}
}
int main(int argc, char** argv)
{
parse_args(argc, argv);
srslte_prach_t prach;
bool high_speed_flag = false;
srand (time(NULL));
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);
int offsets[64];
memset(offsets, 0, sizeof(int) * 64);
float t_offsets[64];
srslte_prach_cfg_t prach_cfg;
ZERO_OBJECT(prach_cfg);
if(input_file_name) {
if (srslte_filesource_init(&fsrc, input_file_name, SRSLTE_COMPLEX_FLOAT_BIN)) {
ERROR("Error opening file %s\n", input_file_name);
exit(-1);
}
}
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;
prach_cfg.num_ra_preambles = num_ra_preambles;
prach_cfg.enable_successive_cancellation = test_successive_cancellation;
int srate = srslte_sampling_freq_hz(nof_prb);
int divisor = srate/1048750;
if (test_offset_calculation) {
n_seqs = 15;
prach_cfg.num_ra_preambles = 15;
prach_cfg.zero_corr_zone = 0;
printf("limiting number of preambles to 15 for offset calculation test\n");
for (int i = 0; i < 15; i++) {
offsets[i] = ((rand()%(25*divisor)));
}
}
if (test_successive_cancellation) {
printf("limiting number of preambles to 6 for successive cancellation test\n");
prach_cfg.num_ra_preambles = 6;
n_seqs = 6;
prach_cfg.zero_corr_zone = 0;
memset(offsets, 0, sizeof(int) * 64);
}
if (srslte_prach_init(&prach, srslte_symbol_sz(nof_prb))) {
return -1;
@ -107,7 +179,6 @@ int main(int argc, char** argv)
}
uint32_t seq_index = 0;
uint32_t frequency_offset = 0;
uint32_t indices[64];
uint32_t n_indices = 0;
@ -115,30 +186,46 @@ int main(int argc, char** argv)
indices[i] = 0;
srslte_prach_set_detect_factor(&prach, 10);
if (test_successive_cancellation) {
stagger_prach_powers(prach, preamble, preamble_sum, prach_cfg.freq_offset, n_seqs, offsets);
} else {
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];
srslte_prach_gen(&prach, seq_index, prach_cfg.freq_offset, preamble);
for (int i = prach.N_cp; i < prach.N_cp + prach.N_seq; i++) {
int off = (offset == -1)?offsets[seq_index]:offset;
preamble_sum[i + off] += preamble[i];
}
}
}
if (input_file_name) {
srslte_filesource_read(&fsrc, &preamble_sum[prach.N_cp], prach.N_seq);
}
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);
srslte_prach_detect_offset(&prach, 0, &preamble_sum[prach.N_cp], prach_len, indices, t_offsets , NULL, &n_indices);
int err = 0;
if (n_indices != n_seqs) {
return -1;
printf("n_indices %d n_seq %d\n", n_indices, n_seqs);
err++;
}
for (int i = 0; i < n_seqs; i++) {
if (indices[i] != i) {
return -1;
for (int i = 0; i < n_indices; i++) {
if (test_offset_calculation) {
int error = (int)(t_offsets[i] * srate) - offsets[i];
if (abs(error) > divisor) {
printf("preamble %d has incorrect offset calculated as %d, should be %d\n", i, (int)(t_offsets[i] * srate) , offsets[i]);
err++;
}
}
}
if (err){
return -1;
}
srslte_prach_free(&prach);
printf("Done\n");