From 6b662a3ed9a2742871c5418332b65a3123565673 Mon Sep 17 00:00:00 2001 From: laurent Date: Fri, 12 Jul 2019 17:25:52 +0200 Subject: [PATCH] compiles --- cmake_targets/CMakeLists.txt | 2 + executables/dl_fs6.c | 157 +++++++++++++++++++++++++++++++--- executables/main-ocp.c | 32 ++++--- executables/split_headers.h | 21 ++++- executables/transport_split.c | 19 ++-- 5 files changed, 195 insertions(+), 36 deletions(-) diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt index 552c5179b4..177de04a2d 100644 --- a/cmake_targets/CMakeLists.txt +++ b/cmake_targets/CMakeLists.txt @@ -2094,6 +2094,8 @@ target_link_libraries (lte-softmodem add_executable(ocp-softmodem ${OPENAIR_TARGETS}/RT/USER/rt_wrapper.c ${OPENAIR_DIR}/executables/main-ocp.c + ${OPENAIR_DIR}/executables/dl_fs6.c + ${OPENAIR_DIR}/executables/transport_split.c ${OPENAIR_TARGETS}/RT/USER/lte-softmodem.c ${OPENAIR_TARGETS}/RT/USER/lte-softmodem-common.c ${OPENAIR2_DIR}/ENB_APP/NB_IoT_interface.c diff --git a/executables/dl_fs6.c b/executables/dl_fs6.c index c583a4bc45..5ad6ddfd3b 100644 --- a/executables/dl_fs6.c +++ b/executables/dl_fs6.c @@ -1,5 +1,11 @@ -#include +#include +#include +#include +#include +#define FS6_BUF_SIZE 100*1000 +static int sockFS6; +#if 0 void pdsch_procedures(PHY_VARS_eNB *eNB, L1_rxtx_proc_t *proc, @@ -61,14 +67,15 @@ void pdsch_procedures(PHY_VARS_eNB *eNB, dlsch_harq->round++; } -phy_procedures_eNB_TX_fs6() { - receiveSubFrame(); +phy_procedures_eNB_TX_fs6(int sockFS6, uint64_t TS) { + uint8_t bufferZone[FS6_BUF_SIZE]; + receiveSubFrame(sockFS6, TS, bufferZone, sizeof(bufferZone) ); // We got // subframe number // - for (aa = 0; aa < fp->nb_antenna_ports_eNB; aa++) { + for (int aa = 0; aa < fp->nb_antenna_ports_eNB; aa++) { memset (&eNB->common_vars.txdataF[aa][subframe * fp->ofdm_symbol_size * fp->symbols_per_tti], 0, fp->ofdm_symbol_size * (fp->symbols_per_tti) * sizeof (int32_t)); @@ -178,17 +185,141 @@ phy_procedures_eNB_TX_fs6() { proc, AMP); } +#endif -DL_thread_fs6() { - receiveSubFrame(); - phy_procedures_eNB_TX_fs6(); - ru->feptx_prec(ru); - ru->feptx_ofdm(ru); - ru->fh_south_out(ru); +void prach_eNB_extract(PHY_VARS_eNB *eNB,RU_t *ru,int frame,int subframe) { } +void prach_eNB_process(PHY_VARS_eNB *eNB,RU_t *ru,int frame,int subframe) { +} +void phy_procedures_eNB_uespec_RX_extract(PHY_VARS_eNB *phy_vars_eNB,L1_rxtx_proc_t *proc) { +} -DL_thread_frequency() { - frequency_t header; - full_read(&header, \ No newline at end of file +void phy_procedures_eNB_uespec_RX_process(PHY_VARS_eNB *phy_vars_eNB,L1_rxtx_proc_t *proc) { +} + +void phy_procedures_eNB_TX_fs6() { +} + +void DL_du_fs6(RU_t *ru, int frame, int subframe, uint64_t TS) { + RU_proc_t *ru_proc=&ru->proc; + + for (int i=0; inum_eNB; i++) { + uint8_t bufferZone[FS6_BUF_SIZE]; + receiveSubFrame(sockFS6, TS, bufferZone, sizeof(bufferZone) ); + } + + phy_procedures_eNB_TX_fs6(); + /* Fixme: datamodel issue: a ru is supposed to be connected to several eNB + L1_rxtx_proc_t * L1_proc = &proc->L1_proc; + ru_proc->timestamp_tx = L1_proc->timestamp_tx; + ru_proc->subframe_tx = L1_proc->subframe_tx; + ru_proc->frame_tx = L1_proc->frame_tx; + */ + feptx_prec(ru); + feptx_ofdm(ru); + tx_rf(ru); +} + +void UL_du_fs6(RU_t *ru, int frame, int subframe) { + RU_proc_t *ru_proc=&ru->proc; + int tmpf=frame, tmpsf=subframe; + rx_rf(ru,&tmpf,&tmpsf); + AssertFatal(tmpf==frame && tmpsf==subframe, "lost synchronization\n"); + ru_proc->frame_tx = (ru_proc->frame_tx+ru_proc->frame_offset)&1023; + // Fixme: datamodel issue + PHY_VARS_eNB *eNB = RC.eNB[0][0]; + L1_proc_t *proc = &eNB->proc; + L1_rxtx_proc_t *L1_proc = &proc->L1_proc; + LTE_DL_FRAME_PARMS *fp = &ru->frame_parms; + proc->frame_rx = frame; + proc->subframe_rx = subframe; + + if (NFAPI_MODE==NFAPI_MODE_PNF) { + // I am a PNF and I need to let nFAPI know that we have a (sub)frame tick + //add_subframe(&frame, &subframe, 4); + //oai_subframe_ind(proc->frame_tx, proc->subframe_tx); + oai_subframe_ind(proc->frame_rx, proc->subframe_rx); + } + + uint8_t bufferZone[FS6_BUF_SIZE]; + prach_eNB_extract(eNB,NULL,proc->frame_rx,proc->subframe_rx); + + if (NFAPI_MODE==NFAPI_MONOLITHIC || NFAPI_MODE==NFAPI_MODE_PNF) { + phy_procedures_eNB_uespec_RX_extract(eNB, &proc->L1_proc); + } + + for (int i=0; inum_eNB; i++) { + sendSubFrame(sockFS6,bufferZone, sizeof(bufferZone) ); + } +} + +void DL_cu_fs6(RU_t *ru,int frame, int subframe) { + // Fixme: datamodel issue + PHY_VARS_eNB *eNB = RC.eNB[0][0]; + L1_proc_t *proc = &eNB->proc; + pthread_mutex_lock(&eNB->UL_INFO_mutex); + eNB->UL_INFO.frame = proc->frame_rx; + eNB->UL_INFO.subframe = proc->subframe_rx; + eNB->UL_INFO.module_id = eNB->Mod_id; + eNB->UL_INFO.CC_id = eNB->CC_id; + eNB->if_inst->UL_indication(&eNB->UL_INFO); + pthread_mutex_unlock(&eNB->UL_INFO_mutex); + uint8_t bufferZone[FS6_BUF_SIZE]; + phy_procedures_eNB_TX(eNB, &proc->L1_proc, 1); + sendSubFrame(sockFS6, bufferZone, sizeof(bufferZone) ); +} + +void UL_cu_fs6(RU_t *ru,int frame, int subframe, uint64_t TS) { + uint8_t bufferZone[FS6_BUF_SIZE]; + receiveSubFrame(sockFS6, TS, bufferZone, sizeof(bufferZone) ); + // Fixme: datamodel issue + PHY_VARS_eNB *eNB = RC.eNB[0][0]; + L1_proc_t *proc = &eNB->proc; + prach_eNB_process(eNB,NULL,proc->frame_rx,proc->subframe_rx); + release_UE_in_freeList(eNB->Mod_id); + + if (NFAPI_MODE==NFAPI_MONOLITHIC || NFAPI_MODE==NFAPI_MODE_PNF) { + phy_procedures_eNB_uespec_RX_process(eNB, &proc->L1_proc); + } +} + +void *cu_fs6(void *arg) { + RU_t *ru = (RU_t *)arg; + RU_proc_t *proc = &ru->proc; + int64_t AbsoluteSubframe=-1; + init_frame_parms(&ru->frame_parms,1); + wait_sync("ru_thread"); + + while(1) { + AbsoluteSubframe++; + int subframe=AbsoluteSubframe%10; + int frame=(AbsoluteSubframe/10)%1024; + UL_cu_fs6(ru, frame,subframe, AbsoluteSubframe); + DL_cu_fs6(ru, frame,subframe); + } + + return NULL; +} + +void *du_fs6(void *arg) { + RU_t *ru = (RU_t *)arg; + RU_proc_t *proc = &ru->proc; + int64_t AbsoluteSubframe=-1; + fill_rf_config(ru,ru->rf_config_file); + init_frame_parms(&ru->frame_parms,1); + phy_init_RU(ru); + openair0_device_load(&ru->rfdevice,&ru->openair0_cfg); + wait_sync("ru_thread"); + + while(1) { + AbsoluteSubframe++; + int subframe=AbsoluteSubframe%10; + int frame=(AbsoluteSubframe/10)%1024; + UL_du_fs6(ru, frame,subframe); + DL_du_fs6(ru, frame,subframe, AbsoluteSubframe); + } + + return NULL; +} diff --git a/executables/main-ocp.c b/executables/main-ocp.c index 93bf7d3daf..db64e47732 100644 --- a/executables/main-ocp.c +++ b/executables/main-ocp.c @@ -26,6 +26,7 @@ static int DEFENBS[] = {0}; #include #include #include +#include extern uint16_t sf_ahead; extern void oai_subframe_ind(uint16_t sfn, uint16_t sf); @@ -103,7 +104,17 @@ void init_RU_proc(RU_t *ru) { for (i=0; i<10; i++) proc->symbol_mask[i]=0; pthread_t t; - threadCreate(&t, ru_thread, (void *)ru, "MainRu", -1, OAI_PRIORITY_RT_MAX); + char *fs6=getenv("fs6"); + + if (fs6) { + if ( strncasecmp(fs6,"cu", 2) ) + threadCreate(&t, cu_fs6, (void *)ru, "MainCu", -1, OAI_PRIORITY_RT_MAX); + else if ( strncasecmp(fs6,"du", 2) ) + threadCreate(&t, du_fs6, (void *)ru, "MainDu", -1, OAI_PRIORITY_RT_MAX); + else + AssertFatal(false, "environement variable fs6 is not cu or du"); + } else + threadCreate(&t, ru_thread, (void *)ru, "MainRu", -1, OAI_PRIORITY_RT_MAX); } void init_transport(PHY_VARS_eNB *eNB) { @@ -719,13 +730,10 @@ void tx_rf(RU_t *ru) { } static void *ru_thread( void *param ) { - static int ru_thread_status; RU_t *ru = (RU_t *)param; RU_proc_t *proc = &ru->proc; int subframe =9; int frame =1023; - // set default return value - ru_thread_status = 0; if (ru->if_south == LOCAL_RF) { // configure RF parameters only fill_rf_config(ru,ru->rf_config_file); @@ -800,8 +808,7 @@ static void *ru_thread( void *param ) { else LOG_I(PHY,"RU %d rf device stopped\n",ru->idx); } - ru_thread_status = 0; - return &ru_thread_status; + return NULL; } int start_rf(RU_t *ru) { @@ -816,18 +823,15 @@ int stop_rf(RU_t *ru) { void set_function_spec_param(RU_t *ru) { switch (ru->if_south) { case LOCAL_RF: // this is an RU with integrated RF (RRU, eNB) - ru->do_prach = 0; // no prach processing in RU ru->feprx = fep_full; ru->feptx_ofdm = feptx_ofdm; ru->feptx_prec = feptx_prec; // this is fep with idft and precoding - ru->fh_north_in = NULL; // no incoming fronthaul from north - ru->start_if = NULL; // no if interface ru->rfdevice.host_type = RAU_HOST; - ru->fh_south_in = rx_rf; // local synchronous RF RX - ru->fh_south_out = tx_rf; // local synchronous RF TX - ru->start_rf = start_rf; // need to start the local RF interface - ru->stop_rf = stop_rf; - ru->eNB_top=eNB_top; + ru->fh_south_in = rx_rf; // local synchronous RF RX + ru->fh_south_out = tx_rf; // local synchronous RF TX + ru->start_rf = start_rf; // need to start the local RF interface + ru->stop_rf = stop_rf; + ru->eNB_top = eNB_top; break; default: diff --git a/executables/split_headers.h b/executables/split_headers.h index 3d59f3c199..68bb3925d7 100644 --- a/executables/split_headers.h +++ b/executables/split_headers.h @@ -1,6 +1,8 @@ #ifndef __SPLIT_HEADERS_H #define __SPLIT_HEADERS_H +#include +#include #define MTU 65536 #define UDP_TIMEOUT 100000L // in nano second #define MAX_BLOCKS 16 @@ -18,12 +20,27 @@ typedef struct frequency_s { int frame; int subframe; int sampleSize; - int nbAnt + int nbAnt; int nbSamples; } frequency_t; -int createListner (port); +int createListner (int port); int receiveSubFrame(int sock, uint64_t expectedTS, void *bufferZone, int bufferSize); int sendSubFrame(int sock, void *bufferZone, int nbBlocks); +inline size_t alignedSize(void *ptr) { + commonUDP_t *header=(commonUDP_t *) ptr; + return ((header->contentBytes+sizeof(commonUDP_t)+blockAlign-1)/blockAlign)*blockAlign; } + +void *cu_fs6(void *arg); +void *du_fs6(void *arg); +void fill_rf_config(RU_t *ru, char *rf_config_file); +void rx_rf(RU_t *ru,int *frame,int *subframe); +void tx_rf(RU_t *ru); + +// mistakes in main OAI +void phy_init_RU(RU_t *); +void feptx_prec(RU_t *); +void feptx_ofdm(RU_t *); +void oai_subframe_ind(uint16_t sfn, uint16_t sf); #endif diff --git a/executables/transport_split.c b/executables/transport_split.c index fe9e1a419c..c3819d665e 100644 --- a/executables/transport_split.c +++ b/executables/transport_split.c @@ -1,6 +1,10 @@ -#include +#include +#include /* See NOTES */ +#include +#include +#include -int createListner (port) { +int createListner (int port) { int sock; AssertFatal((sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) >= 0, ""); struct sockaddr_in addr = { @@ -12,8 +16,8 @@ sin_addr: { s_addr: INADDR_ANY } }; int enable=1; - AssertFatal(setsockopt(eth->sockfdc, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable))==0,""); - AssertFatal(bind(sock, const struct sockaddr *addr, socklen_t addrlen)==0,""); + AssertFatal(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable))==0,""); + AssertFatal(bind(sock, (const struct sockaddr *) &addr, sizeof(addr))==0,""); struct timeval tv= {0,UDP_TIMEOUT}; AssertFatal(setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,&tv,sizeof(tv)) ==0,""); // Make a send/recv buffer larger than a a couple of subframe @@ -28,6 +32,7 @@ sin_addr: // bufferZone: a reception area of bufferSize int receiveSubFrame(int sock, uint64_t expectedTS, void *bufferZone, int bufferSize) { int rcved=0; + commonUDP_t *tmp=NULL; do { //read all subframe data from the control unit @@ -41,7 +46,7 @@ int receiveSubFrame(int sock, uint64_t expectedTS, void *bufferZone, int buffer return -1; } } else { - commonUDP_t *tmp=(commonUDP_t *)bufferZone; + tmp=(commonUDP_t *)bufferZone; if ( expectedTS && tmp->timestamp != expectedTS) { LOG_W(HW,"Received a paquet in mixed subframes, dropping it\n"); @@ -50,9 +55,9 @@ int receiveSubFrame(int sock, uint64_t expectedTS, void *bufferZone, int buffer bufferZone+=ret; } } - } while ( !recved || recved < tmp->nbBlocks); + } while ( !rcved || rcved < tmp->nbBlocks); - return recv; + return rcved; } int sendSubFrame(int sock, void *bufferZone, int nbBlocks) {