Delete unused files
This commit is contained in:
Robert Schmidt
@@ -1,944 +0,0 @@
|
||||
/*
|
||||
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
|
||||
* contributor license agreements. See the NOTICE file distributed with
|
||||
* this work for additional information regarding copyright ownership.
|
||||
* The OpenAirInterface Software Alliance licenses this file to You under
|
||||
* the OAI Public License, Version 1.1 (the "License"); you may not use this file
|
||||
* except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.openairinterface.org/?page_id=698
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*-------------------------------------------------------------------------------
|
||||
* For more information about the OpenAirInterface (OAI) Software Alliance:
|
||||
* contact@openairinterface.org
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <sched.h>
|
||||
#include <linux/sched.h>
|
||||
#include <signal.h>
|
||||
#include <execinfo.h>
|
||||
#include <getopt.h>
|
||||
#include <syscall.h>
|
||||
#include <sys/sysinfo.h>
|
||||
|
||||
#include "assertions.h"
|
||||
#include "PHY/types.h"
|
||||
|
||||
#include "PHY/defs.h"
|
||||
|
||||
#include <sys/time.h>
|
||||
#define GET_TIME_INIT(num) struct timeval _timers[num]
|
||||
#define GET_TIME_VAL(num) gettimeofday(&_timers[num], NULL)
|
||||
#define TIME_VAL_TO_MS(num) (((double)_timers[num].tv_sec*1000.0) + ((double)_timers[num].tv_usec/1000.0))
|
||||
|
||||
#undef MALLOC //there are two conflicting definitions, so we better make sure we don't use it at all
|
||||
//#undef FRAME_LENGTH_COMPLEX_SAMPLES //there are two conflicting definitions, so we better make sure we don't use it at all
|
||||
|
||||
#include "../../ARCH/COMMON/common_lib.h"
|
||||
|
||||
#include "PHY/extern.h"
|
||||
#include "SCHED/extern.h"
|
||||
#include "LAYER2/MAC/extern.h"
|
||||
#include "LAYER2/MAC/proto.h"
|
||||
|
||||
#define SYRIQ_CHANNEL_TESTER 0
|
||||
#define SYRIQ_CHANNEL_TESTER2 0
|
||||
#define SYRIQ_CHANNEL_DATA1 1
|
||||
|
||||
volatile int oai_exit = 0;
|
||||
|
||||
openair0_config_t openair0_cfg[MAX_CARDS];
|
||||
|
||||
#if 0
|
||||
#define NB_ANTENNAS_RX 4
|
||||
|
||||
#define DevAssert(cOND) _Assert_(cOND, _Assert_Exit_, "")
|
||||
#define malloc16(x) memalign(16,x)
|
||||
|
||||
#ifdef 0
|
||||
static inline void* malloc16_clear( size_t size )
|
||||
{
|
||||
#ifdef __AVX2__
|
||||
void* ptr = memalign(32, size);
|
||||
#else
|
||||
void* ptr = memalign(16, size);
|
||||
#endif
|
||||
if(ptr)
|
||||
memset( ptr, 0, size );
|
||||
return ptr;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
typedef struct latency_stat {
|
||||
uint64_t counter;
|
||||
|
||||
uint64_t stat250;
|
||||
uint64_t stat500;
|
||||
uint64_t stat600;
|
||||
uint64_t stat700;
|
||||
uint64_t stat800;
|
||||
|
||||
uint64_t stat1300;
|
||||
uint64_t stat1500;
|
||||
uint64_t stat2000;
|
||||
uint64_t stat2500;
|
||||
uint64_t stat3000;
|
||||
|
||||
uint64_t stat880;
|
||||
uint64_t stat960;
|
||||
uint64_t stat1040;
|
||||
uint64_t stat1120;
|
||||
uint64_t stat1200;
|
||||
} latency_stat_t;
|
||||
|
||||
|
||||
typedef struct timing_stats {
|
||||
char *name;
|
||||
double min;
|
||||
double max;
|
||||
double total;
|
||||
unsigned int count;
|
||||
} timing_stats_t;
|
||||
|
||||
|
||||
//static struct timespec get_timespec_diff(
|
||||
// struct timespec *start,
|
||||
// struct timespec *stop )
|
||||
//{
|
||||
// struct timespec result;
|
||||
//
|
||||
// if ( ( stop->tv_nsec - start->tv_nsec ) < 0 ) {
|
||||
// result.tv_sec = stop->tv_sec - start->tv_sec - 1;
|
||||
// result.tv_nsec = stop->tv_nsec - start->tv_nsec + 1000000000;
|
||||
// }
|
||||
// else {
|
||||
// result.tv_sec = stop->tv_sec - start->tv_sec;
|
||||
// result.tv_nsec = stop->tv_nsec - start->tv_nsec;
|
||||
// }
|
||||
//
|
||||
// return result;
|
||||
//}
|
||||
|
||||
|
||||
//static void measure_time (
|
||||
// openair0_device *rf_device,
|
||||
// struct timespec *start,
|
||||
// struct timespec *stop,
|
||||
// timing_stats_t *stats,
|
||||
// boolean_t START,
|
||||
// uint8_t PRINT_INTERVAL )
|
||||
//{
|
||||
// if ( START ) {
|
||||
// clock_gettime( CLOCK_MONOTONIC, start );
|
||||
// }
|
||||
// else {
|
||||
// clock_gettime( CLOCK_MONOTONIC, stop );
|
||||
//
|
||||
// struct timespec diff;
|
||||
// double current = 0;
|
||||
//// boolean_t show_stats = false;
|
||||
//
|
||||
// diff = get_timespec_diff( start, stop );
|
||||
// current = (double)diff.tv_sec * 1000000 + (double)diff.tv_nsec / 1000;
|
||||
//
|
||||
// if ( current > stats->max ) {
|
||||
// stats->max = current;
|
||||
//// show_stats = true;
|
||||
// }
|
||||
// if ( stats->min == 0 || current < stats->min ) {
|
||||
// stats->min = current;
|
||||
//// show_stats = true;
|
||||
// }
|
||||
// stats->total += current;
|
||||
//
|
||||
//// if ( show_stats ) {
|
||||
//// rf_device.trx_get_stats_func( &rf_device );
|
||||
//// }
|
||||
//
|
||||
//// if ( stats->count % PRINT_INTERVAL == 0 ) {
|
||||
//// double avg = stats->total / ( stats->count + 1 );
|
||||
//// printf( "[%s][%d] Current : %.2lf µs, Min : %.2lf µs, Max : %.2lf µs, Avg : %.2lf µs\n",
|
||||
//// stats->count, stats->name, current, stats->min, stats->max, avg );
|
||||
//// }
|
||||
//
|
||||
// stats->count++;
|
||||
// }
|
||||
//}
|
||||
int32_t **rxdata;
|
||||
int32_t **txdata;
|
||||
|
||||
int setup_ue_buffers(PHY_VARS_UE **phy_vars_ue, openair0_config_t *openair0_cfg);
|
||||
|
||||
static inline void saif_meas(unsigned int frame_rx, unsigned int subframe_rx) {
|
||||
static latency_stat_t __thread latency_stat;
|
||||
static struct timespec __thread last= {0};
|
||||
struct timespec now;
|
||||
clock_gettime(CLOCK_MONOTONIC_RAW, &now);
|
||||
if ( last.tv_sec ) {
|
||||
uint64_t diffTime = ((uint64_t)now.tv_sec *1000 *1000 *1000 + now.tv_nsec) -
|
||||
((uint64_t)last.tv_sec *1000 *1000 *1000 + last.tv_nsec);
|
||||
diffTime/=1000;
|
||||
latency_stat.counter++;
|
||||
|
||||
if ( diffTime <= 800 ) {
|
||||
if (diffTime < 250 )
|
||||
latency_stat.stat250++;
|
||||
else if (diffTime < 500 )
|
||||
latency_stat.stat500++;
|
||||
else if (diffTime < 600 )
|
||||
latency_stat.stat600++;
|
||||
else if (diffTime < 700 )
|
||||
latency_stat.stat700++;
|
||||
else
|
||||
latency_stat.stat800++;
|
||||
}
|
||||
else if ( diffTime > 1200 ) {
|
||||
if (diffTime < 1500 )
|
||||
latency_stat.stat1300++;
|
||||
else if ( diffTime < 2000 )
|
||||
latency_stat.stat1500++;
|
||||
else if ( diffTime < 2500 )
|
||||
latency_stat.stat2000++;
|
||||
else if ( diffTime < 3000 )
|
||||
latency_stat.stat2500++;
|
||||
else
|
||||
latency_stat.stat3000++;
|
||||
}
|
||||
else
|
||||
if (diffTime <= 880 )
|
||||
latency_stat.stat880++;
|
||||
else if (diffTime <= 960 )
|
||||
latency_stat.stat960++;
|
||||
else if (diffTime <= 1040 )
|
||||
latency_stat.stat1040++;
|
||||
else if (diffTime < 1120 )
|
||||
latency_stat.stat1120++;
|
||||
else
|
||||
latency_stat.stat1200++;
|
||||
|
||||
|
||||
if ( (diffTime>=1500) || ( !(frame_rx%1024) && subframe_rx == 0 ) ) {
|
||||
time_t current=time(NULL);
|
||||
printf("\n");
|
||||
printf("%.2f Period stats cnt=%7.7ld 0.. 250=%7.7ld 250.. 500=%7.7ld 500.. 600=%7.7ld 600.. 700=%7.7ld 700.. 800=%7.7ld - (frame_rx=%u) - %s",
|
||||
now.tv_sec+(double)now.tv_nsec/1e9,
|
||||
latency_stat.counter,
|
||||
latency_stat.stat250, latency_stat.stat500,
|
||||
latency_stat.stat600, latency_stat.stat700,
|
||||
latency_stat.stat800,
|
||||
frame_rx,
|
||||
ctime(¤t));
|
||||
printf("%.2f Period stats cnt=%7.7ld 800.. 880=%7.7ld 880.. 960=%7.7ld 960..1040=%7.7ld 1040..1120=%7.7ld 1120..1200=%7.7ld - (frame_rx=%u) - %s",
|
||||
now.tv_sec+(double)now.tv_nsec/1e9,
|
||||
latency_stat.counter,
|
||||
latency_stat.stat880, latency_stat.stat960,
|
||||
latency_stat.stat1040, latency_stat.stat1120,
|
||||
latency_stat.stat1200,
|
||||
frame_rx,
|
||||
ctime(¤t));
|
||||
printf("%.2f Period stats cnt=%7.7ld 1200..1300=%7.7ld 1300..1500=%7.7ld 1500..2000=%7.7ld 2000..2500=%7.7ld >3000=%7.7ld - (frame_rx=%u) - %s",
|
||||
now.tv_sec+(double)now.tv_nsec/1e9,
|
||||
latency_stat.counter,
|
||||
latency_stat.stat1300, latency_stat.stat1500,
|
||||
latency_stat.stat2000, latency_stat.stat2500,
|
||||
latency_stat.stat3000,
|
||||
frame_rx,
|
||||
ctime(¤t));
|
||||
fflush(stdout);
|
||||
}
|
||||
}
|
||||
last=now;
|
||||
}
|
||||
/* End of Changed by SYRTEM */
|
||||
|
||||
void exit_fun(const char* s)
|
||||
{
|
||||
|
||||
if (s != NULL) {
|
||||
printf("%s %s() Exiting OAI softmodem: %s\n",__FILE__, __FUNCTION__, s);
|
||||
}
|
||||
|
||||
oai_exit = 1;
|
||||
|
||||
}
|
||||
|
||||
|
||||
void init_thread(int sched_runtime, int sched_deadline, int sched_fifo, char * name) {
|
||||
|
||||
#ifdef DEADLINE_SCHEDULER
|
||||
if (sched_runtime!=0) {
|
||||
struct sched_attr attr= {0};
|
||||
attr.size = sizeof(attr);
|
||||
// This creates a .5 ms fpga_recv_cnt reservation
|
||||
attr.sched_policy = SCHED_DEADLINE;
|
||||
attr.sched_runtime = sched_runtime;
|
||||
attr.sched_deadline = sched_deadline;
|
||||
attr.sched_period = 0;
|
||||
AssertFatal(sched_setattr(0, &attr, 0) == 0,
|
||||
"[SCHED] main eNB thread: sched_setattr failed %s \n",perror(errno));
|
||||
LOG_I(HW,"[SCHED][eNB] eNB main deadline thread %lu started on CPU %d\n",
|
||||
(unsigned long)gettid(), sched_getcpu());
|
||||
}
|
||||
|
||||
#else
|
||||
#ifdef CPU_AFFINITY
|
||||
if (get_nprocs() >2) {
|
||||
for (j = 1; j < get_nprocs(); j++)
|
||||
CPU_SET(j, &cpuset);
|
||||
}
|
||||
AssertFatal( 0 == pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset)==0,"");
|
||||
#endif
|
||||
struct sched_param sp;
|
||||
sp.sched_priority = sched_fifo;
|
||||
AssertFatal(pthread_setschedparam(pthread_self(),SCHED_FIFO,&sp)==0,
|
||||
"Can't set thread priority, Are you root?\n");
|
||||
#endif
|
||||
|
||||
// Lock memory from swapping. This is a process wide call (not constraint to this thread).
|
||||
mlockall(MCL_CURRENT | MCL_FUTURE);
|
||||
pthread_setname_np( pthread_self(), name );
|
||||
|
||||
}
|
||||
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int ret;
|
||||
uint64_t i;
|
||||
openair0_device rf_device;
|
||||
openair0_timestamp timestamp = 0;
|
||||
|
||||
unsigned int sub_frame = 0;
|
||||
unsigned int frame_rx = 0;
|
||||
|
||||
unsigned int nb_antennas_tx = 1;
|
||||
unsigned int nb_antennas_rx = 1;
|
||||
|
||||
|
||||
openair0_cfg[0].mmapped_dma = 0;
|
||||
openair0_cfg[0].configFilename = NULL;
|
||||
openair0_cfg[0].duplex_mode = duplex_mode_FDD;
|
||||
|
||||
uint32_t **sendbuff = NULL;
|
||||
uint32_t **recvbuff = NULL;
|
||||
uint32_t expected_value = 0;
|
||||
uint32_t received_value = 0;
|
||||
int nsamp = 0; // 1 ms
|
||||
int antenna_id = 1;
|
||||
int c = 0;
|
||||
int numIter = 0;
|
||||
int fpga_loop = 0;
|
||||
#if SYRIQ_CHANNEL_DATA1
|
||||
uint64_t first_ts = 0;
|
||||
uint8_t is_first_ts = 0;
|
||||
uint64_t trx_read_cnt = 0;
|
||||
uint32_t j = 0;
|
||||
uint32_t err_cnt = 0;
|
||||
#else
|
||||
int failure = 0;
|
||||
#endif
|
||||
#if 0 // 5MHz BW
|
||||
unsigned int nb_sample_per_tti = 7680;
|
||||
openair0_cfg[0].sample_rate = 7.68e6;
|
||||
openair0_cfg[0].samples_per_frame = nb_sample_per_tti*10;
|
||||
openair0_cfg[0].rx_bw = 2.5e6;
|
||||
openair0_cfg[0].tx_bw = 2.5e6;
|
||||
openair0_cfg[0].num_rb_dl = 25;
|
||||
#endif
|
||||
|
||||
#if 0 // 10MHz BW
|
||||
unsigned int nb_sample_per_tti = 15360;
|
||||
openair0_cfg[0].sample_rate = 15.36e6;
|
||||
openair0_cfg[0].samples_per_frame = nb_sample_per_tti*10;
|
||||
openair0_cfg[0].rx_bw = 5.0e6;
|
||||
openair0_cfg[0].tx_bw = 5.0e6;
|
||||
openair0_cfg[0].num_rb_dl = 50;
|
||||
#endif
|
||||
|
||||
#if 1 // 20MHz BW
|
||||
unsigned int nb_sample_per_tti = 30720;
|
||||
openair0_cfg[0].sample_rate = 30.72e6;
|
||||
openair0_cfg[0].samples_per_frame = nb_sample_per_tti*10;
|
||||
openair0_cfg[0].rx_bw = 10.0e6;
|
||||
openair0_cfg[0].tx_bw = 10.0e6;
|
||||
openair0_cfg[0].num_rb_dl = 100;
|
||||
#endif
|
||||
|
||||
const char *openair_dir = getenv("OPENAIR_DIR");
|
||||
const char *ini_file = "/usr/local/etc/syriq/ue.band7.tm1.PRB100.NR20.dat";
|
||||
|
||||
int readBlockSize;
|
||||
void* rxp[nb_antennas_rx];
|
||||
void* txp[nb_antennas_tx];
|
||||
|
||||
// int32_t rxdata[1][nb_sample_per_tti*10+2048];
|
||||
#if 0
|
||||
int32_t **rxdata;
|
||||
#endif
|
||||
// init_thread(100000, 500000, sched_get_priority_max(SCHED_FIFO),"main UE");
|
||||
|
||||
printf("LTE HARDWARE Latency debug utility \n");
|
||||
printf("INIT data buffers \n");
|
||||
|
||||
#if 0
|
||||
rxdata = (int32_t**)memalign(32, nb_antennas_rx*sizeof(int32_t*) );
|
||||
rxdata[0] = (int32_t*)memalign(32,(nb_sample_per_tti*10+2048)*sizeof(int32_t));
|
||||
#else
|
||||
rxdata = (int32_t**)malloc16( nb_antennas_rx*sizeof(int32_t*) );
|
||||
txdata = (int32_t**)malloc16( nb_antennas_tx*sizeof(int32_t*) );
|
||||
rxdata[0] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
|
||||
txdata[0] = (int32_t*)malloc16_clear( 307200*sizeof(int32_t) );
|
||||
#endif
|
||||
|
||||
printf("INIT done\n");
|
||||
|
||||
memset(&rf_device, 0, sizeof(openair0_device));
|
||||
|
||||
rf_device.host_type = BBU_HOST;
|
||||
openair0_cfg[0].duplex_mode = duplex_mode_FDD;
|
||||
openair0_cfg[0].rx_num_channels = 1;
|
||||
openair0_cfg[0].tx_num_channels = 1;
|
||||
|
||||
// configure channel 0
|
||||
for (i=0; i<openair0_cfg[0].rx_num_channels; i++)
|
||||
{
|
||||
printf("configure channel %d \n",i);
|
||||
openair0_cfg[0].autocal[i] = 1;
|
||||
openair0_cfg[0].rx_freq[i] = 2680000000;
|
||||
openair0_cfg[0].tx_freq[i] = 2560000000;
|
||||
openair0_cfg[0].rx_gain[i] = 61;
|
||||
openair0_cfg[0].tx_gain[i] = 90;
|
||||
}
|
||||
|
||||
if (openair_dir)
|
||||
{
|
||||
openair0_cfg[0].configFilename = malloc(strlen(openair_dir) + strlen(ini_file) + 2);
|
||||
sprintf(openair0_cfg[0].configFilename, "%s/%s", openair_dir, ini_file);
|
||||
}
|
||||
// printf("openair0_cfg[0].configFilename:%s\n", openair0_cfg[0].configFilename);
|
||||
|
||||
ret = openair0_device_load( &rf_device, &openair0_cfg[0] );
|
||||
if (ret != 0){
|
||||
exit_fun("Error loading device library");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
/* Runtime test
|
||||
* 30 720 000 samples (4 bytes) for 1 sec (30 720 for 1 ms)
|
||||
*/
|
||||
puts( "* Starting the device" );
|
||||
|
||||
// TIMING
|
||||
// struct timespec start, stop; // tx_start, tx_stop;
|
||||
// timing_stats_t rx_stats, tx_stats;
|
||||
|
||||
// rx_stats.name = strdup( "RX" );
|
||||
// tx_stats.name = strdup( "TX" );
|
||||
// TIMING
|
||||
|
||||
nsamp = 307200; // 1 ms
|
||||
sendbuff = memalign( 128, nb_antennas_rx * sizeof( uint32_t * ) );
|
||||
sendbuff[0] = memalign( 128, nsamp * sizeof( uint32_t ) );
|
||||
recvbuff = memalign( 128, nb_antennas_rx * sizeof( uint32_t * ) );
|
||||
recvbuff[0] = memalign( 128, nsamp * sizeof( uint32_t ) );
|
||||
|
||||
// Create dummy buffer
|
||||
for ( c = 0; c < nsamp; c++ ) {
|
||||
// sendbuff[0][c] = (c+1);
|
||||
sendbuff[0][c] = (c+1)*16;
|
||||
// sendbuff[0][c] = (nsamp-c);
|
||||
recvbuff[0][c] = 0;
|
||||
}
|
||||
|
||||
GET_TIME_INIT(3);
|
||||
|
||||
if ( rf_device.trx_start_func( &rf_device ) < 0 ) {
|
||||
printf( " device could not be started !\n" );
|
||||
return -1;
|
||||
}
|
||||
|
||||
// read 30720
|
||||
|
||||
// write 30720 ts+2*30720
|
||||
|
||||
// if tsread >= 2-307200 -> check expected value + status (RxoVer TxUnder)
|
||||
|
||||
rxp[0] = (void*)&rxdata[0][0];
|
||||
txp[0] = (void*)&txdata[0][0];
|
||||
timestamp = 0;
|
||||
nsamp = 30720; // 30720 => 1ms buffer
|
||||
trx_read_cnt = 100000; // 1 loop => 1ms (10sec=10000; 15min = 900000)
|
||||
antenna_id = 1;
|
||||
int diff = 0;
|
||||
int compare_start = 0;
|
||||
|
||||
uint32_t looploop=0;
|
||||
uint64_t error_cnt = 0;
|
||||
uint64_t error_ts_start;
|
||||
|
||||
for (i = 0; i < trx_read_cnt; i++)
|
||||
{
|
||||
|
||||
// printf("\n\n");
|
||||
|
||||
|
||||
// ret = rf_device.trx_read_func( &rf_device, ×tamp, &(rxp[0][(i*30720)%307200]), nsamp, antenna_id );
|
||||
// ret = rf_device.trx_read_func( &rf_device, ×tamp, recvbuff[0][(i*30720)%307200], nsamp, antenna_id );
|
||||
rxp[0] = (void*)&rxdata[0][(i*30720)%307200];
|
||||
GET_TIME_VAL(0);
|
||||
ret = rf_device.trx_read_func( &rf_device, ×tamp, rxp, nsamp, antenna_id );
|
||||
GET_TIME_VAL(1);
|
||||
|
||||
if (ret != nsamp)
|
||||
{
|
||||
printf("Error: nsamp received (%d) != nsamp required (%d)\n", ret, nsamp);
|
||||
fflush(stdout);
|
||||
return (-1);
|
||||
}
|
||||
if (!is_first_ts)
|
||||
{
|
||||
first_ts = timestamp;
|
||||
is_first_ts = 1;
|
||||
}
|
||||
|
||||
// printf("%d - trx_read_func ret=%d - ts = %d - @=0x%08lx\n", i, ret, timestamp, rxp[0] );
|
||||
|
||||
txp[0] = (void*)&(txdata[0][ ((i*30720)%307200+2*30720)%307200 ]);
|
||||
// printf(" i=%d @txp[0][0] = 0x%016lx\n", i, &(((uint32_t *)txp[0])[0]) );
|
||||
// printf(" i=%d @txp[0][1] = 0x%016lx\n", i, &(((uint32_t *)txp[0])[1]) );
|
||||
|
||||
for ( c = 0; c < nsamp; c++ )
|
||||
{
|
||||
(((uint32_t *)txp[0])[c]) = ( (((timestamp+c+2*30720)<<4)&0x0000FFF0) + (((timestamp+c+2*30720)<<8)&0xFFF00000) );
|
||||
}
|
||||
|
||||
// printf(" txp[0][%d] = 0x%x\n",0,((uint32_t *)(txp[0]))[0]);
|
||||
// printf(" txp[0][%d] = 0x%x\n",1,((uint32_t *)(txp[0]))[1]);
|
||||
// printf(" ...\n");
|
||||
// printf(" txp[0][%d] = 0x%x\n",nsamp-2,((uint32_t *)(txp[0]))[nsamp-2]);
|
||||
// printf(" txp[0][%d] = 0x%x\n",nsamp-1,((uint32_t *)(txp[0]))[nsamp-1]);
|
||||
|
||||
|
||||
ret = rf_device.trx_write_func( &rf_device, (timestamp+2*30720), txp, nsamp, antenna_id, false );
|
||||
if (ret != nsamp)
|
||||
{
|
||||
printf("Error: nsamp sent (%d) != nsamp required (%d)\n", ret, nsamp);
|
||||
fflush(stdout);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
// printf("%d - trx_write_func ret=%d - ts = %d - @=0x%08lx\n", i, ret, (timestamp+2*30720), txp[0] );
|
||||
|
||||
|
||||
if (timestamp >= (first_ts + 2 * 307200))
|
||||
{
|
||||
|
||||
// check Rx Overflow
|
||||
|
||||
// check Tx Underflow
|
||||
|
||||
// check Expected Value
|
||||
for ( c = 0; c < nsamp; c++ )
|
||||
{
|
||||
|
||||
// LOOPBACK
|
||||
#if 1
|
||||
expected_value = ((timestamp + c)&0xFFFFFF);
|
||||
received_value = ((uint32_t *)(rxp[0]))[c];
|
||||
received_value = ((received_value)&0xFFF) + ((received_value>>4)&0xFFF000);
|
||||
|
||||
if (compare_start == 0)
|
||||
{
|
||||
compare_start = 1;
|
||||
diff = expected_value - received_value;
|
||||
}
|
||||
received_value = (received_value + diff)&0xFFFFFF;
|
||||
|
||||
#if 1
|
||||
|
||||
if (expected_value != received_value)
|
||||
{
|
||||
if(!error_cnt)
|
||||
error_ts_start = (timestamp + c);
|
||||
else
|
||||
{
|
||||
if (looploop < 32)
|
||||
printf("%d - %d != %d - ts %d - raw 0x%x - diff %d\n",
|
||||
looploop,
|
||||
expected_value, received_value,
|
||||
(timestamp + c), ((uint32_t *)(rxp[0]))[c],
|
||||
diff);
|
||||
looploop++;
|
||||
}
|
||||
|
||||
error_cnt++;
|
||||
|
||||
if(!(error_cnt%102400))
|
||||
printf(" -> error detected : cnt=%d - start=%ld - stop=... diff=%d\n",
|
||||
error_cnt,
|
||||
error_ts_start,
|
||||
diff);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
if(error_cnt)
|
||||
{
|
||||
printf(" -> error detected : cnt=%d - start=%ld - stop=%ld\n\n",
|
||||
error_cnt,
|
||||
error_ts_start,
|
||||
(timestamp + c) );
|
||||
looploop=0;
|
||||
}
|
||||
error_cnt=0;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// DEBUG mode 0
|
||||
#if 0
|
||||
received_value = ((uint32_t *)(rxp[0]))[c];
|
||||
received_value = ((received_value)&0xFFF) + ((received_value>>4)&0xFFF000);
|
||||
received_value = (received_value&0xFFFFFF);
|
||||
if (compare_start == 0)
|
||||
{
|
||||
compare_start = 1;
|
||||
expected_value = received_value;
|
||||
}
|
||||
else
|
||||
{
|
||||
expected_value++;
|
||||
expected_value = (expected_value&0xFFFFFF);
|
||||
}
|
||||
|
||||
if (expected_value != received_value)
|
||||
{
|
||||
if(!error_cnt)
|
||||
error_ts_start = (timestamp + c);
|
||||
error_cnt++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(error_cnt)
|
||||
{
|
||||
printf(" -> error detected : cnt=%d - start=%ld - stop=%ld\n\n",
|
||||
error_cnt,
|
||||
error_ts_start,
|
||||
(timestamp + c) );
|
||||
}
|
||||
error_cnt=0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// if (expected_value != received_value)
|
||||
// {
|
||||
// printf("%d -> %d != %d (ts+c=%ld)(raw=0x%08x)\n",
|
||||
// looploop,
|
||||
// expected_value, received_value,
|
||||
// (timestamp + c),
|
||||
// ((uint32_t *)(rxp[0]))[c] );
|
||||
//
|
||||
// if (received_value)
|
||||
// expected_value = received_value;
|
||||
// }
|
||||
#endif
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
printf("HwLat Application returns !!!\n");
|
||||
fflush(stdout);
|
||||
sleep(1);
|
||||
|
||||
|
||||
printf("\n");
|
||||
rf_device.trx_end_func( &rf_device );
|
||||
|
||||
sleep(1);
|
||||
free(sendbuff[0]);
|
||||
free(sendbuff);
|
||||
free(recvbuff[0]);
|
||||
free(recvbuff);
|
||||
|
||||
exit(0);
|
||||
|
||||
|
||||
|
||||
return(0);
|
||||
|
||||
|
||||
|
||||
// puts( "* Frequency modification test" );
|
||||
// rf_device.trx_set_freq_func( &rf_device, &openair0_cfg[0], 0 );
|
||||
|
||||
// puts( "* Gain modification test" );
|
||||
// rf_device.trx_set_gains_func( &rf_device, &openair0_cfg[0] ); // NOT working (cf. initialization)
|
||||
|
||||
//#if LTE_UE
|
||||
// sleep(1);
|
||||
GET_TIME_VAL(0);
|
||||
for (i = 0; i < trx_read_cnt; i++)
|
||||
{
|
||||
printf("\n");
|
||||
ret = rf_device.trx_read_func( &rf_device, ×tamp, rxp, nsamp, antenna_id );
|
||||
printf("* timestamp=%ld\n", timestamp);
|
||||
#if 1
|
||||
for (j = 0; j < nsamp; j++)
|
||||
{
|
||||
if ( ((uint32_t *)rxp[0])[j] != ((expected_value + j + timestamp)%307200) )
|
||||
{
|
||||
err_cnt++;
|
||||
printf("rxp[%06d]=0x%08x (expected 0x%08lx)\n", j, ((uint32_t *)rxp[0])[j], ((expected_value + j + timestamp)%307200) );
|
||||
}
|
||||
if (err_cnt >= 128)
|
||||
{
|
||||
printf("Error: more than 128 expected value failed !\n");
|
||||
i = (trx_read_cnt - 1);
|
||||
j = nsamp;
|
||||
break;
|
||||
}
|
||||
}
|
||||
//expected_value = (expected_value + nsamp)%307200;
|
||||
expected_value = (expected_value)%307200;
|
||||
#endif
|
||||
}
|
||||
GET_TIME_VAL(1);
|
||||
//#endif
|
||||
|
||||
/* ********** ********** */
|
||||
/* SYRIQ_CHANNEL_DATA1 */
|
||||
/* ********** ********** */
|
||||
#if SYRIQ_CHANNEL_DATA1
|
||||
|
||||
// rf_device.trx_get_stats_func( &rf_device );
|
||||
|
||||
rf_device.trx_end_func( &rf_device );
|
||||
|
||||
printf("\n* rf_device.trx_read_func(%d) x %d: %.6lf s\n\n", nsamp, i, ((TIME_VAL_TO_MS(1) - TIME_VAL_TO_MS(0)))/1000.0 );
|
||||
|
||||
// rf_device.trx_get_stats_func( &rf_device );
|
||||
|
||||
#if 0
|
||||
for (i = 0; i < nsamp; i++)
|
||||
{
|
||||
// if ( ((uint32_t *)rxp[0])[i] != i)
|
||||
// {
|
||||
err_cnt++;
|
||||
printf("rxp[%06d]=0x%08x (expected 0x%08x)\n", i, ((uint32_t *)rxp[0])[i], i);
|
||||
// }
|
||||
// if (err_cnt > 256)
|
||||
// {
|
||||
// i = 307200;
|
||||
// break;
|
||||
// }
|
||||
}
|
||||
#endif
|
||||
// for (i = 1024-32; i < 1024+32; i++)
|
||||
// {
|
||||
//// if ( ((uint32_t *)rxp[0])[i] != i)
|
||||
//// {
|
||||
// err_cnt++;
|
||||
// printf("rxp[%06d]=0x%08x (expected 0x%08x)\n", i, ((uint32_t *)rxp[0])[i], i);
|
||||
//// }
|
||||
// if (err_cnt > 256)
|
||||
// {
|
||||
// i = 307200;
|
||||
// break;
|
||||
// }
|
||||
// }
|
||||
printf("SYRIQ CHANNEL DATA1 done !!!\n");
|
||||
sleep(1);
|
||||
return(0);
|
||||
#endif
|
||||
/* ********** ********** */
|
||||
/* SYRIQ_CHANNEL_DATA1 */
|
||||
/* ********** ********** */
|
||||
|
||||
|
||||
|
||||
timestamp = 0;
|
||||
ret = rf_device.trx_write_func( &rf_device, timestamp, (void**)sendbuff, nsamp, antenna_id, false );
|
||||
printf("* rf_device.trx_write_func returns %d\n", ret);
|
||||
|
||||
sleep(1);
|
||||
|
||||
nsamp = 30720;
|
||||
numIter = 100000;
|
||||
for ( c = 0; c < numIter; c++ )
|
||||
{
|
||||
fpga_loop ++;
|
||||
if ( !(fpga_loop % 1000) )
|
||||
{
|
||||
printf("\rtest loop %d / %d", fpga_loop, numIter);
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
// printf("* TEST : %08d\n", (c+1));
|
||||
// measure_time( &rf_device, &start, &stop, &tx_stats, true, 10 );
|
||||
// ret = rf_device.trx_write_func( &rf_device, timestamp, (void**)sendbuff, nsamp, antenna_id, false );
|
||||
// printf("* rf_device.trx_write_func returns %d\n", ret);
|
||||
// measure_time( &rf_device, &start, &stop, &tx_stats, false, 10 );
|
||||
|
||||
// sleep(1);
|
||||
|
||||
// measure_time( &rf_device, &start, &stop, &tx_stats, true, 10 );
|
||||
ret = rf_device.trx_read_func( &rf_device, ×tamp, (void**)recvbuff, nsamp, antenna_id );
|
||||
// measure_time( &rf_device, &start, &stop, &tx_stats, false, 10 );
|
||||
|
||||
// Check the data
|
||||
if (ret > 0)
|
||||
{
|
||||
/* ********** ********** */
|
||||
/* SYRIQ_CHANNEL_TESTER */
|
||||
/* ********** ********** */
|
||||
#if SYRIQ_CHANNEL_TESTER
|
||||
failure = 0;
|
||||
for (i = 0; i < ret; i++)
|
||||
{
|
||||
if ( ((i%1024) == 0) || ((i%1024) == 1) || ((i%1024) == 2) || ((i%1024) == 3) )
|
||||
{
|
||||
if ( (recvbuff[0])[i] != (1020 + ((i%1024)+1)) )
|
||||
{
|
||||
printf("* ERROR (buff[0])[%d]: %d, expected %d\n", i, (uint32_t)(recvbuff[0])[i], ((i%1024)+1) );
|
||||
failure = 1;
|
||||
}
|
||||
}
|
||||
else if ( (recvbuff[0])[i] != ((i%1024)+1) )
|
||||
{
|
||||
printf("* ERROR (buff[0])[%d]: %d, expected %d\n", i, (uint32_t)(recvbuff[0])[i], ((i%1024)+1) );
|
||||
failure = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("* DONE (buff[0])[%d]: %d, expected %d\n", i, (uint32_t)(recvbuff[0])[i], ((i%1024)+1) );
|
||||
}
|
||||
if(failure)
|
||||
break;
|
||||
}
|
||||
if (failure)
|
||||
printf("* ERROR recv %08d checked FAILURE ret=%d\n", (c+1), ret);
|
||||
else
|
||||
{
|
||||
// printf("* DONE recv %08d checked SUCCESSFULLY ret=%d\n", (c+1), ret);
|
||||
}
|
||||
#endif
|
||||
/* ********** ********** */
|
||||
/* SYRIQ_CHANNEL_TESTER2*/
|
||||
/* ********** ********** */
|
||||
#if SYRIQ_CHANNEL_TESTER2
|
||||
// printf("* ret=%d timestamp=%ld (%ld)\n", ret, timestamp, (timestamp%307200));
|
||||
failure = 0;
|
||||
for (i = 0; i < ret; i++)
|
||||
{
|
||||
// printf("* (recvbuff[0])[%d]: %d\n", i, (uint32_t)(recvbuff[0])[i]);
|
||||
// printf("* timestamp+(i/1024+1)*1024 - 3 + i%1024: %d\n", (timestamp-nsamp+(i/1024+1)*1024 - 3 + i%1024)%307200 );
|
||||
expected_value = ((((i%1024)+1)/*>>4*/)&0x00000FFF);
|
||||
if ( ((i%1024) == 0) || ((i%1024) == 1) || ((i%1024) == 2) || ((i%1024) == 3) )
|
||||
{
|
||||
expected_value = ((((timestamp-nsamp+(i/1024+1)*1024 - 3 + i%1024))%307200));
|
||||
if ( (recvbuff[0])[i] != expected_value)
|
||||
{
|
||||
if ( (expected_value == 0) && ((recvbuff[0])[i] != 4915200) )
|
||||
{
|
||||
printf("* ERROR (buff[0])[%d]: %d, expected %d\n", i, (uint32_t)(recvbuff[0])[i], expected_value );
|
||||
failure = 1;
|
||||
}
|
||||
if ( (expected_value == 0) && ((recvbuff[0])[i] == 4915200) )
|
||||
{
|
||||
// printf("* DONE loop in circular buffer\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
else if ( (recvbuff[0])[i] != expected_value )
|
||||
{
|
||||
printf("* ERROR (buff[0])[%d]: %d, expected %d\n", i, (uint32_t)(recvbuff[0])[i], ((i%1024)+1) );
|
||||
failure = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// printf("* DONE (buff[0])[%d]: %d, expected %d\n", i, (uint32_t)(recvbuff[0])[i], ((i%1024)+1) );
|
||||
}
|
||||
// if(failure)
|
||||
// break;
|
||||
}
|
||||
if (failure)
|
||||
printf("* ERROR recv %08d checked FAILURE ret=%d\n", (c+1), ret);
|
||||
else
|
||||
{
|
||||
// printf("* DONE recv %08d checked SUCCESSFULLY ret=%d\n", (c+1), ret);
|
||||
}
|
||||
#endif
|
||||
#if LOOPBACK
|
||||
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("* ERROR rf_device.trx_read_func returns %d\n", ret);
|
||||
}
|
||||
|
||||
}
|
||||
printf("\n");
|
||||
rf_device.trx_end_func( &rf_device );
|
||||
|
||||
sleep(1);
|
||||
free(sendbuff[0]);
|
||||
free(sendbuff);
|
||||
free(recvbuff[0]);
|
||||
free(recvbuff);
|
||||
|
||||
exit(0);
|
||||
|
||||
// END IS HERE !
|
||||
|
||||
rf_device.trx_set_freq_func(&rf_device,&openair0_cfg[0],0);
|
||||
|
||||
if (rf_device.trx_start_func(&rf_device) != 0 ) {
|
||||
printf("Could not start the device\n");
|
||||
oai_exit=1;
|
||||
}
|
||||
|
||||
while(!oai_exit){
|
||||
|
||||
rxp[0] = (void*)&rxdata[0][sub_frame*nb_sample_per_tti];
|
||||
|
||||
readBlockSize = rf_device.trx_read_func(&rf_device,
|
||||
×tamp,
|
||||
rxp,
|
||||
nb_sample_per_tti,
|
||||
0);
|
||||
|
||||
if ( readBlockSize != nb_sample_per_tti )
|
||||
oai_exit = 1;
|
||||
|
||||
sub_frame++;
|
||||
sub_frame%=10;
|
||||
|
||||
if( sub_frame == 0)
|
||||
frame_rx++;
|
||||
|
||||
saif_meas(frame_rx, sub_frame);
|
||||
}
|
||||
|
||||
return(0);
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user