Skip to content

O
OpenXG-RAN
Commit 7c377945 authored by rmagueta's avatar rmagueta
Browse files
Options

Revert code indentation in usrp_lib

parent 2efe7513
Hide whitespace changes
Inline Side-by-side
Showing with 410 additions and 390 deletions
targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
View file @ 7c377945
...@@ -272,6 +272,7 @@ static int sync_to_gps(openair0_device *device) { ...@@ -272,6 +272,7 @@ static int sync_to_gps(openair0_device *device) {
*/ */
static int trx_usrp_start(openair0_device *device) { static int trx_usrp_start(openair0_device *device) {
usrp_state_t *s = (usrp_state_t *)device->priv; usrp_state_t *s = (usrp_state_t *)device->priv;
// setup GPIO for TDD, GPIO(4) = ATR_RX // setup GPIO for TDD, GPIO(4) = ATR_RX
//set data direction register (DDR) to output //set data direction register (DDR) to output
s->usrp->set_gpio_attr("FP0", "DDR", 0xfff, 0xfff); s->usrp->set_gpio_attr("FP0", "DDR", 0xfff, 0xfff);
...@@ -284,16 +285,17 @@ static int trx_usrp_start(openair0_device *device) { ...@@ -284,16 +285,17 @@ static int trx_usrp_start(openair0_device *device) {
s->usrp->set_gpio_attr("FP0", "ATR_XX", (1<<5), 0x7f); s->usrp->set_gpio_attr("FP0", "ATR_XX", (1<<5), 0x7f);
// set the output pins to 1 // set the output pins to 1
s->usrp->set_gpio_attr("FP0", "OUT", 7<<7, 0xf80); s->usrp->set_gpio_attr("FP0", "OUT", 7<<7, 0xf80);
s->wait_for_first_pps = 1; s->wait_for_first_pps = 1;
s->rx_count = 0; s->rx_count = 0;
s->tx_count = 0; s->tx_count = 0;
//s->first_tx = 1; //s->first_tx = 1;
//s->first_rx = 1; //s->first_rx = 1;
s->rx_timestamp = 0; s->rx_timestamp = 0;
s->usrp->set_time_next_pps(uhd::time_spec_t(0.0)); s->usrp->set_time_next_pps(uhd::time_spec_t(0.0));
// wait for the pps to change // wait for the pps to change
uhd::time_spec_t time_last_pps = s->usrp->get_time_last_pps(); uhd::time_spec_t time_last_pps = s->usrp->get_time_last_pps();
while (time_last_pps == s->usrp->get_time_last_pps()) { while (time_last_pps == s->usrp->get_time_last_pps()) {
boost::this_thread::sleep(boost::posix_time::milliseconds(1)); boost::this_thread::sleep(boost::posix_time::milliseconds(1));
} }
...@@ -302,6 +304,7 @@ static int trx_usrp_start(openair0_device *device) { ...@@ -302,6 +304,7 @@ static int trx_usrp_start(openair0_device *device) {
cmd.time_spec = uhd::time_spec_t(1.0); cmd.time_spec = uhd::time_spec_t(1.0);
cmd.stream_now = false; // start at constant delay cmd.stream_now = false; // start at constant delay
s->rx_stream->issue_stream_cmd(cmd); s->rx_stream->issue_stream_cmd(cmd);
return 0; return 0;
} }
/*! \brief Terminate operation of the USRP transceiver -- free all associated resources /*! \brief Terminate operation of the USRP transceiver -- free all associated resources
...@@ -315,8 +318,9 @@ static void trx_usrp_end(openair0_device *device) { ...@@ -315,8 +318,9 @@ static void trx_usrp_end(openair0_device *device) {
if (s == NULL) if (s == NULL)
return; return;
iqrecorder_end(device); iqrecorder_end(device);
} }
/*! \brief Called to send samples to the USRP RF target /*! \brief Called to send samples to the USRP RF target
...@@ -328,59 +332,64 @@ static void trx_usrp_end(openair0_device *device) { ...@@ -328,59 +332,64 @@ static void trx_usrp_end(openair0_device *device) {
@param flags flags must be set to TRUE if timestamp parameter needs to be applied @param flags flags must be set to TRUE if timestamp parameter needs to be applied
*/ */
static int trx_usrp_write(openair0_device *device, static int trx_usrp_write(openair0_device *device,
openair0_timestamp timestamp, openair0_timestamp timestamp,
void **buff, void **buff,
int nsamps, int nsamps,
int cc, int cc,
int flags) { int flags) {
int ret=0; int ret=0;
usrp_state_t *s = (usrp_state_t *)device->priv; usrp_state_t *s = (usrp_state_t *)device->priv;
int nsamps2; // aligned to upper 32 or 16 byte boundary int nsamps2; // aligned to upper 32 or 16 byte boundary
int flags_lsb = flags&0xff; int flags_lsb = flags&0xff;
int flags_msb = (flags>>8)&0xff; int flags_msb = (flags>>8)&0xff;
int end; int end;
openair0_thread_t *write_thread = &device->write_thread; openair0_thread_t *write_thread = &device->write_thread;
openair0_write_package_t *write_package = write_thread->write_package; openair0_write_package_t *write_package = write_thread->write_package;
AssertFatal( MAX_WRITE_THREAD_BUFFER_SIZE >= cc,"Do not support more than %d cc number\n", MAX_WRITE_THREAD_BUFFER_SIZE); AssertFatal( MAX_WRITE_THREAD_BUFFER_SIZE >= cc,"Do not support more than %d cc number\n", MAX_WRITE_THREAD_BUFFER_SIZE);
boolean_t first_packet_state=false,last_packet_state=false;
boolean_t first_packet_state=false,last_packet_state=false;
if (flags_lsb == 2) { // start of burst
// s->tx_md.start_of_burst = true; if (flags_lsb == 2) { // start of burst
// s->tx_md.end_of_burst = false; // s->tx_md.start_of_burst = true;
first_packet_state = true; // s->tx_md.end_of_burst = false;
last_packet_state = false; first_packet_state = true;
} else if (flags_lsb == 3) { // end of burst last_packet_state = false;
//s->tx_md.start_of_burst = false; } else if (flags_lsb == 3) { // end of burst
//s->tx_md.end_of_burst = true; //s->tx_md.start_of_burst = false;
first_packet_state = false; //s->tx_md.end_of_burst = true;
last_packet_state = true; first_packet_state = false;
} else if (flags_lsb == 4) { // start and end last_packet_state = true;
} else if (flags_lsb == 4) { // start and end
// s->tx_md.start_of_burst = true; // s->tx_md.start_of_burst = true;
// s->tx_md.end_of_burst = true; // s->tx_md.end_of_burst = true;
first_packet_state = true; first_packet_state = true;
last_packet_state = true; last_packet_state = true;
} else if (flags_lsb==1) { // middle of burst } else if (flags_lsb==1) { // middle of burst
// s->tx_md.start_of_burst = false; // s->tx_md.start_of_burst = false;
// s->tx_md.end_of_burst = false; // s->tx_md.end_of_burst = false;
first_packet_state = false; first_packet_state = false;
last_packet_state = false; last_packet_state = false;
} else if (flags_lsb==10) { // fail safe mode }
// s->tx_md.has_time_spec = false; else if (flags_lsb==10) { // fail safe mode
// s->tx_md.start_of_burst = false; // s->tx_md.has_time_spec = false;
// s->tx_md.end_of_burst = true; // s->tx_md.start_of_burst = false;
first_packet_state = false; // s->tx_md.end_of_burst = true;
last_packet_state = true; first_packet_state = false;
} last_packet_state = true;
}
if(usrp_tx_thread == 0) { if(usrp_tx_thread == 0){
#if defined(__x86_64) || defined(__i386__) #if defined(__x86_64) || defined(__i386__)
#ifdef __AVX2__ #ifdef __AVX2__
nsamps2 = (nsamps+7)>>3; nsamps2 = (nsamps+7)>>3;
__m256i buff_tx[8][nsamps2]; __m256i buff_tx[8][nsamps2];
#else #else
nsamps2 = (nsamps+3)>>2; nsamps2 = (nsamps+3)>>2;
__m128i buff_tx[8][nsamps2]; __m128i buff_tx[8][nsamps2];
#endif #endif
#elif defined(__arm__) #elif defined(__arm__)
nsamps2 = (nsamps+3)>>2; nsamps2 = (nsamps+3)>>2;
int16x8_t buff_tx[8][nsamps2]; int16x8_t buff_tx[8][nsamps2];
...@@ -408,8 +417,8 @@ static int trx_usrp_write(openair0_device *device, ...@@ -408,8 +417,8 @@ static int trx_usrp_write(openair0_device *device,
s->tx_md.end_of_burst = last_packet_state; s->tx_md.end_of_burst = last_packet_state;
s->tx_md.time_spec = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate); s->tx_md.time_spec = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate);
s->tx_count++; s->tx_count++;
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_BEAM_SWITCHING_GPIO,1);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_BEAM_SWITCHING_GPIO,1);
// bit 3 enables gpio (for backward compatibility) // bit 3 enables gpio (for backward compatibility)
if (flags_msb&8) { if (flags_msb&8) {
// push GPIO bits 7-9 from flags_msb // push GPIO bits 7-9 from flags_msb
...@@ -418,8 +427,7 @@ static int trx_usrp_write(openair0_device *device, ...@@ -418,8 +427,7 @@ static int trx_usrp_write(openair0_device *device,
s->usrp->set_gpio_attr("FP0", "OUT", gpio789, 0x380); s->usrp->set_gpio_attr("FP0", "OUT", gpio789, 0x380);
s->usrp->clear_command_time(); s->usrp->clear_command_time();
} }
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_BEAM_SWITCHING_GPIO,0);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_BEAM_SWITCHING_GPIO,0);
if (cc>1) { if (cc>1) {
std::vector<void *> buff_ptrs; std::vector<void *> buff_ptrs;
...@@ -428,18 +436,18 @@ static int trx_usrp_write(openair0_device *device, ...@@ -428,18 +436,18 @@ static int trx_usrp_write(openair0_device *device,
buff_ptrs.push_back(&(((int16_t *)buff_tx[i])[0])); buff_ptrs.push_back(&(((int16_t *)buff_tx[i])[0]));
ret = (int)s->tx_stream->send(buff_ptrs, nsamps, s->tx_md); ret = (int)s->tx_stream->send(buff_ptrs, nsamps, s->tx_md);
} else { }
else {
ret = (int)s->tx_stream->send(&(((int16_t *)buff_tx[0])[0]), nsamps, s->tx_md); ret = (int)s->tx_stream->send(&(((int16_t *)buff_tx[0])[0]), nsamps, s->tx_md);
} }
if (ret != nsamps) if (ret != nsamps) LOG_E(HW,"[xmit] tx samples %d != %d\n",ret,nsamps);
LOG_E(HW,"[xmit] tx samples %d != %d\n",ret,nsamps);
return ret; return ret;
} else { }
else{
pthread_mutex_lock(&write_thread->mutex_write); pthread_mutex_lock(&write_thread->mutex_write);
if(write_thread->count_write >= MAX_WRITE_THREAD_PACKAGE) { if(write_thread->count_write >= MAX_WRITE_THREAD_PACKAGE){
LOG_W(HW,"Buffer overflow, count_write = %d, start = %d end = %d, resetting write package\n", write_thread->count_write, write_thread->start, write_thread->end); LOG_W(HW,"Buffer overflow, count_write = %d, start = %d end = %d, resetting write package\n", write_thread->count_write, write_thread->start, write_thread->end);
write_thread->end = write_thread->start; write_thread->end = write_thread->start;
write_thread->count_write = 0; write_thread->count_write = 0;
...@@ -452,16 +460,15 @@ static int trx_usrp_write(openair0_device *device, ...@@ -452,16 +460,15 @@ static int trx_usrp_write(openair0_device *device,
write_package[end].first_packet = first_packet_state; write_package[end].first_packet = first_packet_state;
write_package[end].last_packet = last_packet_state; write_package[end].last_packet = last_packet_state;
write_package[end].flags_msb = flags_msb; write_package[end].flags_msb = flags_msb;
for (int i = 0; i < cc; i++) for (int i = 0; i < cc; i++)
write_package[end].buff[i] = buff[i]; write_package[end].buff[i] = buff[i];
write_thread->count_write++; write_thread->count_write++;
write_thread->end = (write_thread->end + 1)% MAX_WRITE_THREAD_PACKAGE; write_thread->end = (write_thread->end + 1)% MAX_WRITE_THREAD_PACKAGE;
pthread_cond_signal(&write_thread->cond_write); pthread_cond_signal(&write_thread->cond_write);
pthread_mutex_unlock(&write_thread->mutex_write); pthread_mutex_unlock(&write_thread->mutex_write);
return 0; return 0;
} }
} }
//-----------------------start-------------------------- //-----------------------start--------------------------
...@@ -473,11 +480,12 @@ static int trx_usrp_write(openair0_device *device, ...@@ -473,11 +480,12 @@ static int trx_usrp_write(openair0_device *device,
@param antenna_id index of the antenna if the device has multiple antennas @param antenna_id index of the antenna if the device has multiple antennas
@param flags flags must be set to TRUE if timestamp parameter needs to be applied @param flags flags must be set to TRUE if timestamp parameter needs to be applied
*/ */
void *trx_usrp_write_thread(void *arg) { void *trx_usrp_write_thread(void * arg){
int ret=0; int ret=0;
openair0_device *device=(openair0_device *)arg; openair0_device *device=(openair0_device *)arg;
openair0_thread_t *write_thread = &device->write_thread; openair0_thread_t *write_thread = &device->write_thread;
openair0_write_package_t *write_package = write_thread->write_package; openair0_write_package_t *write_package = write_thread->write_package;
usrp_state_t *s; usrp_state_t *s;
int nsamps2; // aligned to upper 32 or 16 byte boundary int nsamps2; // aligned to upper 32 or 16 byte boundary
int start; int start;
...@@ -489,13 +497,11 @@ void *trx_usrp_write_thread(void *arg) { ...@@ -489,13 +497,11 @@ void *trx_usrp_write_thread(void *arg) {
signed char last_packet; signed char last_packet;
int flags_msb; int flags_msb;
while(1) { while(1){
pthread_mutex_lock(&write_thread->mutex_write); pthread_mutex_lock(&write_thread->mutex_write);
while (write_thread->count_write == 0) { while (write_thread->count_write == 0) {
pthread_cond_wait(&write_thread->cond_write,&write_thread->mutex_write); // this unlocks mutex_rxtx while waiting and then locks it again pthread_cond_wait(&write_thread->cond_write,&write_thread->mutex_write); // this unlocks mutex_rxtx while waiting and then locks it again
} }
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_THREAD, 1 ); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_THREAD, 1 );
s = (usrp_state_t *)device->priv; s = (usrp_state_t *)device->priv;
start = write_thread->start; start = write_thread->start;
...@@ -512,36 +518,38 @@ void *trx_usrp_write_thread(void *arg) { ...@@ -512,36 +518,38 @@ void *trx_usrp_write_thread(void *arg) {
/*if(write_thread->count_write != 0){ /*if(write_thread->count_write != 0){
LOG_W(HW,"count write = %d, start = %d, end = %d\n", write_thread->count_write, write_thread->start, write_thread->end); LOG_W(HW,"count write = %d, start = %d, end = %d\n", write_thread->count_write, write_thread->start, write_thread->end);
}*/ }*/
#if defined(__x86_64) || defined(__i386__)
#ifdef __AVX2__ #if defined(__x86_64) || defined(__i386__)
nsamps2 = (nsamps+7)>>3; #ifdef __AVX2__
__m256i buff_tx[8][nsamps2]; nsamps2 = (nsamps+7)>>3;
#else __m256i buff_tx[8][nsamps2];
nsamps2 = (nsamps+3)>>2; #else
__m128i buff_tx[8][nsamps2]; nsamps2 = (nsamps+3)>>2;
#endif __m128i buff_tx[8][nsamps2];
#elif defined(__arm__) #endif
nsamps2 = (nsamps+3)>>2; #elif defined(__arm__)
int16x8_t buff_tx[8][nsamps2]; nsamps2 = (nsamps+3)>>2;
#else int16x8_t buff_tx[8][nsamps2];
#error Unsupported CPU architecture, USRP device cannot be built #else
#endif #error Unsupported CPU architecture, USRP device cannot be built
#endif
// bring RX data into 12 LSBs for softmodem RX // bring RX data into 12 LSBs for softmodem RX
for (int i=0; i<cc; i++) { for (int i=0; i<cc; i++) {
for (int j=0; j<nsamps2; j++) { for (int j=0; j<nsamps2; j++) {
#if defined(__x86_64__) || defined(__i386__) #if defined(__x86_64__) || defined(__i386__)
#ifdef __AVX2__ #ifdef __AVX2__
buff_tx[i][j] = _mm256_slli_epi16(((__m256i *)buff[i])[j],4); buff_tx[i][j] = _mm256_slli_epi16(((__m256i *)buff[i])[j],4);
#else #else
buff_tx[i][j] = _mm_slli_epi16(((__m128i *)buff[i])[j],4); buff_tx[i][j] = _mm_slli_epi16(((__m128i *)buff[i])[j],4);
#endif #endif
#elif defined(__arm__) #elif defined(__arm__)
buff_tx[i][j] = vshlq_n_s16(((int16x8_t *)buff[i])[j],4); buff_tx[i][j] = vshlq_n_s16(((int16x8_t *)buff[i])[j],4);
#endif #endif
} }
} }
s->tx_md.has_time_spec = true; s->tx_md.has_time_spec = true;
s->tx_md.start_of_burst = (s->tx_count==0) ? true : first_packet; s->tx_md.start_of_burst = (s->tx_count==0) ? true : first_packet;
s->tx_md.end_of_burst = last_packet; s->tx_md.end_of_burst = last_packet;
...@@ -564,32 +572,34 @@ void *trx_usrp_write_thread(void *arg) { ...@@ -564,32 +572,34 @@ void *trx_usrp_write_thread(void *arg) {
buff_ptrs.push_back(&(((int16_t *)buff_tx[i])[0])); buff_ptrs.push_back(&(((int16_t *)buff_tx[i])[0]));
ret = (int)s->tx_stream->send(buff_ptrs, nsamps, s->tx_md); ret = (int)s->tx_stream->send(buff_ptrs, nsamps, s->tx_md);
} else { }
else {
ret = (int)s->tx_stream->send(&(((int16_t *)buff_tx[0])[0]), nsamps, s->tx_md); ret = (int)s->tx_stream->send(&(((int16_t *)buff_tx[0])[0]), nsamps, s->tx_md);
} }
if (ret != nsamps) if (ret != nsamps) LOG_E(HW,"[xmit] tx samples %d != %d\n",ret,nsamps);
LOG_E(HW,"[xmit] tx samples %d != %d\n",ret,nsamps);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_USRP_SEND_RETURN, ret ); VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_USRP_SEND_RETURN, ret );
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_THREAD, 0 ); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_THREAD, 0 );
if(0) if(0) break;
break;
} }
return NULL; return NULL;
} }
int trx_usrp_write_init(openair0_device *device) { int trx_usrp_write_init(openair0_device *device){
uhd::set_thread_priority_safe(1.0); uhd::set_thread_priority_safe(1.0);
openair0_thread_t *write_thread = &device->write_thread; openair0_thread_t *write_thread = &device->write_thread;
printf("initializing tx write thread\n"); printf("initializing tx write thread\n");
write_thread->start = 0; write_thread->start = 0;
write_thread->end = 0; write_thread->end = 0;
write_thread->count_write = 0; write_thread->count_write = 0;
printf("end of tx write thread\n"); printf("end of tx write thread\n");
pthread_create(&write_thread->pthread_write,NULL,trx_usrp_write_thread,(void *)device); pthread_create(&write_thread->pthread_write,NULL,trx_usrp_write_thread,(void *)device);
return(0); return(0);
} }
...@@ -623,60 +633,57 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp ...@@ -623,60 +633,57 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp
int16x8_t buff_tmp[2][nsamps2]; int16x8_t buff_tmp[2][nsamps2];
#endif #endif
if (cc>1) { if (cc>1) {
// receive multiple channels (e.g. RF A and RF B) // receive multiple channels (e.g. RF A and RF B)
std::vector<void *> buff_ptrs; std::vector<void *> buff_ptrs;
for (int i=0; i<cc; i++) for (int i=0; i<cc; i++) buff_ptrs.push_back(buff_tmp[i]);
buff_ptrs.push_back(buff_tmp[i]);
samples_received = s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md); samples_received = s->rx_stream->recv(buff_ptrs, nsamps, s->rx_md);
} else { } else {
// receive a single channel (e.g. from connector RF A) // receive a single channel (e.g. from connector RF A)
samples_received=0; samples_received=0;
while (samples_received != nsamps) { while (samples_received != nsamps) {
samples_received += s->rx_stream->recv((void *)((int32_t *)buff_tmp[0]+samples_received), samples_received += s->rx_stream->recv((void*)((int32_t*)buff_tmp[0]+samples_received),
nsamps-samples_received, s->rx_md); nsamps-samples_received, s->rx_md);
if ((s->wait_for_first_pps == 0) && (s->rx_md.error_code!=uhd::rx_metadata_t::ERROR_CODE_NONE)) if ((s->wait_for_first_pps == 0) && (s->rx_md.error_code!=uhd::rx_metadata_t::ERROR_CODE_NONE))
break; break;
if ((s->wait_for_first_pps == 1) && (samples_received != nsamps)) { if ((s->wait_for_first_pps == 1) && (samples_received != nsamps)) {
printf("sleep...\n"); //usleep(100); printf("sleep...\n"); //usleep(100);
}
} }
if (samples_received == nsamps) s->wait_for_first_pps=0;
} }
if (samples_received == nsamps) // bring RX data into 12 LSBs for softmodem RX
s->wait_for_first_pps=0; for (int i=0; i<cc; i++) {
} for (int j=0; j<nsamps2; j++) {
// bring RX data into 12 LSBs for softmodem RX
for (int i=0; i<cc; i++) {
for (int j=0; j<nsamps2; j++) {
#if defined(__x86_64__) || defined(__i386__) #if defined(__x86_64__) || defined(__i386__)
#ifdef __AVX2__ #ifdef __AVX2__
// FK: in some cases the buffer might not be 32 byte aligned, so we cannot use avx2 // FK: in some cases the buffer might not be 32 byte aligned, so we cannot use avx2
if ((((uintptr_t) buff[i])&0x1F)==0) { if ((((uintptr_t) buff[i])&0x1F)==0) {
((__m256i *)buff[i])[j] = _mm256_srai_epi16(buff_tmp[i][j],4); ((__m256i *)buff[i])[j] = _mm256_srai_epi16(buff_tmp[i][j],4);
} else { } else {
((__m128i *)buff[i])[2*j] = _mm_srai_epi16(((__m128i *)buff_tmp[i])[2*j],4); ((__m128i *)buff[i])[2*j] = _mm_srai_epi16(((__m128i *)buff_tmp[i])[2*j],4);
((__m128i *)buff[i])[2*j+1] = _mm_srai_epi16(((__m128i *)buff_tmp[i])[2*j+1],4); ((__m128i *)buff[i])[2*j+1] = _mm_srai_epi16(((__m128i *)buff_tmp[i])[2*j+1],4);
} }
#else #else
((__m128i *)buff[i])[j] = _mm_srai_epi16(buff_tmp[i][j],4); ((__m128i *)buff[i])[j] = _mm_srai_epi16(buff_tmp[i][j],4);
#endif #endif
#elif defined(__arm__) #elif defined(__arm__)
((int16x8_t *)buff[i])[j] = vshrq_n_s16(buff_tmp[i][j],4); ((int16x8_t *)buff[i])[j] = vshrq_n_s16(buff_tmp[i][j],4);
#endif #endif
}
} }
}
if (samples_received < nsamps) { if (samples_received < nsamps) {
LOG_E(HW,"[recv] received %d samples out of %d\n",samples_received,nsamps); LOG_E(HW,"[recv] received %d samples out of %d\n",samples_received,nsamps);
} }
if ( s->rx_md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE) if ( s->rx_md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE)
LOG_E(HW, "%s\n", s->rx_md.to_pp_string(true).c_str()); LOG_E(HW, "%s\n", s->rx_md.to_pp_string(true).c_str());
...@@ -684,11 +691,12 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp ...@@ -684,11 +691,12 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp
s->rx_count += nsamps; s->rx_count += nsamps;
s->rx_timestamp = s->rx_md.time_spec.to_ticks(s->sample_rate); s->rx_timestamp = s->rx_md.time_spec.to_ticks(s->sample_rate);
*ptimestamp = s->rx_timestamp; *ptimestamp = s->rx_timestamp;
// push GPIO bits 7-9 from flags_msb // push GPIO bits 7-9 from flags_msb
/*s->usrp->set_command_time(uhd::time_spec_t::from_ticks((s->rx_timestamp+(2*nsamps)),s->sample_rate)); /*s->usrp->set_command_time(uhd::time_spec_t::from_ticks((s->rx_timestamp+(2*nsamps)),s->sample_rate));
s->usrp->set_gpio_attr("FP0", "OUT", gpio789<<7, 0x380); s->usrp->set_gpio_attr("FP0", "OUT", gpio789<<7, 0x380);
s->usrp->clear_command_time(); s->usrp->clear_command_time();
gpio789 = (gpio789+1)&7;*/ gpio789 = (gpio789+1)&7;*/
recplay_state_t *recPlay=device->recplay_state; recplay_state_t *recPlay=device->recplay_state;
if ( recPlay != NULL) { // record mode if ( recPlay != NULL) { // record mode
...@@ -937,6 +945,8 @@ extern "C" { ...@@ -937,6 +945,8 @@ extern "C" {
device->trx_set_freq_func = trx_usrp_set_freq; device->trx_set_freq_func = trx_usrp_set_freq;
device->trx_set_gains_func = trx_usrp_set_gains; device->trx_set_gains_func = trx_usrp_set_gains;
device->trx_write_init = trx_usrp_write_init; device->trx_write_init = trx_usrp_write_init;
// hotfix! to be checked later // hotfix! to be checked later
uhd::set_thread_priority_safe(1.0); uhd::set_thread_priority_safe(1.0);
// Initialize USRP device // Initialize USRP device
...@@ -1003,319 +1013,329 @@ extern "C" { ...@@ -1003,319 +1013,329 @@ extern "C" {
s->usrp = uhd::usrp::multi_usrp::make(args); s->usrp = uhd::usrp::multi_usrp::make(args);
if (args.find("clock_source")==std::string::npos) { if (args.find("clock_source")==std::string::npos) {
if (openair0_cfg[0].clock_source == internal) { if (openair0_cfg[0].clock_source == internal) {
s->usrp->set_clock_source("internal"); s->usrp->set_clock_source("internal");
LOG_D(HW,"Setting clock source to internal\n"); LOG_D(HW,"Setting clock source to internal\n");
} else if (openair0_cfg[0].clock_source == external ) { }
s->usrp->set_clock_source("external"); else if (openair0_cfg[0].clock_source == external ) {
LOG_D(HW,"Setting clock source to external\n"); s->usrp->set_clock_source("external");
} else if (openair0_cfg[0].clock_source==gpsdo) { LOG_D(HW,"Setting clock source to external\n");
s->usrp->set_clock_source("gpsdo"); }
LOG_D(HW,"Setting clock source to gpsdo\n"); else if (openair0_cfg[0].clock_source==gpsdo) {
} else { s->usrp->set_clock_source("gpsdo");
LOG_W(HW,"Clock source set neither in usrp_args nor on command line, using default!\n"); LOG_D(HW,"Setting clock source to gpsdo\n");
} }
} else { else {
if (openair0_cfg[0].clock_source != unset) { LOG_W(HW,"Clock source set neither in usrp_args nor on command line, using default!\n");
LOG_W(HW,"Clock source set in both usrp_args and in clock_source, ingnoring the latter!\n"); }
}
} }
else {
if (openair0_cfg[0].clock_source != unset) {
LOG_W(HW,"Clock source set in both usrp_args and in clock_source, ingnoring the latter!\n");
}
}
if (args.find("time_source")==std::string::npos) { if (args.find("time_source")==std::string::npos) {
if (openair0_cfg[0].time_source == internal) { if (openair0_cfg[0].time_source == internal) {
s->usrp->set_time_source("internal"); s->usrp->set_time_source("internal");
LOG_D(HW,"Setting time source to internal\n"); LOG_D(HW,"Setting time source to internal\n");
} else if (openair0_cfg[0].time_source == external ) { }
s->usrp->set_time_source("external"); else if (openair0_cfg[0].time_source == external ) {
LOG_D(HW,"Setting time source to external\n"); s->usrp->set_time_source("external");
} else if (openair0_cfg[0].time_source==gpsdo) { LOG_D(HW,"Setting time source to external\n");
s->usrp->set_time_source("gpsdo"); }
LOG_D(HW,"Setting time source to gpsdo\n"); else if (openair0_cfg[0].time_source==gpsdo) {
} else { s->usrp->set_time_source("gpsdo");
LOG_W(HW,"Time source set neither in usrp_args nor on command line, using default!\n"); LOG_D(HW,"Setting time source to gpsdo\n");
} }
} else { else {
if (openair0_cfg[0].clock_source != unset) { LOG_W(HW,"Time source set neither in usrp_args nor on command line, using default!\n");
LOG_W(HW,"Time source set in both usrp_args and in time_source, ingnoring the latter!\n"); }
}
} }
else {
if (openair0_cfg[0].clock_source != unset) {
LOG_W(HW,"Time source set in both usrp_args and in time_source, ingnoring the latter!\n");
}
}
if (s->usrp->get_clock_source(0) == "gpsdo") {
s->use_gps = 1;
if (sync_to_gps(device)==EXIT_SUCCESS) { if (s->usrp->get_clock_source(0) == "gpsdo") {
LOG_I(HW,"USRP synced with GPS!\n"); s->use_gps = 1;
} else {
LOG_I(HW,"USRP fails to sync with GPS. Exiting.\n");
exit(EXIT_FAILURE);
}
} else if (s->usrp->get_clock_source(0) == "external") {
if (check_ref_locked(s,0)) {
LOG_I(HW,"USRP locked to external reference!\n");
} else {
LOG_I(HW,"Failed to lock to external reference. Exiting.\n");
exit(EXIT_FAILURE);
}
}
if (device->type==USRP_X300_DEV) { if (sync_to_gps(device)==EXIT_SUCCESS) {
openair0_cfg[0].rx_gain_calib_table = calib_table_x310; LOG_I(HW,"USRP synced with GPS!\n");
std::cerr << "-- Using calibration table: calib_table_x310" << std::endl; } else {
LOG_I(HW,"USRP fails to sync with GPS. Exiting.\n");
exit(EXIT_FAILURE);
} }
} else if (s->usrp->get_clock_source(0) == "external") {
if (device->type==USRP_N300_DEV) { if (check_ref_locked(s,0)) {
openair0_cfg[0].rx_gain_calib_table = calib_table_n310; LOG_I(HW,"USRP locked to external reference!\n");
std::cerr << "-- Using calibration table: calib_table_n310" << std::endl; } else {
LOG_I(HW,"Failed to lock to external reference. Exiting.\n");
exit(EXIT_FAILURE);
} }
}
if (device->type==USRP_N300_DEV || device->type==USRP_X300_DEV) { if (device->type==USRP_X300_DEV) {
LOG_I(HW,"%s() sample_rate:%u\n", __FUNCTION__, (int)openair0_cfg[0].sample_rate); openair0_cfg[0].rx_gain_calib_table = calib_table_x310;
std::cerr << "-- Using calibration table: calib_table_x310" << std::endl;
}
switch ((int)openair0_cfg[0].sample_rate) { if (device->type==USRP_N300_DEV) {
case 122880000: openair0_cfg[0].rx_gain_calib_table = calib_table_n310;
// from usrp_time_offset std::cerr << "-- Using calibration table: calib_table_n310" << std::endl;
//openair0_cfg[0].samples_per_packet = 2048; }
openair0_cfg[0].tx_sample_advance = 15; //to be checked
openair0_cfg[0].tx_bw = 80e6;
openair0_cfg[0].rx_bw = 80e6;
break;
case 92160000:
// from usrp_time_offset
//openair0_cfg[0].samples_per_packet = 2048;
openair0_cfg[0].tx_sample_advance = 15; //to be checked
openair0_cfg[0].tx_bw = 80e6;
openair0_cfg[0].rx_bw = 80e6;
break;
case 61440000: if (device->type==USRP_N300_DEV || device->type==USRP_X300_DEV) {
// from usrp_time_offset LOG_I(HW,"%s() sample_rate:%u\n", __FUNCTION__, (int)openair0_cfg[0].sample_rate);
//openair0_cfg[0].samples_per_packet = 2048;
openair0_cfg[0].tx_sample_advance = 15;
openair0_cfg[0].tx_bw = 40e6;
openair0_cfg[0].rx_bw = 40e6;
break;
case 46080000: switch ((int)openair0_cfg[0].sample_rate) {
//openair0_cfg[0].samples_per_packet = 2048; case 122880000:
openair0_cfg[0].tx_sample_advance = 15; // from usrp_time_offset
openair0_cfg[0].tx_bw = 40e6; //openair0_cfg[0].samples_per_packet = 2048;
openair0_cfg[0].rx_bw = 40e6; openair0_cfg[0].tx_sample_advance = 15; //to be checked
break; openair0_cfg[0].tx_bw = 80e6;
openair0_cfg[0].rx_bw = 80e6;
break;
case 30720000: case 92160000:
// from usrp_time_offset // from usrp_time_offset
//openair0_cfg[0].samples_per_packet = 2048; //openair0_cfg[0].samples_per_packet = 2048;
openair0_cfg[0].tx_sample_advance = 15; openair0_cfg[0].tx_sample_advance = 15; //to be checked
openair0_cfg[0].tx_bw = 20e6; openair0_cfg[0].tx_bw = 80e6;
openair0_cfg[0].rx_bw = 20e6; openair0_cfg[0].rx_bw = 80e6;
break; break;
case 15360000: case 61440000:
//openair0_cfg[0].samples_per_packet = 2048; // from usrp_time_offset
openair0_cfg[0].tx_sample_advance = 45; //openair0_cfg[0].samples_per_packet = 2048;
openair0_cfg[0].tx_bw = 10e6; openair0_cfg[0].tx_sample_advance = 15;
openair0_cfg[0].rx_bw = 10e6; openair0_cfg[0].tx_bw = 40e6;
break; openair0_cfg[0].rx_bw = 40e6;
break;
case 7680000: case 46080000:
//openair0_cfg[0].samples_per_packet = 2048; //openair0_cfg[0].samples_per_packet = 2048;
openair0_cfg[0].tx_sample_advance = 50; openair0_cfg[0].tx_sample_advance = 15;
openair0_cfg[0].tx_bw = 5e6; openair0_cfg[0].tx_bw = 40e6;
openair0_cfg[0].rx_bw = 5e6; openair0_cfg[0].rx_bw = 40e6;
break; break;
case 1920000: case 30720000:
//openair0_cfg[0].samples_per_packet = 2048; // from usrp_time_offset
openair0_cfg[0].tx_sample_advance = 50; //openair0_cfg[0].samples_per_packet = 2048;
openair0_cfg[0].tx_bw = 1.25e6; openair0_cfg[0].tx_sample_advance = 15;
openair0_cfg[0].rx_bw = 1.25e6; openair0_cfg[0].tx_bw = 20e6;
break; openair0_cfg[0].rx_bw = 20e6;
break;
default: case 15360000:
LOG_E(HW,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate); //openair0_cfg[0].samples_per_packet = 2048;
exit(-1); openair0_cfg[0].tx_sample_advance = 45;
break; openair0_cfg[0].tx_bw = 10e6;
} openair0_cfg[0].rx_bw = 10e6;
break;
case 7680000:
//openair0_cfg[0].samples_per_packet = 2048;
openair0_cfg[0].tx_sample_advance = 50;
openair0_cfg[0].tx_bw = 5e6;
openair0_cfg[0].rx_bw = 5e6;
break;
case 1920000:
//openair0_cfg[0].samples_per_packet = 2048;
openair0_cfg[0].tx_sample_advance = 50;
openair0_cfg[0].tx_bw = 1.25e6;
openair0_cfg[0].rx_bw = 1.25e6;
break;
default:
LOG_E(HW,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
exit(-1);
break;
} }
}
if (device->type == USRP_B200_DEV) { if (device->type == USRP_B200_DEV) {
if ((vers == 3) && (subvers == 9) && (subsubvers>=2)) { if ((vers == 3) && (subvers == 9) && (subsubvers>=2)) {
openair0_cfg[0].rx_gain_calib_table = calib_table_b210; openair0_cfg[0].rx_gain_calib_table = calib_table_b210;
bw_gain_adjust=0; bw_gain_adjust=0;
std::cerr << "-- Using calibration table: calib_table_b210" << std::endl; // Bell Labs info std::cerr << "-- Using calibration table: calib_table_b210" << std::endl; // Bell Labs info
} else { } else {
openair0_cfg[0].rx_gain_calib_table = calib_table_b210_38; openair0_cfg[0].rx_gain_calib_table = calib_table_b210_38;
bw_gain_adjust=1; bw_gain_adjust=1;
std::cerr << "-- Using calibration table: calib_table_b210_38" << std::endl; // Bell Labs info std::cerr << "-- Using calibration table: calib_table_b210_38" << std::endl; // Bell Labs info
} }
switch ((int)openair0_cfg[0].sample_rate) { switch ((int)openair0_cfg[0].sample_rate) {
case 46080000: case 46080000:
s->usrp->set_master_clock_rate(46.08e6); s->usrp->set_master_clock_rate(46.08e6);
//openair0_cfg[0].samples_per_packet = 1024; //openair0_cfg[0].samples_per_packet = 1024;
openair0_cfg[0].tx_sample_advance = 115; openair0_cfg[0].tx_sample_advance = 115;
openair0_cfg[0].tx_bw = 40e6; openair0_cfg[0].tx_bw = 40e6;
openair0_cfg[0].rx_bw = 40e6; openair0_cfg[0].rx_bw = 40e6;
break; break;
case 30720000: case 30720000:
s->usrp->set_master_clock_rate(30.72e6); s->usrp->set_master_clock_rate(30.72e6);
//openair0_cfg[0].samples_per_packet = 1024; //openair0_cfg[0].samples_per_packet = 1024;
openair0_cfg[0].tx_sample_advance = 115; openair0_cfg[0].tx_sample_advance = 115;
openair0_cfg[0].tx_bw = 20e6; openair0_cfg[0].tx_bw = 20e6;
openair0_cfg[0].rx_bw = 20e6; openair0_cfg[0].rx_bw = 20e6;
break; break;
case 23040000: case 23040000:
s->usrp->set_master_clock_rate(23.04e6); //to be checked s->usrp->set_master_clock_rate(23.04e6); //to be checked
//openair0_cfg[0].samples_per_packet = 1024; //openair0_cfg[0].samples_per_packet = 1024;
openair0_cfg[0].tx_sample_advance = 113; openair0_cfg[0].tx_sample_advance = 113;
openair0_cfg[0].tx_bw = 20e6; openair0_cfg[0].tx_bw = 20e6;
openair0_cfg[0].rx_bw = 20e6; openair0_cfg[0].rx_bw = 20e6;
break; break;
case 15360000: case 15360000:
s->usrp->set_master_clock_rate(30.72e06); s->usrp->set_master_clock_rate(30.72e06);
//openair0_cfg[0].samples_per_packet = 1024; //openair0_cfg[0].samples_per_packet = 1024;
openair0_cfg[0].tx_sample_advance = 103; openair0_cfg[0].tx_sample_advance = 103;
openair0_cfg[0].tx_bw = 20e6; openair0_cfg[0].tx_bw = 20e6;
openair0_cfg[0].rx_bw = 20e6; openair0_cfg[0].rx_bw = 20e6;
break; break;
case 7680000: case 7680000:
s->usrp->set_master_clock_rate(30.72e6); s->usrp->set_master_clock_rate(30.72e6);
//openair0_cfg[0].samples_per_packet = 1024; //openair0_cfg[0].samples_per_packet = 1024;
openair0_cfg[0].tx_sample_advance = 80; openair0_cfg[0].tx_sample_advance = 80;
openair0_cfg[0].tx_bw = 20e6; openair0_cfg[0].tx_bw = 20e6;
openair0_cfg[0].rx_bw = 20e6; openair0_cfg[0].rx_bw = 20e6;
break; break;
case 1920000: case 1920000:
s->usrp->set_master_clock_rate(30.72e6); s->usrp->set_master_clock_rate(30.72e6);
//openair0_cfg[0].samples_per_packet = 1024; //openair0_cfg[0].samples_per_packet = 1024;
openair0_cfg[0].tx_sample_advance = 40; openair0_cfg[0].tx_sample_advance = 40;
openair0_cfg[0].tx_bw = 20e6; openair0_cfg[0].tx_bw = 20e6;
openair0_cfg[0].rx_bw = 20e6; openair0_cfg[0].rx_bw = 20e6;
break; break;
default: default:
LOG_E(HW,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate); LOG_E(HW,"Error: unknown sampling rate %f\n",openair0_cfg[0].sample_rate);
exit(-1); exit(-1);
break; break;
}
} }
}
/* device specific */ /* device specific */
//openair0_cfg[0].txlaunch_wait = 1;//manage when TX processing is triggered //openair0_cfg[0].txlaunch_wait = 1;//manage when TX processing is triggered
//openair0_cfg[0].txlaunch_wait_slotcount = 1; //manage when TX processing is triggered //openair0_cfg[0].txlaunch_wait_slotcount = 1; //manage when TX processing is triggered
openair0_cfg[0].iq_txshift = 4;//shift openair0_cfg[0].iq_txshift = 4;//shift
openair0_cfg[0].iq_rxrescale = 15;//rescale iqs openair0_cfg[0].iq_rxrescale = 15;//rescale iqs
for(int i=0; i<((int) s->usrp->get_rx_num_channels()); i++) { for(int i=0; i<((int) s->usrp->get_rx_num_channels()); i++) {
if (i<openair0_cfg[0].rx_num_channels) { if (i<openair0_cfg[0].rx_num_channels) {
s->usrp->set_rx_rate(openair0_cfg[0].sample_rate,i); s->usrp->set_rx_rate(openair0_cfg[0].sample_rate,i);
s->usrp->set_rx_freq(openair0_cfg[0].rx_freq[i],i); s->usrp->set_rx_freq(openair0_cfg[0].rx_freq[i],i);
set_rx_gain_offset(&openair0_cfg[0],i,bw_gain_adjust); set_rx_gain_offset(&openair0_cfg[0],i,bw_gain_adjust);
::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(i); ::uhd::gain_range_t gain_range = s->usrp->get_rx_gain_range(i);
// limit to maximum gain // limit to maximum gain
AssertFatal( openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] <= gain_range.stop(), AssertFatal( openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] <= gain_range.stop(),
"RX Gain too high, lower by %f dB\n", "RX Gain too high, lower by %f dB\n",
openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] - gain_range.stop()); openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i] - gain_range.stop());
s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],i); s->usrp->set_rx_gain(openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],i);
LOG_I(HW,"RX Gain %d %f (%f) => %f (max %f)\n",i, LOG_I(HW,"RX Gain %d %f (%f) => %f (max %f)\n",i,
openair0_cfg[0].rx_gain[i],openair0_cfg[0].rx_gain_offset[i], openair0_cfg[0].rx_gain[i],openair0_cfg[0].rx_gain_offset[i],
openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],gain_range.stop()); openair0_cfg[0].rx_gain[i]-openair0_cfg[0].rx_gain_offset[i],gain_range.stop());
}
} }
}
LOG_D(HW, "usrp->get_tx_num_channels() == %zd\n", s->usrp->get_tx_num_channels()); LOG_D(HW, "usrp->get_tx_num_channels() == %zd\n", s->usrp->get_tx_num_channels());
LOG_D(HW, "openair0_cfg[0].tx_num_channels == %d\n", openair0_cfg[0].tx_num_channels); LOG_D(HW, "openair0_cfg[0].tx_num_channels == %d\n", openair0_cfg[0].tx_num_channels);
for(int i=0; i<((int) s->usrp->get_tx_num_channels()); i++) { for(int i=0; i<((int) s->usrp->get_tx_num_channels()); i++) {
::uhd::gain_range_t gain_range_tx = s->usrp->get_tx_gain_range(i); ::uhd::gain_range_t gain_range_tx = s->usrp->get_tx_gain_range(i);
if (i<openair0_cfg[0].tx_num_channels) { if (i<openair0_cfg[0].tx_num_channels) {
s->usrp->set_tx_rate(openair0_cfg[0].sample_rate,i); s->usrp->set_tx_rate(openair0_cfg[0].sample_rate,i);
s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[i],i); s->usrp->set_tx_freq(openair0_cfg[0].tx_freq[i],i);
s->usrp->set_tx_gain(gain_range_tx.stop()-openair0_cfg[0].tx_gain[i],i); s->usrp->set_tx_gain(gain_range_tx.stop()-openair0_cfg[0].tx_gain[i],i);
LOG_I(HW,"USRP TX_GAIN:%3.2lf gain_range:%3.2lf tx_gain:%3.2lf\n", gain_range_tx.stop()-openair0_cfg[0].tx_gain[i], gain_range_tx.stop(), openair0_cfg[0].tx_gain[i]); LOG_I(HW,"USRP TX_GAIN:%3.2lf gain_range:%3.2lf tx_gain:%3.2lf\n", gain_range_tx.stop()-openair0_cfg[0].tx_gain[i], gain_range_tx.stop(), openair0_cfg[0].tx_gain[i]);
}
} }
}
//s->usrp->set_clock_source("external"); //s->usrp->set_clock_source("external");
//s->usrp->set_time_source("external"); //s->usrp->set_time_source("external");
// display USRP settings // display USRP settings
LOG_I(HW,"Actual master clock: %fMHz...\n",s->usrp->get_master_clock_rate()/1e6); LOG_I(HW,"Actual master clock: %fMHz...\n",s->usrp->get_master_clock_rate()/1e6);
LOG_I(HW,"Actual clock source %s...\n",s->usrp->get_clock_source(0).c_str()); LOG_I(HW,"Actual clock source %s...\n",s->usrp->get_clock_source(0).c_str());
LOG_I(HW,"Actual time source %s...\n",s->usrp->get_time_source(0).c_str()); LOG_I(HW,"Actual time source %s...\n",s->usrp->get_time_source(0).c_str());
sleep(1); sleep(1);
// create tx & rx streamer // create tx & rx streamer
uhd::stream_args_t stream_args_rx("sc16", "sc16"); uhd::stream_args_t stream_args_rx("sc16", "sc16");
int samples=openair0_cfg[0].sample_rate; int samples=openair0_cfg[0].sample_rate;
int max=s->usrp->get_rx_stream(stream_args_rx)->get_max_num_samps(); int max=s->usrp->get_rx_stream(stream_args_rx)->get_max_num_samps();
samples/=10000; samples/=10000;
LOG_I(HW,"RF board max packet size %u, size for 100µs jitter %d \n", max, samples); LOG_I(HW,"RF board max packet size %u, size for 100µs jitter %d \n", max, samples);
if ( samples < max ) { if ( samples < max ) {
stream_args_rx.args["spp"] = str(boost::format("%d") % samples ); stream_args_rx.args["spp"] = str(boost::format("%d") % samples );
} }
LOG_I(HW,"rx_max_num_samps %zu\n", LOG_I(HW,"rx_max_num_samps %zu\n",
s->usrp->get_rx_stream(stream_args_rx)->get_max_num_samps()); s->usrp->get_rx_stream(stream_args_rx)->get_max_num_samps());
for (int i = 0; i<openair0_cfg[0].rx_num_channels; i++) for (int i = 0; i<openair0_cfg[0].rx_num_channels; i++)
stream_args_rx.channels.push_back(i); stream_args_rx.channels.push_back(i);
s->rx_stream = s->usrp->get_rx_stream(stream_args_rx); s->rx_stream = s->usrp->get_rx_stream(stream_args_rx);
uhd::stream_args_t stream_args_tx("sc16", "sc16"); uhd::stream_args_t stream_args_tx("sc16", "sc16");
for (int i = 0; i<openair0_cfg[0].tx_num_channels; i++) for (int i = 0; i<openair0_cfg[0].tx_num_channels; i++)
stream_args_tx.channels.push_back(i); stream_args_tx.channels.push_back(i);
s->tx_stream = s->usrp->get_tx_stream(stream_args_tx); s->tx_stream = s->usrp->get_tx_stream(stream_args_tx);
/* Setting TX/RX BW after streamers are created due to USRP calibration issue */ /* Setting TX/RX BW after streamers are created due to USRP calibration issue */
for(int i=0; i<((int) s->usrp->get_tx_num_channels()) && i<openair0_cfg[0].tx_num_channels; i++) for(int i=0; i<((int) s->usrp->get_tx_num_channels()) && i<openair0_cfg[0].tx_num_channels; i++)
s->usrp->set_tx_bandwidth(openair0_cfg[0].tx_bw,i); s->usrp->set_tx_bandwidth(openair0_cfg[0].tx_bw,i);
for(int i=0; i<((int) s->usrp->get_rx_num_channels()) && i<openair0_cfg[0].rx_num_channels; i++) for(int i=0; i<((int) s->usrp->get_rx_num_channels()) && i<openair0_cfg[0].rx_num_channels; i++)
s->usrp->set_rx_bandwidth(openair0_cfg[0].rx_bw,i); s->usrp->set_rx_bandwidth(openair0_cfg[0].rx_bw,i);
for (int i=0; i<openair0_cfg[0].rx_num_channels; i++) { for (int i=0; i<openair0_cfg[0].rx_num_channels; i++) {
LOG_I(HW,"RX Channel %d\n",i); LOG_I(HW,"RX Channel %d\n",i);
LOG_I(HW," Actual RX sample rate: %fMSps...\n",s->usrp->get_rx_rate(i)/1e6); LOG_I(HW," Actual RX sample rate: %fMSps...\n",s->usrp->get_rx_rate(i)/1e6);
LOG_I(HW," Actual RX frequency: %fGHz...\n", s->usrp->get_rx_freq(i)/1e9); LOG_I(HW," Actual RX frequency: %fGHz...\n", s->usrp->get_rx_freq(i)/1e9);
LOG_I(HW," Actual RX gain: %f...\n", s->usrp->get_rx_gain(i)); LOG_I(HW," Actual RX gain: %f...\n", s->usrp->get_rx_gain(i));
LOG_I(HW," Actual RX bandwidth: %fM...\n", s->usrp->get_rx_bandwidth(i)/1e6); LOG_I(HW," Actual RX bandwidth: %fM...\n", s->usrp->get_rx_bandwidth(i)/1e6);
LOG_I(HW," Actual RX antenna: %s...\n", s->usrp->get_rx_antenna(i).c_str()); LOG_I(HW," Actual RX antenna: %s...\n", s->usrp->get_rx_antenna(i).c_str());
} }
for (int i=0; i<openair0_cfg[0].tx_num_channels; i++) { for (int i=0; i<openair0_cfg[0].tx_num_channels; i++) {
LOG_I(HW,"TX Channel %d\n",i); LOG_I(HW,"TX Channel %d\n",i);
LOG_I(HW," Actual TX sample rate: %fMSps...\n", s->usrp->get_tx_rate(i)/1e6); LOG_I(HW," Actual TX sample rate: %fMSps...\n", s->usrp->get_tx_rate(i)/1e6);
LOG_I(HW," Actual TX frequency: %fGHz...\n", s->usrp->get_tx_freq(i)/1e9); LOG_I(HW," Actual TX frequency: %fGHz...\n", s->usrp->get_tx_freq(i)/1e9);
LOG_I(HW," Actual TX gain: %f...\n", s->usrp->get_tx_gain(i)); LOG_I(HW," Actual TX gain: %f...\n", s->usrp->get_tx_gain(i));
LOG_I(HW," Actual TX bandwidth: %fM...\n", s->usrp->get_tx_bandwidth(i)/1e6); LOG_I(HW," Actual TX bandwidth: %fM...\n", s->usrp->get_tx_bandwidth(i)/1e6);
LOG_I(HW," Actual TX antenna: %s...\n", s->usrp->get_tx_antenna(i).c_str()); LOG_I(HW," Actual TX antenna: %s...\n", s->usrp->get_tx_antenna(i).c_str());
LOG_I(HW," Actual TX packet size: %lu\n",s->tx_stream->get_max_num_samps()); LOG_I(HW," Actual TX packet size: %lu\n",s->tx_stream->get_max_num_samps());
} }
LOG_I(HW,"Device timestamp: %f...\n", s->usrp->get_time_now().get_real_secs()); LOG_I(HW,"Device timestamp: %f...\n", s->usrp->get_time_now().get_real_secs());
device->trx_write_func = trx_usrp_write; device->trx_write_func = trx_usrp_write;
device->trx_read_func = trx_usrp_read; device->trx_read_func = trx_usrp_read;
s->sample_rate = openair0_cfg[0].sample_rate; s->sample_rate = openair0_cfg[0].sample_rate;
// TODO: // TODO:
// init tx_forward_nsamps based usrp_time_offset ex // init tx_forward_nsamps based usrp_time_offset ex
if(is_equal(s->sample_rate, (double)30.72e6)) if(is_equal(s->sample_rate, (double)30.72e6))
s->tx_forward_nsamps = 176; s->tx_forward_nsamps = 176;
if(is_equal(s->sample_rate, (double)15.36e6)) if(is_equal(s->sample_rate, (double)15.36e6))
s->tx_forward_nsamps = 90; s->tx_forward_nsamps = 90;
if(is_equal(s->sample_rate, (double)7.68e6)) if(is_equal(s->sample_rate, (double)7.68e6))
s->tx_forward_nsamps = 50; s->tx_forward_nsamps = 50;
recplay_state_t *recPlay=device->recplay_state; recplay_state_t *recPlay=device->recplay_state;
...@@ -1329,8 +1349,8 @@ extern "C" { ...@@ -1329,8 +1349,8 @@ extern "C" {
std::cerr<< "Memory allocation failed for subframe record or replay mode." << std::endl; std::cerr<< "Memory allocation failed for subframe record or replay mode." << std::endl;
exit(-1); exit(-1);
} }
}
return 0;
} }
/*@}*/ return 0;
}
/*@}*/
}/* extern c */ }/* extern c */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment