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

Improved cell search program

This commit is contained in:
ismagom 2014-08-02 01:36:34 +02:00
parent f4eeec3df7
commit dbc3195830
7 changed files with 382 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

240
lte/phy/examples/cell_search.c
View File

@ -46,32 +46,34 @@
#define FLEN 9600 #define FLEN 9600
#define FLEN_PERIOD 0.005 #define FLEN_PERIOD 0.005
#define MAX_EARFCN 1000
int band = -1; int band = -1;
int earfcn_start=-1, earfcn_end = -1; int earfcn_start=-1, earfcn_end = -1;
int nof_frames_find=200; int nof_frames_total = 50;
int nof_frames_detected = 10;
float threshold = -1;
float uhd_gain = 60.0; float uhd_gain = 60.0;
char *uhd_args=""; char *uhd_args="";
#define MAX_EARFCN 1000
lte_earfcn_t channels[MAX_EARFCN];
void usage(char *prog) { void usage(char *prog) {
printf("Usage: %s [asefgv] -b band\n", prog); printf("Usage: %s [agsendtvb] -b band\n", prog);
printf("\t-a UHD args [Default %s]\n", uhd_args); printf("\t-a UHD args [Default %s]\n", uhd_args);
printf("\t-g UHD gain [Default %.2f dB]\n", uhd_gain); printf("\t-g UHD gain [Default %.2f dB]\n", uhd_gain);
printf("\t-s earfcn_start [Default All]\n"); printf("\t-s earfcn_start [Default All]\n");
printf("\t-e earfcn_end [Default All]\n"); printf("\t-e earfcn_end [Default All]\n");
printf("\t-f nof_frames_find [Default %d]\n", nof_frames_find); printf("\t-n nof_frames_total [Default 100]\n");
printf("\t-d nof_frames_detected [Default 10]\n");
printf("\t-t threshold [Default %.2f]\n",threshold);
printf("\t-v [set verbose to debug, default none]\n"); printf("\t-v [set verbose to debug, default none]\n");
} }
void parse_args(int argc, char **argv) { void parse_args(int argc, char **argv) {
int opt; int opt;
while ((opt = getopt(argc, argv, "asefgvb")) != -1) { while ((opt = getopt(argc, argv, "agsendtvb")) != -1) {
switch(opt) { switch(opt) {
case 'a': case 'a':
uhd_args = argv[optind]; uhd_args = argv[optind];
@ -85,8 +87,14 @@ void parse_args(int argc, char **argv) {
case 'e': case 'e':
earfcn_end = atoi(argv[optind]); earfcn_end = atoi(argv[optind]);
break; break;
case 'f': case 'n':
nof_frames_find = atoi(argv[optind]); nof_frames_total = atoi(argv[optind]);
break;
case 'd':
nof_frames_detected = atoi(argv[optind]);
break;
case 't':
threshold = atof(argv[optind]);
break; break;
case 'g': case 'g':
uhd_gain = atof(argv[optind]); uhd_gain = atof(argv[optind]);
@ -105,36 +113,135 @@ void parse_args(int argc, char **argv) {
} }
} }
int cuhd_recv_wrapper(void *h, void *data, uint32_t nsamples) { int decode_pbch(void *uhd, cf_t *buffer, ue_celldetect_result_t *found_cell)
DEBUG(" ---- Receive %d samples ---- \n", nsamples); {
return cuhd_recv(h, data, nsamples, 1); ue_mib_t uemib;
} pbch_mib_t mib;
int n;
bzero(&mib, sizeof(pbch_mib_t));
int main(int argc, char **argv) { uint32_t nof_frames = 0;
int ret; uint32_t flen = MIB_FRAME_SIZE;
int frame_cnt;
int nof_freqs;
uint32_t freq;
ue_sync_t uesync;
void *uhd;
cf_t *buffer;
lte_cell_t cell;
if (argc < 3) { if (ue_mib_init(&uemib, found_cell->cell_id, found_cell->cp)) {
usage(argv[0]); fprintf(stderr, "Error initiating PBCH decoder\n");
exit(-1); return LIBLTE_ERROR;
} }
parse_args(argc,argv); INFO("Setting sampling frequency 1.92 MHz for PBCH decoding\n", 0);
cuhd_set_rx_srate(uhd, 1920000.0);
INFO("Starting receiver...\n", 0);
cuhd_start_rx_stream(uhd);
do {
if (cuhd_recv(uhd, buffer, flen, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
return LIBLTE_ERROR;
}
INFO("Calling ue_mib_decode() %d/%d\n", nof_frames, nof_frames_total);
n = ue_mib_decode(&uemib, buffer, flen, &mib);
if (n == LIBLTE_ERROR || n == LIBLTE_ERROR_INVALID_INPUTS) {
fprintf(stderr, "Error calling ue_mib_decode()\n");
return LIBLTE_ERROR;
}
if (n == MIB_FRAME_UNALIGNED) {
printf("Realigning frame\n");
if (cuhd_recv(uhd, buffer, flen/2, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
return LIBLTE_ERROR;
}
}
nof_frames++;
} while (n != MIB_FOUND && nof_frames < 2*nof_frames_total);
if (n == MIB_FOUND) {
printf("\n\nMIB decoded in %d ms (%d half frames)\n", nof_frames*5, nof_frames);
pbch_mib_fprint(stdout, &mib, found_cell->cell_id);
} else {
printf("\nCould not decode MIB\n");
}
cuhd_stop_rx_stream(uhd);
cuhd_flush_buffer(uhd);
ue_mib_free(&uemib);
return LIBLTE_SUCCESS;
}
int find_cell(void *uhd, ue_celldetect_t *s, cf_t *buffer, ue_celldetect_result_t *found_cell)
{
int n;
INFO("Setting sampling frequency 960 KHz for PSS search\n", 0);
cuhd_set_rx_srate(uhd, 960000.0);
INFO("Starting receiver...\n", 0);
cuhd_start_rx_stream(uhd);
uint32_t nof_scanned_cells = 0;
uint32_t flen = 4800;
do {
if (cuhd_recv(uhd, buffer, flen, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
return LIBLTE_ERROR;
}
n = ue_celldetect_scan(s, buffer, flen, found_cell);
switch(n) {
case CS_FRAME_UNALIGNED:
printf("Realigning frame\n");
if (cuhd_recv(uhd, buffer, flen/2, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
return LIBLTE_ERROR;
}
return LIBLTE_ERROR;
case CS_CELL_DETECTED:
if (found_cell->peak > 0) {
printf("\n\tCELL ID: %d, CP: %s, Peak: %.2f, Mode: %d/%d\n",
found_cell->cell_id, lte_cp_string(found_cell->cp),
found_cell->peak, found_cell->mode, s->nof_frames_detected);
}
nof_scanned_cells++;
break;
case CS_CELL_NOT_DETECTED:
nof_scanned_cells++;
break;
case LIBLTE_ERROR:
case LIBLTE_ERROR_INVALID_INPUTS:
fprintf(stderr, "Error calling cellsearch_scan()\n");
return LIBLTE_ERROR;
}
} while(nof_scanned_cells < 3 && n != CS_CELL_DETECTED);
INFO("Stopping receiver...\n", 0);
cuhd_stop_rx_stream(uhd);
cuhd_flush_buffer(uhd);
return n;
}
int main(int argc, char **argv) {
int n;
void *uhd;
ue_celldetect_t s;
ue_celldetect_result_t found_cell;
cf_t *buffer;
int nof_freqs;
lte_earfcn_t channels[MAX_EARFCN];
uint32_t freq;
parse_args(argc, argv);
printf("Opening UHD device...\n"); printf("Opening UHD device...\n");
if (cuhd_open(uhd_args, &uhd)) { if (cuhd_open(uhd_args, &uhd)) {
fprintf(stderr, "Error opening uhd\n"); fprintf(stderr, "Error opening uhd\n");
exit(-1); exit(-1);
} }
/* set uhd_gain */
cuhd_set_rx_gain(uhd, uhd_gain); cuhd_set_rx_gain(uhd, uhd_gain);
nof_freqs = lte_band_get_fd_band(band, channels, earfcn_start, earfcn_end, MAX_EARFCN); nof_freqs = lte_band_get_fd_band(band, channels, earfcn_start, earfcn_end, MAX_EARFCN);
@ -143,59 +250,58 @@ int main(int argc, char **argv) {
exit(-1); exit(-1);
} }
buffer = vec_malloc(sizeof(cf_t) * 96000);
if (!buffer) {
perror("malloc");
return LIBLTE_ERROR;
}
for (freq=0;freq<nof_freqs;freq++) { if (ue_celldetect_init(&s)) {
/* set freq */ fprintf(stderr, "Error initiating UE sync module\n");
cuhd_stop_rx_stream(uhd); exit(-1);
}
if (threshold > 0) {
ue_celldetect_set_threshold(&s, threshold);
}
if (nof_frames_total > 0) {
ue_celldetect_set_nof_frames_total(&s, nof_frames_total);
}
if (nof_frames_detected > 0) {
ue_celldetect_set_nof_frames_detected(&s, nof_frames_detected);
}
for (freq=0;freq<nof_freqs;freq+=10) {
/* set uhd_freq */
cuhd_set_rx_freq(uhd, (double) channels[freq].fd * MHZ); cuhd_set_rx_freq(uhd, (double) channels[freq].fd * MHZ);
cuhd_rx_wait_lo_locked(uhd); cuhd_rx_wait_lo_locked(uhd);
if (ue_sync_init(&uesync, cell, cuhd_recv_wrapper, uhd)) {
fprintf(stderr, "Error initiating UE sync\n");
exit(-1);
}
ue_sync_decode_sss_on_track(&uesync, true);
DEBUG("Starting receiver...\n",0);
cuhd_start_rx_stream(uhd);
usleep(10000); usleep(10000);
INFO("Set uhd_freq to %.3f MHz\n", (double) channels[freq].fd * MHZ/1000000);
/* Receive up to a maximum of nof_frames_find */
frame_cnt = 0;
ret = 0;
ue_sync_reset(&uesync);
while(frame_cnt < nof_frames_find && ret == 0) {
ret = ue_sync_get_buffer(&uesync, &buffer);
if (ret < 0) {
fprintf(stderr, "Error calling ue_sync_work()\n");
exit(-1);
}
frame_cnt++;
printf("[%3d/%d]: EARFCN %d Freq. %.2f MHz looking for PSS. \r", freq, nof_freqs, printf("[%3d/%d]: EARFCN %d Freq. %.2f MHz looking for PSS. \r", freq, nof_freqs,
channels[freq].id, channels[freq].fd);fflush(stdout); channels[freq].id, channels[freq].fd);fflush(stdout);
if (VERBOSE_ISINFO()) { if (VERBOSE_ISINFO()) {
printf("\n"); printf("\n");
} }
n = find_cell(uhd, &s, buffer, &found_cell);
if (n < 0) {
fprintf(stderr, "Error searching cell\n");
exit(-1);
}
if (n == CS_CELL_DETECTED) {
if (decode_pbch(uhd, buffer, &found_cell)) {
fprintf(stderr, "Error decoding PBCH\n");
exit(-1);
} }
if (ret == 1) {
if (VERBOSE_ISINFO()) {
printf("[%3d/%d]: EARFCN %d Freq. %.2f MHz FOUND MIB ", freq, nof_freqs,
channels[freq].id, channels[freq].fd);
} }
printf("CFO: %+.4f KHz\n", ue_sync_get_cfo(&uesync));
printf("\n");fflush(stdout);
}
ue_sync_free(&uesync);
} }
ue_celldetect_free(&s);
cuhd_close(uhd); cuhd_close(uhd);
printf("\n\nDone\n");
exit(0); exit(0);
} }

2
lte/phy/include/liblte/phy/phy.h
View File

@ -95,7 +95,7 @@
#include "liblte/phy/ue/ue_sync.h" #include "liblte/phy/ue/ue_sync.h"
#include "liblte/phy/ue/ue_mib.h" #include "liblte/phy/ue/ue_mib.h"
#include "liblte/phy/ue/ue_cellsearch.h" #include "liblte/phy/ue/ue_celldetect.h"
#include "liblte/phy/ue/ue_dl.h" #include "liblte/phy/ue/ue_dl.h"
#include "liblte/phy/scrambling/scrambling.h" #include "liblte/phy/scrambling/scrambling.h"

28
lte/phy/include/liblte/phy/ue/ue_cellsearch.h → lte/phy/include/liblte/phy/ue/ue_celldetect.h
View File

@ -42,7 +42,7 @@
* This object scans a signal for LTE cells using the known PSS * This object scans a signal for LTE cells using the known PSS
* and SSS sequences. * and SSS sequences.
* *
* The function ue_cellsearch_scan() shall be called multiple times, * The function ue_celldetect_scan() shall be called multiple times,
* each passing a number of samples multiple of 4800, sampled at 960 KHz * each passing a number of samples multiple of 4800, sampled at 960 KHz
* (that is, 5 ms of samples). * (that is, 5 ms of samples).
* *
@ -74,7 +74,7 @@ typedef struct LIBLTE_API {
lte_cp_t cp; lte_cp_t cp;
float peak; float peak;
uint32_t mode; uint32_t mode;
} ue_cellsearch_result_t; } ue_celldetect_result_t;
typedef struct LIBLTE_API { typedef struct LIBLTE_API {
@ -92,35 +92,35 @@ typedef struct LIBLTE_API {
uint32_t *mode_ntimes; uint32_t *mode_ntimes;
char *mode_counted; char *mode_counted;
ue_cellsearch_result_t *candidates; ue_celldetect_result_t *candidates;
} ue_cellsearch_t; } ue_celldetect_t;
LIBLTE_API int ue_cellsearch_init(ue_cellsearch_t *q); LIBLTE_API int ue_celldetect_init(ue_celldetect_t *q);
LIBLTE_API int ue_cellsearch_init_max(ue_cellsearch_t *q, LIBLTE_API int ue_celldetect_init_max(ue_celldetect_t *q,
uint32_t max_frames_total, uint32_t max_frames_total,
uint32_t max_frames_detected); uint32_t max_frames_detected);
LIBLTE_API void ue_cellsearch_free(ue_cellsearch_t *q); LIBLTE_API void ue_celldetect_free(ue_celldetect_t *q);
LIBLTE_API void ue_cellsearch_reset(ue_cellsearch_t *q); LIBLTE_API void ue_celldetect_reset(ue_celldetect_t *q);
LIBLTE_API int ue_cellsearch_scan(ue_cellsearch_t *q, LIBLTE_API int ue_celldetect_scan(ue_celldetect_t *q,
cf_t *signal, cf_t *signal,
uint32_t nsamples, uint32_t nsamples,
ue_cellsearch_result_t *found_cell); ue_celldetect_result_t *found_cell);
LIBLTE_API int ue_cellsearch_set_nof_frames_total(ue_cellsearch_t *q, LIBLTE_API int ue_celldetect_set_nof_frames_total(ue_celldetect_t *q,
uint32_t nof_frames); uint32_t nof_frames);
LIBLTE_API int ue_cellsearch_set_nof_frames_detected(ue_cellsearch_t *q, LIBLTE_API int ue_celldetect_set_nof_frames_detected(ue_celldetect_t *q,
uint32_t nof_frames); uint32_t nof_frames);
LIBLTE_API void ue_cellsearch_set_threshold(ue_cellsearch_t *q, LIBLTE_API void ue_celldetect_set_threshold(ue_celldetect_t *q,
float threshold); float threshold);
LIBLTE_API void ue_cellsearch_reset(ue_cellsearch_t *q); LIBLTE_API void ue_celldetect_reset(ue_celldetect_t *q);

84
lte/phy/lib/sync/src/sync.c
View File

@ -143,83 +143,43 @@ lte_cp_t sync_get_cp(sync_t *q) {
return q->cp; return q->cp;
} }
static lte_cp_t detect_cp(cf_t *input, uint32_t peak_pos)
{
return CPNORM;
}
int sync_sss(sync_t *q, cf_t *input, uint32_t peak_pos) { int sync_sss(sync_t *q, cf_t *input, uint32_t peak_pos) {
uint32_t m0, m1; uint32_t m0, m1;
int sss_idx_n, sss_idx_e, ret; int sss_idx, ret;
float m0_value_e, m1_value_e,m0_value_n, m1_value_n; float m0_value, m1_value;
uint32_t sf_idx_e, N_id_1_e, sf_idx_n, N_id_1_n;
sss_synch_set_N_id_2(&q->sss, q->N_id_2); sss_synch_set_N_id_2(&q->sss, q->N_id_2);
/* Make sure we have enough room to find SSS sequence */
sss_idx_n = (int) peak_pos - 2*(q->fft_size + CP(q->fft_size, CPNORM_LEN));
sss_idx_e = (int) peak_pos - 2*(q->fft_size + CP(q->fft_size, CPEXT_LEN));
if (q->detect_cp) { if (q->detect_cp) {
if (sss_idx_n < 0 || sss_idx_e < 0) { q->cp = detect_cp(input, peak_pos);
INFO("Not enough room to decode SSS (%d, %d)\n", sss_idx_n, sss_idx_e);
return LIBLTE_SUCCESS;
}
} else {
if (CP_ISNORM(q->cp)) {
if (sss_idx_n < 0) {
INFO("Not enough room to decode normal CP SSS (sss_idx=%d, peak_pos=%d)\n", sss_idx_n, peak_pos);
return LIBLTE_SUCCESS;
}
} else {
if (sss_idx_e < 0) {
INFO("Not enough room to decode extended CP SSS (sss_idx=%d, peak_pos=%d)\n", sss_idx_e, peak_pos);
return LIBLTE_SUCCESS;
}
}
} }
sf_idx_n = 0; /* Make sure we have enough room to find SSS sequence */
sf_idx_e = 0; sss_idx = (int) peak_pos - 2*(q->fft_size + CP(q->fft_size, q->cp));
N_id_1_n = 0;
N_id_1_e = 0; if (sss_idx < 0) {
INFO("Not enough room to decode CP SSS (sss_idx=%d, peak_pos=%d)\n", sss_idx, peak_pos);
return LIBLTE_SUCCESS;
}
/* try Normal CP length */ /* try Normal CP length */
if (q->detect_cp || CP_ISNORM(q->cp)) { sss_synch_m0m1(&q->sss, &input[sss_idx], &m0, &m0_value, &m1, &m1_value);
sss_synch_m0m1(&q->sss, &input[sss_idx_n], &m0, &m0_value_n, &m1, &m1_value_n);
sf_idx_n = sss_synch_subframe(m0, m1); q->sf_idx = sss_synch_subframe(m0, m1);
ret = sss_synch_N_id_1(&q->sss, m0, m1); ret = sss_synch_N_id_1(&q->sss, m0, m1);
if (ret >= 0) { if (ret >= 0) {
N_id_1_n = (uint32_t) ret; q->N_id_1 = (uint32_t) ret;
} else { } else {
N_id_1_n = 1000; q->N_id_1 = 1000;
}
} }
if (q->detect_cp || CP_ISEXT(q->cp)) { DEBUG("SSS detected N_id_1=%d, sf_idx=%d, %s CP\n",
/* Now try Extended CP length */ q->N_id_1, q->sf_idx, CP_ISNORM(q->cp)?"Normal":"Extended");
sss_synch_m0m1(&q->sss, &input[sss_idx_e], &m0, &m0_value_e, &m1, &m1_value_e);
sf_idx_e = sss_synch_subframe(m0, m1);
ret = sss_synch_N_id_1(&q->sss, m0, m1);
if (ret >= 0) {
N_id_1_e = (uint32_t) ret;
} else {
N_id_1_e = 1000;
}
}
/* Correlation with extended CP hypoteshis is greater than with normal? */
if ((q->detect_cp && m0_value_e * m1_value_e > m0_value_n * m1_value_n)
|| CP_ISEXT(q->cp)) {
q->cp = CPEXT;
q->sf_idx = sf_idx_e;
q->N_id_1 = N_id_1_e;
/* otherwise is normal CP */
} else {
q->cp = CPNORM;
q->sf_idx = sf_idx_n;
q->N_id_1 = N_id_1_n;
}
DEBUG("SSS detected N_id_1=%d, sf_idx=%d, position=%d/%d %s CP\n",
q->N_id_1, q->sf_idx, sss_idx_n, sss_idx_e, CP_ISNORM(q->cp)?"Normal":"Extended");
return 1; return 1;
} }
@ -276,7 +236,7 @@ int sync_find(sync_t *q, cf_t *input, uint32_t find_offset, uint32_t *peak_posit
} }
} }
} else { } else {
printf("Warning: no space for CFO computation\n"); INFO("Warning: no space for CFO computation\n",0);
} }
if (peak_position) { if (peak_position) {

36
lte/phy/lib/ue/src/ue_cellsearch.c → lte/phy/lib/ue/src/ue_celldetect.c
View File

@ -31,7 +31,7 @@
#include <assert.h> #include <assert.h>
#include <unistd.h> #include <unistd.h>
#include "liblte/phy/ue/ue_cellsearch.h" #include "liblte/phy/ue/ue_celldetect.h"
#include "liblte/phy/utils/debug.h" #include "liblte/phy/utils/debug.h"
#include "liblte/phy/utils/vector.h" #include "liblte/phy/utils/vector.h"
@ -39,19 +39,19 @@
#define FIND_FFTSIZE 64 #define FIND_FFTSIZE 64
#define FIND_SFLEN 5*SF_LEN(FIND_FFTSIZE) #define FIND_SFLEN 5*SF_LEN(FIND_FFTSIZE)
int ue_cellsearch_init(ue_cellsearch_t * q) { int ue_celldetect_init(ue_celldetect_t * q) {
return ue_cellsearch_init_max(q, CS_DEFAULT_MAXFRAMES_TOTAL, CS_DEFAULT_MAXFRAMES_DETECTED); return ue_celldetect_init_max(q, CS_DEFAULT_MAXFRAMES_TOTAL, CS_DEFAULT_MAXFRAMES_DETECTED);
} }
int ue_cellsearch_init_max(ue_cellsearch_t * q, uint32_t max_frames_total, uint32_t max_frames_detected) { int ue_celldetect_init_max(ue_celldetect_t * q, uint32_t max_frames_total, uint32_t max_frames_detected) {
int ret = LIBLTE_ERROR_INVALID_INPUTS; int ret = LIBLTE_ERROR_INVALID_INPUTS;
if (q != NULL) { if (q != NULL) {
ret = LIBLTE_ERROR; ret = LIBLTE_ERROR;
bzero(q, sizeof(ue_cellsearch_t)); bzero(q, sizeof(ue_celldetect_t));
q->candidates = malloc(sizeof(ue_cellsearch_result_t) * max_frames_detected); q->candidates = malloc(sizeof(ue_celldetect_result_t) * max_frames_detected);
if (!q->candidates) { if (!q->candidates) {
perror("malloc"); perror("malloc");
goto clean_exit; goto clean_exit;
@ -78,19 +78,19 @@ int ue_cellsearch_init_max(ue_cellsearch_t * q, uint32_t max_frames_total, uint3
q->nof_frames_total = CS_DEFAULT_NOFFRAMES_TOTAL; q->nof_frames_total = CS_DEFAULT_NOFFRAMES_TOTAL;
q->nof_frames_detected = CS_DEFAULT_NOFFRAMES_DETECTED; q->nof_frames_detected = CS_DEFAULT_NOFFRAMES_DETECTED;
ue_cellsearch_reset(q); ue_celldetect_reset(q);
ret = LIBLTE_SUCCESS; ret = LIBLTE_SUCCESS;
} }
clean_exit: clean_exit:
if (ret == LIBLTE_ERROR) { if (ret == LIBLTE_ERROR) {
ue_cellsearch_free(q); ue_celldetect_free(q);
} }
return ret; return ret;
} }
void ue_cellsearch_free(ue_cellsearch_t * q) void ue_celldetect_free(ue_celldetect_t * q)
{ {
if (q->candidates) { if (q->candidates) {
free(q->candidates); free(q->candidates);
@ -105,21 +105,21 @@ void ue_cellsearch_free(ue_cellsearch_t * q)
} }
void ue_cellsearch_reset(ue_cellsearch_t * q) void ue_celldetect_reset(ue_celldetect_t * q)
{ {
q->current_nof_detected = 0; q->current_nof_detected = 0;
q->current_nof_total = 0; q->current_nof_total = 0;
q->current_N_id_2 = 0; q->current_N_id_2 = 0;
} }
void ue_cellsearch_set_threshold(ue_cellsearch_t * q, float threshold) void ue_celldetect_set_threshold(ue_celldetect_t * q, float threshold)
{ {
sync_set_threshold(&q->sfind, threshold); sync_set_threshold(&q->sfind, threshold);
} }
int ue_cellsearch_set_nof_frames_total(ue_cellsearch_t * q, uint32_t nof_frames) int ue_celldetect_set_nof_frames_total(ue_celldetect_t * q, uint32_t nof_frames)
{ {
if (nof_frames > q->max_frames_total) { if (nof_frames <= q->max_frames_total) {
q->nof_frames_total = nof_frames; q->nof_frames_total = nof_frames;
return LIBLTE_SUCCESS; return LIBLTE_SUCCESS;
} else { } else {
@ -127,9 +127,9 @@ int ue_cellsearch_set_nof_frames_total(ue_cellsearch_t * q, uint32_t nof_frames)
} }
} }
int ue_cellsearch_set_nof_frames_detected(ue_cellsearch_t * q, uint32_t nof_frames) int ue_celldetect_set_nof_frames_detected(ue_celldetect_t * q, uint32_t nof_frames)
{ {
if (nof_frames > q->max_frames_detected) { if (nof_frames <= q->max_frames_detected) {
q->nof_frames_detected = nof_frames; q->nof_frames_detected = nof_frames;
return LIBLTE_SUCCESS; return LIBLTE_SUCCESS;
} else { } else {
@ -138,7 +138,7 @@ int ue_cellsearch_set_nof_frames_detected(ue_cellsearch_t * q, uint32_t nof_fram
} }
/* Decide the most likely cell based on the mode */ /* Decide the most likely cell based on the mode */
void decide_cell(ue_cellsearch_t * q, ue_cellsearch_result_t *found_cell) void decide_cell(ue_celldetect_t * q, ue_celldetect_result_t *found_cell)
{ {
uint32_t i, j; uint32_t i, j;
@ -186,10 +186,10 @@ void decide_cell(ue_cellsearch_t * q, ue_cellsearch_result_t *found_cell)
found_cell->mode = q->mode_ntimes[mode_pos]; found_cell->mode = q->mode_ntimes[mode_pos];
} }
int ue_cellsearch_scan(ue_cellsearch_t * q, int ue_celldetect_scan(ue_celldetect_t * q,
cf_t *signal, cf_t *signal,
uint32_t nsamples, uint32_t nsamples,
ue_cellsearch_result_t *found_cell) ue_celldetect_result_t *found_cell)
{ {
int ret = LIBLTE_ERROR_INVALID_INPUTS; int ret = LIBLTE_ERROR_INVALID_INPUTS;
uint32_t peak_idx; uint32_t peak_idx;

4
lte/phy/lib/ue/test/CMakeLists.txt
View File

@ -29,8 +29,8 @@ IF(${CUHD_FIND} GREATER -1)
ADD_EXECUTABLE(ue_sync_usrp ue_sync_usrp.c) ADD_EXECUTABLE(ue_sync_usrp ue_sync_usrp.c)
TARGET_LINK_LIBRARIES(ue_sync_usrp lte_phy cuhd) TARGET_LINK_LIBRARIES(ue_sync_usrp lte_phy cuhd)
ADD_EXECUTABLE(ue_cell_detect ue_cell_detect.c) ADD_EXECUTABLE(ue_celldetect_mib_test ue_celldetect_mib_test.c)
TARGET_LINK_LIBRARIES(ue_cell_detect lte_phy cuhd) TARGET_LINK_LIBRARIES(ue_celldetect_mib_test lte_phy cuhd)
ENDIF(${CUHD_FIND} GREATER -1) ENDIF(${CUHD_FIND} GREATER -1)
IF(${GRAPHICS_FIND} EQUAL -1) IF(${GRAPHICS_FIND} EQUAL -1)

239
lte/phy/lib/ue/test/ue_cell_detect.c → lte/phy/lib/ue/test/ue_celldetect_mib_test.c
View File

@ -40,7 +40,6 @@
#include "liblte/phy/phy.h" #include "liblte/phy/phy.h"
#include "liblte/cuhd/cuhd.h" #include "liblte/cuhd/cuhd.h"
void *uhd;
int nof_frames_total = CS_DEFAULT_NOFFRAMES_TOTAL; int nof_frames_total = CS_DEFAULT_NOFFRAMES_TOTAL;
int nof_frames_detected = CS_DEFAULT_NOFFRAMES_DETECTED; int nof_frames_detected = CS_DEFAULT_NOFFRAMES_DETECTED;
@ -95,7 +94,123 @@ void parse_args(int argc, char **argv) {
} }
} }
void input_init() { int decode_pbch(void *uhd, cf_t *buffer, ue_celldetect_result_t *found_cell)
{
ue_mib_t uemib;
pbch_mib_t mib;
int n;
uint32_t nof_frames = 0;
uint32_t flen = MIB_FRAME_SIZE;
if (ue_mib_init(&uemib, found_cell->cell_id, found_cell->cp)) {
fprintf(stderr, "Error initiating PBCH decoder\n");
return LIBLTE_ERROR;
}
INFO("Setting sampling frequency 1.92 MHz for PBCH decoding\n", 0);
cuhd_set_rx_srate(uhd, 1920000.0);
INFO("Starting receiver...\n", 0);
cuhd_start_rx_stream(uhd);
do {
if (cuhd_recv(uhd, buffer, flen, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
return LIBLTE_ERROR;
}
INFO("Calling ue_mib_decode() %d/%d\n", nof_frames, nof_frames_total);
n = ue_mib_decode(&uemib, buffer, flen, &mib);
if (n == LIBLTE_ERROR || n == LIBLTE_ERROR_INVALID_INPUTS) {
fprintf(stderr, "Error calling ue_mib_decode()\n");
return LIBLTE_ERROR;
}
if (n == MIB_FRAME_UNALIGNED) {
printf("Realigning frame\n");
if (cuhd_recv(uhd, buffer, flen/2, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
return LIBLTE_ERROR;
}
}
nof_frames++;
} while (n != MIB_FOUND && nof_frames < nof_frames_total);
if (n == MIB_FOUND) {
printf("\n\nMIB decoded in %d ms (%d half frames)\n", nof_frames*5, nof_frames);
pbch_mib_fprint(stdout, &mib, found_cell->cell_id);
} else {
printf("\nCould not decode MIB\n");
}
cuhd_stop_rx_stream(uhd);
cuhd_flush_buffer(uhd);
ue_mib_free(&uemib);
return LIBLTE_SUCCESS;
}
int find_cell(void *uhd, ue_celldetect_t *s, cf_t *buffer, ue_celldetect_result_t *found_cell)
{
int n;
INFO("Setting sampling frequency 960 KHz for PSS search\n", 0);
cuhd_set_rx_srate(uhd, 960000.0);
INFO("Starting receiver...\n", 0);
cuhd_start_rx_stream(uhd);
uint32_t nof_scanned_cells = 0;
uint32_t flen = 4800;
do {
if (cuhd_recv(uhd, buffer, flen, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
return LIBLTE_ERROR;
}
n = ue_celldetect_scan(s, buffer, flen, found_cell);
switch(n) {
case CS_FRAME_UNALIGNED:
printf("Realigning frame\n");
if (cuhd_recv(uhd, buffer, flen/2, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
return LIBLTE_ERROR;
}
return LIBLTE_ERROR;
case CS_CELL_DETECTED:
if (found_cell->peak > 0) {
printf("\tCELL ID: %d, CP: %s, Peak: %.2f, Mode: %d/%d\n",
found_cell->cell_id, lte_cp_string(found_cell->cp),
found_cell->peak, found_cell->mode, s->nof_frames_detected);
}
nof_scanned_cells++;
break;
case CS_CELL_NOT_DETECTED:
nof_scanned_cells++;
break;
case LIBLTE_ERROR:
case LIBLTE_ERROR_INVALID_INPUTS:
fprintf(stderr, "Error calling cellsearch_scan()\n");
return LIBLTE_ERROR;
}
} while(nof_scanned_cells < 3 && n != CS_CELL_DETECTED);
INFO("Stopping receiver...\n", 0);
cuhd_stop_rx_stream(uhd);
cuhd_flush_buffer(uhd);
return n;
}
int main(int argc, char **argv) {
int n;
void *uhd;
ue_celldetect_t s;
ue_celldetect_result_t found_cell;
cf_t *buffer;
parse_args(argc, argv);
printf("Opening UHD device...\n"); printf("Opening UHD device...\n");
if (cuhd_open(uhd_args, &uhd)) { if (cuhd_open(uhd_args, &uhd)) {
@ -109,136 +224,40 @@ void input_init() {
cuhd_rx_wait_lo_locked(uhd); cuhd_rx_wait_lo_locked(uhd);
DEBUG("Set uhd_freq to %.3f MHz\n", (double ) uhd_freq/1000000); DEBUG("Set uhd_freq to %.3f MHz\n", (double ) uhd_freq/1000000);
INFO("Setting sampling frequency 960 KHz for PSS search\n", 0); buffer = vec_malloc(sizeof(cf_t) * 96000);
cuhd_set_rx_srate(uhd, 960000.0);
DEBUG("Starting receiver...\n", 0);
cuhd_start_rx_stream(uhd);
}
int main(int argc, char **argv) {
ue_cellsearch_t s;
ue_mib_t uemib;
ue_cellsearch_result_t found_cell;
pbch_mib_t mib;
uint32_t flen;
cf_t *buffer;
int n;
parse_args(argc, argv);
input_init();
// allocate for the maximum size (10 ms at 1.92 MHz for PBCH decoding)
buffer = vec_malloc(sizeof(cf_t) * 19200*30);
if (!buffer) { if (!buffer) {
perror("malloc"); perror("malloc");
exit(-1); return LIBLTE_ERROR;
} }
if (ue_cellsearch_init(&s)) { if (ue_celldetect_init(&s)) {
fprintf(stderr, "Error initiating UE sync module\n"); fprintf(stderr, "Error initiating UE sync module\n");
exit(-1); exit(-1);
} }
if (threshold > 0) { if (threshold > 0) {
ue_cellsearch_set_threshold(&s, threshold); ue_celldetect_set_threshold(&s, threshold);
} }
if (nof_frames_total > 0) { if (nof_frames_total > 0) {
ue_cellsearch_set_nof_frames_total(&s, nof_frames_total); ue_celldetect_set_nof_frames_total(&s, nof_frames_total);
} }
if (nof_frames_detected > 0) { if (nof_frames_detected > 0) {
ue_cellsearch_set_nof_frames_detected(&s, nof_frames_detected); ue_celldetect_set_nof_frames_detected(&s, nof_frames_detected);
} }
uint32_t nof_scanned_cells = 0; n = find_cell(uhd, &s, buffer, &found_cell);
flen = 4800; if (n < 0) {
fprintf(stderr, "Error searching cell\n");
do {
if (cuhd_recv(uhd, buffer, flen, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
exit(-1); exit(-1);
} }
n = ue_cellsearch_scan(&s, buffer, flen, &found_cell);
switch(n) {
case CS_FRAME_UNALIGNED:
fprintf(stderr, "Unaliged frame!! Exiting\n");
exit(-1);
case CS_CELL_DETECTED:
printf("\tCELL ID: %d, CP: %s, Peak: %.2f, Mode: %d/%d\n",
found_cell.cell_id, lte_cp_string(found_cell.cp),
found_cell.peak, found_cell.mode, s.nof_frames_detected);
nof_scanned_cells++;
break;
case CS_CELL_NOT_DETECTED:
nof_scanned_cells++;
break;
case LIBLTE_ERROR:
case LIBLTE_ERROR_INVALID_INPUTS:
fprintf(stderr, "Error calling cellsearch_scan()\n");
exit(-1);
}
} while(nof_scanned_cells < 3 && n != CS_CELL_DETECTED);
if (n == CS_CELL_DETECTED) { if (n == CS_CELL_DETECTED) {
INFO("Stopping receiver...\n", 0); if (decode_pbch(uhd, buffer, &found_cell)) {
cuhd_stop_rx_stream(uhd); fprintf(stderr, "Error decoding PBCH\n");
cuhd_flush_buffer(uhd);
if (ue_mib_init(&uemib, found_cell.cell_id, found_cell.cp)) {
fprintf(stderr, "Error initiating PBCH decoder\n");
exit(-1);
}
INFO("Setting sampling frequency 1.92 MHz for PBCH decoding\n", 0);
cuhd_set_rx_srate(uhd, 1920000.0);
INFO("Starting receiver...\n", 0);
cuhd_start_rx_stream(uhd);
usleep(50000);
uint32_t nof_frames = 0;
flen = MIB_FRAME_SIZE;
do {
if (cuhd_recv(uhd, buffer, flen, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
exit(-1);
}
INFO("Calling ue_mib_decode() %d/%d\n", nof_frames, nof_frames_total);
n = ue_mib_decode(&uemib, buffer, flen, &mib);
if (n == LIBLTE_ERROR || n == LIBLTE_ERROR_INVALID_INPUTS) {
fprintf(stderr, "Error calling ue_mib_decode()\n");
exit(-1);
}
if (n == MIB_FRAME_UNALIGNED) {
printf("Realigning frame\n");
if (cuhd_recv(uhd, buffer, flen/2, 1)<0) {
fprintf(stderr, "Error receiving from USRP\n");
exit(-1); exit(-1);
} }
} }
nof_frames++;
} while (n != MIB_FOUND && nof_frames < nof_frames_total);
if (n == MIB_FOUND) {
printf("\n\nMIB decoded in %d ms (%d half frames)\n", nof_frames*5, nof_frames);
pbch_mib_fprint(stdout, &mib, found_cell.cell_id);
} else {
printf("\nCould not decode MIB\n");
}
}
ue_celldetect_free(&s);
ue_mib_free(&uemib);
ue_cellsearch_free(&s);
cuhd_close(uhd); cuhd_close(uhd);
exit(0); exit(0);
} }