Initial commit

assertions.h

+/*
+ * 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
+ */
+
+#ifndef __COMMON_UTILS_ASSERTIONS__H__
+#define __COMMON_UTILS_ASSERTIONS__H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "platform_types.h"
+#include "backtrace.h"
+
+#define _Assert_Exit_							\
+  if (getenv("gdbStacks")) {						\
+    char tmp [1000];							\
+    sprintf(tmp,"gdb -ex='set confirm off' -ex 'thread apply all bt' -ex q -p %d < /dev/null", getpid());  \
+    __attribute__((unused)) int dummy=system(tmp);						\
+  }									\
+  fprintf(stderr, "\nExiting execution\n");				\
+  fflush(stdout);							\
+  fflush(stderr);							\
+  abort();
+
+#define _Assert_(cOND, aCTION, fORMAT, aRGS...)             \
+do {                                                        \
+    if (!(cOND)) {                                          \
+        fprintf(stderr, "\nAssertion (%s) failed!\n"   \
+                "In %s() %s:%d\n" fORMAT,                   \
+                #cOND, __FUNCTION__, __FILE__, __LINE__, ##aRGS);  \
+        aCTION;                                             \
+    }						\
+} while(0)
+
+#define AssertFatal(cOND, fORMAT, aRGS...)          _Assert_(cOND, _Assert_Exit_, fORMAT, ##aRGS)
+
+#define AssertError(cOND, aCTION, fORMAT, aRGS...)  _Assert_(cOND, aCTION, fORMAT, ##aRGS)
+
+
+
+#define DevCheck(cOND, vALUE1, vALUE2, vALUE3)                                                          \
+_Assert_(cOND, _Assert_Exit_, #vALUE1 ": %" PRIdMAX "\n" #vALUE2 ": %" PRIdMAX "\n" #vALUE3 ": %" PRIdMAX "\n\n",  \
+         (intmax_t)vALUE1, (intmax_t)vALUE2, (intmax_t)vALUE3)
+
+#define DevCheck4(cOND, vALUE1, vALUE2, vALUE3, vALUE4)                                                                         \
+_Assert_(cOND, _Assert_Exit_, #vALUE1": %" PRIdMAX "\n" #vALUE2 ": %" PRIdMAX "\n" #vALUE3 ": %" PRIdMAX "\n" #vALUE4 ": %" PRIdMAX "\n\n",   \
+         (intmax_t)vALUE1, (intmax_t)vALUE2, (intmax_t)vALUE3, (intmax_t)vALUE4)
+
+#define DevParam(vALUE1, vALUE2, vALUE3)    DevCheck(0, vALUE1, vALUE2, vALUE3)
+
+#define DevAssert(cOND)                     _Assert_(cOND, _Assert_Exit_, "")
+
+#define DevMessage(mESSAGE)                 _Assert_(0, _Assert_Exit_, #mESSAGE)
+
+#define CHECK_INIT_RETURN(fCT)                                  \
+do {                                                            \
+    int fct_ret;                                                \
+    if ((fct_ret = (fCT)) != 0) {                               \
+        fprintf(stderr, "Function "#fCT" has failed\n"          \
+        "returning %d\n", fct_ret);                             \
+        fflush(stdout);                                         \
+        fflush(stderr);                                         \
+        exit(EXIT_FAILURE);                                     \
+    }                                                           \
+} while(0)
+
+#endif /* __COMMON_UTILS_ASSERTIONS__H__ */

common_lib.c

+/*
+ * 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
+ */
+
+/*! \file common_lib.c
+ * \brief common APIs for different RF frontend device
+ * \author HongliangXU, Navid Nikaein
+ * \date 2015
+ * \version 0.2
+ * \company Eurecom
+ * \maintainer:  navid.nikaein@eurecom.fr
+ * \note
+ * \warning
+ */
+#include <stdio.h>
+#include <strings.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "common_lib.h"
+#include "assertions.h"
+#include "load_module_shlib.h"
+
+const char* devtype_names[MAX_RF_DEV_TYPE] = {
+  "",
+  "EXMIMO",
+  "USRP B200",
+  "USRP X300",
+  "USRP N300",
+  "USRP X400",
+  "BLADERF",
+  "YunSDR",
+  "LMSSDR",
+  "IRIS",
+  "No HW",
+  "ADRV9371_ZC706",
+  "UEDv2",
+  "RFSIMULATOR"
+};
+
+const char *get_devname(int devtype) {
+  if (devtype < MAX_RF_DEV_TYPE && devtype !=MIN_RF_DEV_TYPE )
+    return devtype_names[devtype];
+  return "none";
+}
+
+int set_device(openair0_device *device)
+{
+  const char *devname = get_devname(device->type);
+    if (strcmp(devname,"none") != 0) {
+      LOG_I(HW,"[%s] has loaded %s device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"),devname);
+    } else {
+      LOG_E(HW,"[%s] invalid HW device.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+      return -1;
+    }
+  return 0;
+}
+
+int set_transport(openair0_device *device)
+{
+  switch (device->transp_type) {
+    case ETHERNET_TP:
+      LOG_I(HW,"[%s] has loaded ETHERNET trasport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+      return 0;
+      break;
+
+    case NONE_TP:
+      LOG_I(HW,"[%s] has not loaded a transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+      return 0;
+      break;
+
+    default:
+      LOG_E(HW,"[%s] invalid transport protocol.\n",((device->host_type == RAU_HOST) ? "RAU": "RRU"));
+      return -1;
+      break;
+  }
+}
+
+typedef int(*devfunc_t)(openair0_device *, openair0_config_t *, eth_params_t *);
+
+
+/* look for the interface library and load it */
+int load_lib(openair0_device *device,
+             openair0_config_t *openair0_cfg,
+             eth_params_t *cfg,
+             uint8_t flag)
+{
+  loader_shlibfunc_t shlib_fdesc[1];
+  int ret=0;
+  char *deflibname=OAI_RF_LIBNAME;
+  
+  openair0_cfg->recplay_mode = read_recplayconfig(&(openair0_cfg->recplay_conf),&(device->recplay_state));
+
+  if ( openair0_cfg->recplay_mode == RECPLAY_REPLAYMODE ) {
+  	  deflibname=OAI_IQPLAYER_LIBNAME;
+  	  shlib_fdesc[0].fname="device_init";
+  	  set_softmodem_optmask(SOFTMODEM_RECPLAY_BIT);  // softmodem has to know we use the iqplayer to workaround randomized algorithms
+  } else if (IS_SOFTMODEM_RFSIM && flag == RAU_LOCAL_RADIO_HEAD) {
+	  deflibname=OAI_RFSIM_LIBNAME;
+	  shlib_fdesc[0].fname="device_init";
+  } else if (flag == RAU_LOCAL_RADIO_HEAD) {
+	  if (IS_SOFTMODEM_RFSIM)
+		  deflibname="rfsimulator";
+	  else
+          deflibname=OAI_RF_LIBNAME;
+      shlib_fdesc[0].fname="device_init";
+  } else if (flag == RAU_REMOTE_THIRDPARTY_RADIO_HEAD) {
+    deflibname=OAI_THIRDPARTY_TP_LIBNAME;
+    shlib_fdesc[0].fname="transport_init";
+  } else {
+	  deflibname=OAI_TP_LIBNAME;
+	  shlib_fdesc[0].fname="transport_init";
+  }
+  
+  char *devname=NULL;
+  paramdef_t device_params[]=DEVICE_PARAMS_DESC ;
+  int numparams = sizeof(device_params)/sizeof(paramdef_t);
+  int devname_pidx = config_paramidx_fromname(device_params,numparams, CONFIG_DEVICEOPT_NAME);
+  device_params[devname_pidx].defstrval=deflibname;
+  
+  config_get(device_params,numparams,DEVICE_SECTION);
+  
+  ret=load_module_shlib(devname,shlib_fdesc,1,NULL);
+  AssertFatal( (ret >= 0),
+  	           "Library %s couldn't be loaded\n",devname);
+
+  return ((devfunc_t)shlib_fdesc[0].fptr)(device,openair0_cfg,cfg);
+}
+
+
+int openair0_device_load(openair0_device *device,
+                         openair0_config_t *openair0_cfg)
+{
+  int rc=0;
+  rc=load_lib(device, openair0_cfg, NULL,RAU_LOCAL_RADIO_HEAD );
+
+  if ( rc >= 0) {
+    if ( set_device(device) < 0) {
+      LOG_E(HW, "%s %d:Unsupported radio head\n", __FILE__, __LINE__);
+      return -1;
+	}
+  } else
+    AssertFatal(false, "can't open the radio device: %s\n", get_devname(device->type));
+
+  return rc;
+}
+
+
+int openair0_transport_load(openair0_device *device,
+                            openair0_config_t *openair0_cfg,
+                            eth_params_t *eth_params)
+{
+  int rc;
+  rc=load_lib(device, openair0_cfg, eth_params, RAU_REMOTE_RADIO_HEAD);
+
+  if ( rc >= 0) {
+    if ( set_transport(device) < 0) {
+      LOG_E(HW, "%s %d:Unsupported transport protocol\n", __FILE__, __LINE__);
+      return -1;
+    }
+  }
+
+  return rc;
+}

rf_helper.h

+/*
+ * Copyright 2013-2020 Software Radio Systems Limited
+ *
+ * This file is part of srsLTE.
+ *
+ * srsLTE is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * srsLTE is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * A copy of the GNU Affero General Public License can be found in
+ * the LICENSE file in the top-level directory of this distribution
+ * and at http://www.gnu.org/licenses/.
+ *
+ */
+#ifndef YUNSDR_RF_HELPER_H_
+#define YUNSDR_RF_HELPER_H_
+
+// A bunch of helper functions to process device arguments
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define REMOVE_SUBSTRING_WITHCOMAS(S, TOREMOVE)                                                                        \
+  remove_substring(S, TOREMOVE ",");                                                                                   \
+  remove_substring(S, TOREMOVE ", ");                                                                                  \
+  remove_substring(S, "," TOREMOVE);                                                                                   \
+  remove_substring(S, ", " TOREMOVE);                                                                                  \
+  remove_substring(S, TOREMOVE)
+
+static inline void remove_substring(char* s, const char* toremove)
+{
+  while ((s = strstr(s, toremove))) {
+    memmove(s, s + strlen(toremove), 1 + strlen(s + strlen(toremove)));
+  }
+}
+
+static inline void copy_subdev_string(char* dst, char* src)
+{
+  int n   = 0;
+  int len = (int)strlen(src);
+  /* Copy until end of string or comma */
+  while (n < len && src[n] != '\0' && src[n] != ',') {
+    dst[n] = src[n];
+    n++;
+  }
+  dst[n] = '\0';
+}
+
+#endif /* YUNSDR_RF_HELPER_H_ */

trx_test.c

+#include "trx_test.h"
+
+int txdata_size=57344;
+int rxdata_size=2465792;
+int absolute_slot=0;
+int nb_slot_frame=2;
+int samples_per_subframe=30720;
+
+int NB_ANTENNAS_RX=4;
+int NB_ANTENNAS_TX=4;
+
+//samples_per_subframe 30720, samples_per_slot_wCP 14336.
+//txdata_size 57344, txdataF_size 57344, rxdata_size 2465792.
+
+#define VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(A,B)   
+
+#define NR_TIMESPEC_TO_DOUBLE_US(nr_t)   ( ( (double)nr_t.tv_sec * 1000000 ) + ( (double)nr_t.tv_nsec / 1000 ) )
+struct timespec  nr_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;
+}
+
+int main( int argc, char **argv ) {
+
+//  T_Config_Init();
+
+  openair0_config_t openair0_cfg[4];
+  openair0_device rfdevice;
+
+  int card=0;
+  openair0_cfg[card].sample_rate       = 30720 * 1e3;
+  openair0_cfg[card].samples_per_frame = 30720;
+
+  openair0_cfg[card].duplex_mode = duplex_mode_TDD;
+
+  openair0_cfg[card].Mod_id = 0;
+  openair0_cfg[card].num_rb_dl = 51;
+  openair0_cfg[card].clock_source = 0;
+  openair0_cfg[card].time_source = 0;
+  openair0_cfg[card].tx_num_channels = 1;
+  openair0_cfg[card].rx_num_channels = 1;
+
+  printf("HW: Configuring card %d, sample_rate %f, tx/rx num_channels %d/%d, duplex_mode %d\n",
+      card,
+      openair0_cfg[card].sample_rate,
+      openair0_cfg[card].tx_num_channels,
+      openair0_cfg[card].rx_num_channels,
+      openair0_cfg[card].duplex_mode);
+
+  int dl_carrier = 3628380000;
+  int ul_carrier = 3628380000;
+  int freq_off   = 0;
+  int rx_gain_off = 0;
+  int rf_chain = 0;
+  double freq_scale  = (double)(dl_carrier + freq_off) / dl_carrier;
+
+  for (int i = rf_chain; i < rf_chain + 1; i++) {
+    printf("test\n");
+    if (i < openair0_cfg->rx_num_channels)
+      openair0_cfg->rx_freq[i + rf_chain] = dl_carrier * freq_scale;
+    else
+      openair0_cfg->rx_freq[i] = 0.0;
+
+    if (i<openair0_cfg->tx_num_channels)
+      openair0_cfg->tx_freq[i] = ul_carrier * freq_scale;
+    else
+      openair0_cfg->tx_freq[i] = 0.0;
+
+    openair0_cfg->autocal[i] = 1;
+
+    //if (i < openair0_cfg->rx_num_channels) 
+    {
+      printf("HW: Configuring channel %d (rf_chain %d): setting tx_freq %f Hz, rx_freq %f Hz\n",
+        i,
+        rf_chain,
+        openair0_cfg->tx_freq[i],
+        openair0_cfg->rx_freq[i]);
+    }
+  }
+//    nr_rf_card_config_gain(&openair0_cfg[card], rx_gain_off);
+
+  openair0_cfg[card].sdr_addrs = "dev=pciex:0,auxdac1=300";
+
+  openair0_timestamp timestamp, writeTimestamp;
+  int32_t * rxp[NB_ANTENNAS_RX];
+  int32_t * txp[NB_ANTENNAS_TX];
+  int start_rx_stream = 1;
+
+  double clock_gettime_cur;
+  struct timespec time_start;
+  struct timespec time_stop;
+
+
+
+
+  for (int i=0; i<NB_ANTENNAS_RX; i++) {
+    txp[i] = (int32_t *) malloc16_clear( txdata_size );
+    rxp[i] = (int32_t *) malloc16_clear( rxdata_size );
+  }
+    int readBlockSize, writeBlockSize;
+
+  readBlockSize = samples_per_subframe/2;
+  writeBlockSize = readBlockSize;
+    
+
+  device_init(&(rfdevice), &openair0_cfg[0]);
+
+  rfdevice.trx_start_func(&rfdevice);
+
+//first time is very long, don't know why.
+  clock_gettime(CLOCK_REALTIME,&time_start);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, VCD_FUNCTION_IN );
+  rfdevice.trx_read_func(&rfdevice,
+                                          &timestamp,
+                                          (void **)rxp,
+                                          readBlockSize,
+                                          1);
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, VCD_FUNCTION_OUT );
+  clock_gettime(CLOCK_REALTIME,&time_stop);
+  clock_gettime_cur = NR_TIMESPEC_TO_DOUBLE_US( nr_get_timespec_diff( &time_start, &time_stop ));//us
+  printf("using %.2lf msec in 1st time\n", clock_gettime_cur/1000);
+  clock_gettime(CLOCK_REALTIME,&time_start);
+  while (1) {
+
+    absolute_slot++;
+    clock_gettime(CLOCK_REALTIME,&time_stop);
+
+    clock_gettime_cur = NR_TIMESPEC_TO_DOUBLE_US( nr_get_timespec_diff( &time_start, &time_stop ));//us
+    if (clock_gettime_cur > 1000) 
+         printf("slot_num %d, time = %.2f sec, delay_time=%.2lf msec\n", absolute_slot, ((float)absolute_slot)/2/1000, clock_gettime_cur/1000);
+    clock_gettime(CLOCK_REALTIME,&time_start);
+
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, VCD_FUNCTION_IN );
+    rfdevice.trx_read_func(&rfdevice,
+                                           &timestamp,
+                                           (void **)rxp,
+                                           readBlockSize,
+                                           1);
+
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_READ, VCD_FUNCTION_OUT );
+
+    // use previous timing_advance value to compute writeTimestamp
+    writeTimestamp = timestamp+samples_per_subframe/20*5;// sent after 5 slot.
+
+    // but use current UE->timing_advance value to compute writeBlockSize
+  
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, VCD_FUNCTION_IN );
+    rfdevice.trx_write_func(&rfdevice,
+                                              writeTimestamp,
+                                              (void **)txp,
+                                              writeBlockSize,
+                                              1,
+                                              1);
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE, VCD_FUNCTION_OUT );
+    
+  } // while !oai_exit
+
+
+  return 0;
+}

trx_test.h

+#include <stdint.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <time.h>
+#include <stdlib.h>
+#include <string.h>
+//#include "T.h"
+#include "common_lib.h"
+#include "yunsdr_lib.h"
+#include "utils.h"
+
+typedef long int openair0_timestamp;
+typedef int int32_t;
+

utils.h

+#ifndef _UTILS_H
+#define _UTILS_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <malloc.h>
+#include <sys/types.h>
+#include "assertions.h"
+
+#ifdef MALLOC_TRACE
+#define malloc myMalloc
+#endif
+
+#define sizeofArray(a) (sizeof(a)/sizeof(*(a)))
+
+#define cmax(a,b)  ((a>b) ? (a) : (b))
+#define cmax3(a,b,c) ((cmax(a,b)>c) ? (cmax(a,b)) : (c))
+#define cmin(a,b)  ((a<b) ? (a) : (b))
+
+#ifdef __cplusplus
+#ifdef min
+#undef min
+#undef max
+#endif
+#else
+#define max(a,b) cmax(a,b)
+#define min(a,b) cmin(a,b)
+#endif
+
+#ifndef malloc16
+#  ifdef __AVX2__
+#    define malloc16(x) memalign(32,x+32)
+#  else
+#    define malloc16(x) memalign(16,x+16)
+#  endif
+#endif
+#define free16(y,x) free(y)
+#define bigmalloc malloc
+#define bigmalloc16 malloc16
+#define openair_free(y,x) free((y))
+#define PAGE_SIZE 4096
+
+#define free_and_zero(PtR) do {     \
+    if (PtR) {           \
+      free(PtR);         \
+      PtR = NULL;        \
+    }                    \
+  } while (0)
+
+static inline void *malloc16_clear( size_t size ) {
+#ifdef __AVX2__
+  void *ptr = memalign(32, size+32);
+#else
+  void *ptr = memalign(16, size+16);
+#endif
+  DevAssert(ptr);
+  memset( ptr, 0, size );
+  return ptr;
+}
+
+
+static inline void *calloc_or_fail(size_t size) {
+  void *ptr = calloc(1, size);
+
+  if (ptr == NULL) {
+    fprintf(stderr, "[UE] Failed to calloc %zu bytes", size);
+    exit(EXIT_FAILURE);
+  }
+
+  return ptr;
+}
+
+static inline void *malloc_or_fail(size_t size) {
+  void *ptr = malloc(size);
+
+  if (ptr == NULL) {
+    fprintf(stderr, "[UE] Failed to malloc %zu bytes", size);
+    exit(EXIT_FAILURE);
+  }
+
+  return ptr;
+}
+
+#if !defined (msg)
+# define msg(aRGS...) LOG_D(PHY, ##aRGS)
+#endif
+#ifndef malloc16
+#  ifdef __AVX2__
+#    define malloc16(x) memalign(32,x)
+#  else
+#    define malloc16(x) memalign(16,x)
+#  endif
+#endif
+
+#define free16(y,x) free(y)
+#define bigmalloc malloc
+#define bigmalloc16 malloc16
+#define openair_free(y,x) free((y))
+#define PAGE_SIZE 4096
+
+#define PAGE_MASK 0xfffff000
+#define virt_to_phys(x) (x)
+
+const char *hexdump(const void *data, size_t data_len, char *out, size_t out_len);
+
+// Converts an hexadecimal ASCII coded digit into its value. **
+int hex_char_to_hex_value (char c);
+// Converts an hexadecimal ASCII coded string into its value.**
+int hex_string_to_hex_value (uint8_t *hex_value, const char *hex_string, int size);
+
+void *memcpy1(void *dst,const void *src,size_t n);
+
+void set_priority(int priority);
+
+char *itoa(int i);
+
+#define findInList(keY, result, list, element_type) {\
+    int i;\
+    for (i=0; i<sizeof(list)/sizeof(element_type) ; i++)\
+      if (list[i].key==keY) {\
+        result=list[i].val;\
+        break;\
+      }\
+    AssertFatal(i < sizeof(list)/sizeof(element_type), "List %s doesn't contain %s\n",#list, #keY); \
+  }
+#ifdef __cplusplus
+}
+#endif
+
+#endif

yunsdr_lib.h

+/*
+ * 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.0  (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
+ */
+
+/** yunsdr_lib.h
+ *
+ * Author: eric
+ * base on bladerf_lib.h
+ */
+
+#include "yunsdr_api_ss.h"
+#include "common_lib.h"
+
+/** @addtogroup _YUNSDR_PHY_RF_INTERFACE_
+ * @{
+ */
+
+/*! \brief YunSDR specific data structure */ 
+typedef struct {
+
+  //! opaque YunSDR device struct. An empty ("") or NULL device identifier will result in the first encountered device being opened (using the first discovered backend)
+  YUNSDR_DESCRIPTOR *dev;
+  int16_t *rx_buffer;
+  int16_t *tx_buffer;
+  //! Sample rate
+  unsigned int sample_rate;
+
+  int rx_num_channels;
+  int tx_num_channels;
+  uint64_t tx_lo_freq;
+  uint64_t rx_lo_freq;
+
+  // --------------------------------
+  // Debug and output control
+  // --------------------------------
+  //! Number of underflows
+  int num_underflows;
+  //! Number of overflows
+  int num_overflows;
+  //! number of RX errors
+  int num_rx_errors;
+  //! Number of TX errors
+  int num_tx_errors;
+
+  //! timestamp of current TX
+  uint64_t tx_current_ts;
+  //! timestamp of current RX
+  uint64_t rx_current_ts;
+  //! number of TX samples
+  uint64_t tx_nsamps;
+  //! number of RX samples
+  uint64_t rx_nsamps;
+  //! number of TX count
+  uint64_t tx_count;
+  //! number of RX count
+  uint64_t rx_count;
+  //! timestamp of RX packet
+  openair0_timestamp rx_timestamp;
+
+} yunsdr_state_t;
+
+/*! \brief get current timestamp
+ *\param device the hardware to use 
+ */
+openair0_timestamp trx_get_timestamp(openair0_device *device);
+
+int device_init(openair0_device *device, openair0_config_t *openair0_cfg);
+
+/*@}*/