const char *
fl_show_simple_input( const char * str1,
const char * defstr )
{
if ( fd_input )
{
fl_hide_form( fd_input->form );
fl_free_form( fd_input->form );
fli_safe_free( fd_input );
}
else
fl_deactivate_all_forms( );
fli_safe_free( ret_str );
fd_input = create_input( str1, defstr );
fl_show_form( fd_input->form, FL_PLACE_HOTSPOT, FL_TRANSIENT, "Input" );
fl_update_display( 0 );
while ( fl_do_only_forms( ) != fd_input->but )
/* empty */ ;
ret_str = fl_strdup( fl_get_input( fd_input->input ) );
fl_hide_form( fd_input->form );
fl_free_form( fd_input->form );
fli_safe_free( fd_input );
fl_activate_all_forms( );
return ret_str;
}
NeoWindow::~NeoWindow() {
/*if ( portal != NULL ) {
delete portal;
portal = NULL;
}*/
if ( pixmap != (Pixmap) NULL ) {
::XFreePixmap( display, pixmap );
pixmap = NULL;
}
fl_remove_canvas_handler( mainWin->mainCanvas, Expose, expose_callback );
fl_remove_canvas_handler( mainWin->mainCanvas, ButtonPress, buttonRelease_callback );
fl_remove_canvas_handler( mainWin->mainCanvas, ButtonRelease, buttonRelease_callback );
fl_hide_form( mainWin->mainWindow );
fl_free_form( mainWin->mainWindow );
mainWin = NULL;
if ( options_box != NULL ) {
fl_hide_form( options_box->options );
fl_free_form( options_box->options );
options_box = NULL;
}
if ( nnet_plot != NULL ) {
fl_hide_form( nnet_plot->neural_net_plot );
fl_free_form( nnet_plot->neural_net_plot );
nnet_plot = NULL;
}
if ( chart_wind != NULL ) {
fl_hide_form( chart_wind->chart_window );
fl_free_form( chart_wind->chart_window );
chart_wind = NULL;
}
::XFlush( display );
::XFreeGC( display, gc );
::XCloseDisplay( display );
fl_finish();
}
int
main( int argc,
char * argv[ ] )
{
FD_newbut *cbform ;
fl_initialize( &argc, argv, "FormDemo", 0, 0 );
cbform = create_form_newbut( );
fl_show_form( cbform->newbut, FL_PLACE_CENTER, FL_TRANSIENT, "test" );
while( fl_do_forms( ) != cbform->bexit )
/* empty */ ;
fl_hide_form( cbform->newbut );
fl_free_form( cbform->newbut );
free( cbform );
fprintf( stderr,"sleeping\n" );
sleep( 2 );
cbform = create_form_newbut( );
fl_show_form( cbform->newbut, FL_PLACE_CENTER, 0, 0 );
while( fl_do_forms() != cbform->bexit )
/* empty */;
fl_finish( );
return 0;
}
void unc_ret_cb(FL_OBJECT *ob, long user_data){//return din ceas - sterg si obiectul din lista
unc_pl *p1u, *p2u;
//caut in lista pointerul corespunzatoar formei pe care vreau sa o sterg
for(p2u = p1u = crt_head; p1u->p_unceas->retOB != ob && p1u != NULL; p2u = p1u, p1u = p1u->next);
fl_hide_form(p1u->p_unceas->unCeas);
fl_free_form(p1u->p_unceas->unCeas);
if(p1u == p2u){//nodul eliberat a fost capul listei
if(p1u->next == NULL){// a fost singurul nod in lista
free(p1u);
crt_head = NULL;
}
else{ //nu a fost singurul nod in lista
crt_head = p1u->next;
free(p1u);
}
}
else{ //nu a fost capul listei
if(p1u->next == NULL){ //a fost coada listei
free(p1u);
p2u->next = NULL;
}
else{
p2u->next = p1u->next;
free(p1u);
}
}
}
static void
form_dealloc(formobject *f)
{
releaseobjects(f->ob_form);
if (f->ob_form->visible)
fl_hide_form(f->ob_form);
fl_free_form(f->ob_form);
PyObject_Del(f);
}
void NeoWindow::HandleOptionsObject( FL_OBJECT *obj ) { // Handle command from form on options dialog
FD_options *box = options_box;
if ( obj == box->ok ) {
fl_hide_form( box->options );
fl_free_form( box->options );
Refresh( true );
options_box = NULL;
} else if ( obj == box->initial_pop )
neo->initial_creatures = fl_get_slider_value( obj );
else if ( obj == box->initial_plant )
neo->num_initial_food_locs = fl_get_slider_value( obj );
else if ( obj == box->initial_flesh )
neo->num_initial_meat_locs = fl_get_slider_value( obj );
else if ( obj == box->give_head_start )
neo->bGiveHeadStart = fl_get_button( obj );
else if ( obj == box->allow_sex )
neo->bAllowSexual = fl_get_button( obj );
else if ( obj == box->allow_asex )
neo->bAllowAsexual = fl_get_button( obj );
else if ( obj == box->terrain_size )
neo->terrain_size = atoi( fl_get_choice_text( obj ) );
else if ( obj == box->scale )
neo->scale = fl_get_slider_value( obj );
else if ( obj == box->prob_crossover )
neo->prob_crossover = fl_get_slider_value( obj );
else if ( obj == box->prob_mutation )
neo->prob_mutation = fl_get_slider_value( obj );
else if ( obj == box->max_pop )
neo->maximum_creatures = fl_get_slider_value( obj );
else if ( obj == box->min_pop )
neo->nMinimumPopulation = fl_get_slider_value( obj );
else if ( obj == box->age_factor )
neo->age_factor = fl_get_slider_value( obj );
else if ( obj == box->carcass_decay_rate )
neo->nCarcassDecayRate = fl_get_slider_value( obj );
else if ( obj == box->waste_decay_rate )
neo->nWasteDecayRate = fl_get_slider_value( obj );
else if ( obj == box->poison_decay_rate )
neo->nPoisonDecayRate = fl_get_slider_value( obj );
else if ( obj == box->give_head_start )
neo->bGiveHeadStart = fl_get_button( obj );
else if ( obj == box->allow_sex )
neo->bAllowSexual = fl_get_button( obj );
else if ( obj == box->allow_asex )
neo->bAllowAsexual = fl_get_button( obj );
else if ( obj == box->maintain_min_pop )
neo->bKeepMinimumPopulation = fl_get_button( obj );
else if ( obj == box->use_survivor )
neo->bUseSurvivorForMinimum = fl_get_button( obj );
else if ( obj == box->save_sim )
if ( fl_get_button( obj ) )
neo->saveEveryNsteps = fl_get_slider_value( box->save_every );
else
neo->saveEveryNsteps = -1;
else if ( obj == box->file_name )
strcpy( neo->fileName, fl_get_input( obj ) );
}
void NeoWindow::HandleChartWindowObject( FL_OBJECT *obj ) {
FD_chart_window *box = chart_wind;
if ( obj == box->ok ) {
fl_hide_form( box->chart_window );
fl_free_form( box->chart_window );
Refresh( true );
chart_wind = NULL;
}
}
void NeoWindow::HandleNNetPlotObject( FL_OBJECT *obj ) {
FD_neural_net_plot *box = nnet_plot;
if ( obj == box->ok ) {
fl_remove_canvas_handler( nnet_plot->mainCanvas, Expose, expose_callback );
fl_hide_form( box->neural_net_plot );
fl_free_form( box->neural_net_plot );
Refresh( true );
nnet_plot = NULL;
}
}
void anim_reactive_collision_interface(AnimProb * AnimProbPt) {
int NofCoef;
NofCoef = XYZ_ANIM.animation[0]->nof_coef;
ZANIM = AnimProbPt;
if (ARCI != NULL) {
fl_hide_form(ARCI);
fl_free_form(ARCI);
ARCI = NULL;
}
ARCI = fl_bgn_form(FL_UP_BOX, 200, 370);
ARCI_REAC_TIME = fl_add_valslider (FL_HOR_SLIDER, 10, 10, 180, 20, "Reaction Time");
fl_set_slider_bounds (ARCI_REAC_TIME, 0, 3);
fl_set_slider_value (ARCI_REAC_TIME, 1);
fl_set_slider_step (ARCI_REAC_TIME, 0.1);
ARCI_CONST_BLOCKS = fl_add_button(FL_NORMAL_BUTTON, 10, 50, 180, 20, "Constitute Blocks");
fl_set_object_callback(ARCI_CONST_BLOCKS, anim_arci_cb, 10);
ARCI_NOF_BLOCK = fl_add_text(FL_NORMAL_TEXT, 10, 80, 180, 20, "");
anim_udpate_nof_blocks();
ARCI_NOF_ATTEMPTS = fl_add_valslider (FL_HOR_SLIDER, 10, 110, 180, 20, "Number of Attempt for Solving Collisions");
fl_set_slider_bounds (ARCI_NOF_ATTEMPTS, 0, 1000);
fl_set_slider_value (ARCI_NOF_ATTEMPTS, 100);
fl_set_slider_step (ARCI_NOF_ATTEMPTS, 10);
ARCI_SOLVE_COL = fl_add_button(FL_NORMAL_BUTTON, 10, 150, 180, 20, "Solve Blocks");
fl_set_object_callback(ARCI_SOLVE_COL, anim_arci_cb, 11);
ARCI_SOLVED = fl_add_text(FL_NORMAL_TEXT, 10, 180, 180, 20, "");
anim_udpate_solved();
ARCI_SHOW_SOL = fl_add_button(FL_NORMAL_BUTTON, 10, 210, 180, 20, "Show Solution(s)");
fl_set_object_callback(ARCI_SHOW_SOL, anim_arci_cb, 12);
ARCI_OPTIM = fl_add_button(FL_NORMAL_BUTTON, 10, 240, 180, 20, "Optimize Solution(s)");
fl_set_object_callback(ARCI_OPTIM, anim_arci_cb, 13);
ARCI_OPTIMIZED = fl_add_text(FL_NORMAL_TEXT, 10, 270, 180, 20, "");
anim_udpate_optimized();
ARCI_SHOW_OPTIM = fl_add_button(FL_NORMAL_BUTTON, 10, 300, 180, 20, "Show Optimized Solution(s)");
fl_set_object_callback(ARCI_SHOW_OPTIM, anim_arci_cb, 14);
ARCI_CLOSE = fl_add_button(FL_NORMAL_BUTTON, 10, 330, 180, 20, "Close");
fl_set_object_callback(ARCI_CLOSE, anim_arci_cb, 15);
fl_end_form();
fl_show_form (ARCI, FL_PLACE_SIZE, FL_FULLBORDER, "Reactive collisions");
}
/* fonctions de destruction des objets forms */
void g3d_delete_steering_form(void)
{int n,i;
n = 4;
if(fl_get_button(steering_obj)){fl_hide_form(STEERING_FORM);}
fl_free_object(obj1);
fl_free_object(obj2);
for(i=0;i<n;i++){
BUTTON_TAB_OBJ[i]->u_vdata = NULL;
BUTTON_TAB_OBJ[i]->next = NULL;
BUTTON_TAB_OBJ[i]->prev = NULL;
fl_free_object(BUTTON_TAB_OBJ[i]);
}
GROUP->next = NULL;
GROUP->prev = NULL;
fl_free_object(GROUP);
fl_free_form(STEERING_FORM);
free(BUTTON_TAB_OBJ);
}
static void anim_arci_cb (FL_OBJECT * obj, long arg) {
switch (arg) {
case 10 :
ZANIM->ColOptions.ColBlockExtTime = fl_get_slider_value(ARCI_REAC_TIME);
anim_col_avoidance_step1(ZANIM);
anim_udpate_nof_blocks();
anim_udpate_solved();
anim_interface_update();
break;
case 11 :
ZANIM->ColOptions.NofAttempts = fl_get_slider_value(ARCI_NOF_ATTEMPTS);
anim_col_avoidance_step2(ZANIM);
anim_udpate_nof_blocks();
anim_udpate_solved();
anim_udpate_optimized();
break;
case 12 :
anim_show_form(ZANIM->ColAvoidRes, ZANIM->Robot);
break;
case 13 :
anim_col_avoidance_step3(ZANIM);
anim_udpate_optimized();
break;
case 14 :
anim_show_form(ZANIM->ColOpt2Res, ZANIM->Robot);
break;
case 15 :
fl_hide_form(ARCI);
fl_free_form(ARCI);
ARCI = NULL;
anim_interface_update();
break;
default :
PrintWarning (("anim_reac_col_interface.c -- unknown command"));
break;
}
}
int
fl_show_question( const char * str,
int ans )
{
FL_OBJECT *retobj;
char shortcut[ 4 ];
int k = 0;
if ( fd_yesno )
{
fl_hide_form( fd_yesno->form );
fl_free_form( fd_yesno->form );
fl_free( fd_yesno );
}
else
fl_deactivate_all_forms( );
fd_yesno = create_yesno( );
default_ans = ans;
fli_parse_goodies_label( fd_yesno->yes, FLQuestionYesLabel );
fli_parse_goodies_label( fd_yesno->no, FLQuestionNoLabel );
/* We don't set a shortcut if the first letter of the "yes" label
is identical to all letters in the "no" label */
while ( fd_yesno->no->label[ k ]
&& tolower( ( int ) fd_yesno->yes->label[ 0 ] ) ==
tolower( ( int ) fd_yesno->yes->label[ k ] ) )
k++;
if ( fd_yesno->no->label[ k ] )
{
shortcut[ 0 ] = fd_yesno->yes->label[ 0 ];
shortcut[ 1 ] = tolower( ( int ) fd_yesno->yes->label[ 0 ] );
shortcut[ 2 ] = toupper( ( int ) fd_yesno->yes->label[ 0 ] );
shortcut[ 3 ] = '\0';
fl_set_button_shortcut( fd_yesno->yes, shortcut, 1 );
shortcut[ 0 ] = fd_yesno->no->label[ k ];
shortcut[ 1 ] = toupper( ( int ) fd_yesno->no->label[ k ] );
shortcut[ 2 ] = tolower( ( int ) fd_yesno->no->label[ k ] );
fl_set_button_shortcut( fd_yesno->no, shortcut, 1 );
}
fli_get_goodie_title( fd_yesno->form, FLQuestionTitle );
fli_handle_goodie_font( fd_yesno->yes, fd_yesno->str );
fli_handle_goodie_font( fd_yesno->no, NULL );
fl_set_object_label( fd_yesno->str, str );
if ( ans == 1 )
fl_set_form_hotobject( fd_yesno->form, fd_yesno->yes );
else if ( ans == 0 )
fl_set_form_hotobject( fd_yesno->form, fd_yesno->no );
else
fl_set_form_hotspot( fd_yesno->form, -1, -1 );
fl_show_form( fd_yesno->form, FL_PLACE_HOTSPOT, FL_TRANSIENT,
fd_yesno->form->label );
fl_update_display( 0 );
while ( ( retobj = fl_do_only_forms( ) ) != fd_yesno->yes
&& retobj != fd_yesno->no )
/* empty */;
k = retobj == fd_yesno->yes;
fl_hide_form( fd_yesno->form );
fl_free_form( fd_yesno->form );
fli_safe_free( fd_yesno );
fl_activate_all_forms( );
return k;
}
void g3d_delete_grasp_planning_form(void)
{
fl_free_form(GRASP_PLANNING_FORM);
}
/*
If the control panel is visible, hide it and then delete it.
*/
void Quit_cb(FL_OBJECT *ob, long data)
{
CtrlPanelOn=0;
fl_hide_form(fd_ctrlpanel->ctrlpanel);
fl_free_form(fd_ctrlpanel->ctrlpanel);
}
void g3d_delete_genom_form(void) {
fl_free_form(GENOM_FORM);
}
int main(int argc, char **argv) {
#ifdef RTAI
RT_TASK *task;
RTIME period;
#endif
int i,j,aa;
void *status;
/*
uint32_t rf_mode_max[4] = {55759,55759,55759,55759};
uint32_t rf_mode_med[4] = {39375,39375,39375,39375};
uint32_t rf_mode_byp[4] = {22991,22991,22991,22991};
*/
uint32_t my_rf_mode = RXEN + TXEN + TXLPFNORM + TXLPFEN + TXLPF25 + RXLPFNORM + RXLPFEN + RXLPF25 + LNA1ON +LNAMax + RFBBNORM + DMAMODE_RX + DMAMODE_TX;
uint32_t rf_mode_base = TXLPFNORM + TXLPFEN + TXLPF25 + RXLPFNORM + RXLPFEN + RXLPF25 + LNA1ON +LNAMax + RFBBNORM;
uint32_t rf_mode[4] = {my_rf_mode,0,0,0};
uint32_t rf_local[4] = {8255000,8255000,8255000,8255000}; // UE zepto
//{8254617, 8254617, 8254617, 8254617}; //eNB khalifa
//{8255067,8254810,8257340,8257340}; // eNB PETRONAS
uint32_t rf_vcocal[4] = {910,910,910,910};
uint32_t rf_vcocal_850[4] = {2015, 2015, 2015, 2015};
uint32_t rf_rxdc[4] = {32896,32896,32896,32896};
uint32_t rxgain[4] = {20,20,20,20};
uint32_t txgain[4] = {20,20,20,20};
uint16_t Nid_cell = 0;
uint8_t cooperation_flag=0, transmission_mode=1, abstraction_flag=0;
uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2;
int c;
char do_forms=0;
unsigned int fd;
unsigned int tcxo = 114;
int amp;
uint8_t prach_fmt;
int N_ZC;
char rxg_fname[100];
char txg_fname[100];
char rflo_fname[100];
char rfdc_fname[100];
FILE *rxg_fd=NULL;
FILE *txg_fd=NULL;
FILE *rflo_fd=NULL;
FILE *rfdc_fd=NULL;
unsigned int rxg_max[4]={133,133,133,133}, rxg_med[4]={127,127,127,127}, rxg_byp[4]={120,120,120,120};
int tx_max_power=0;
char line[1000];
int l;
int ret, ant;
int ant_offset=0;
int error_code;
char *itti_dump_file = NULL;
const struct option long_options[] = {
{"calib-ue-rx", required_argument, NULL, 256},
{"calib-ue-rx-med", required_argument, NULL, 257},
{"calib-ue-rx-byp", required_argument, NULL, 258},
{"debug-ue-prach", no_argument, NULL, 259},
{"no-L2-connect", no_argument, NULL, 260},
{NULL, 0, NULL, 0}};
//mode = normal_txrx;
while ((c = getopt_long (argc, argv, "C:K:O:ST:UdF:V",long_options,NULL)) != -1)
{
switch (c)
{
case 'V':
ouput_vcd = 1;
break;
case 'd':
do_forms=1;
break;
case 'U':
UE_flag = 1;
break;
case 'C':
carrier_freq[0] = atoi(optarg);
carrier_freq[1] = atoi(optarg);
carrier_freq[2] = atoi(optarg);
carrier_freq[3] = atoi(optarg);
break;
case 'S':
fs4_test=1;
break;
case 'T':
tcxo=atoi(optarg);
break;
case 'K':
#if defined(ENABLE_ITTI)
itti_dump_file = strdup(optarg);
#else
printf("-K option is disabled when ENABLE_ITTI is not defined\n");
#endif
break;
case 'O':
#if defined(ENABLE_USE_MME)
EPC_MODE_ENABLED = 1;
if (optarg == NULL) /* No IP address provided: use localhost */
{
memcpy(&EPC_MODE_MME_ADDRESS[0], "127.0.0.1", 10);
} else {
uint8_t ip_length = strlen(optarg) + 1;
memcpy(&EPC_MODE_MME_ADDRESS[0], optarg,
ip_length > 16 ? 16 : ip_length);
}
#else
printf("You enabled mme mode without s1ap compiled...\n");
#endif
break;
case 'F':
sprintf(rxg_fname,"%srxg.lime",optarg);
rxg_fd = fopen(rxg_fname,"r");
if (rxg_fd) {
printf("Loading RX Gain parameters from %s\n",rxg_fname);
l=0;
while (fgets(line, sizeof(line), rxg_fd)) {
if ((strlen(line)==0) || (*line == '#')) continue; //ignore empty or comment lines
else {
if (l==0) sscanf(line,"%d %d %d %d",&rxg_max[0],&rxg_max[1],&rxg_max[2],&rxg_max[3]);
if (l==1) sscanf(line,"%d %d %d %d",&rxg_med[0],&rxg_med[1],&rxg_med[2],&rxg_med[3]);
if (l==2) sscanf(line,"%d %d %d %d",&rxg_byp[0],&rxg_byp[1],&rxg_byp[2],&rxg_byp[3]);
l++;
}
}
}
else
printf("%s not found, running with defaults\n",rxg_fname);
sprintf(txg_fname,"%stxg.lime",optarg);
txg_fd = fopen(txg_fname,"r");
if (txg_fd) {
printf("Loading TX Gain parameters from %s\n",txg_fname);
l=0;
while (fgets(line, sizeof(line), txg_fd)) {
if ((strlen(line)==0) || (*line == '#')) {
continue; //ignore empty or comment lines
}
else {
if (l==0) sscanf(line,"%d %d %d %d",&txgain[0],&txgain[1],&txgain[2],&txgain[3]);
if (l==1) sscanf(line,"%d",&tx_max_power);
l++;
}
}
}
else
printf("%s not found, running with defaults\n",txg_fname);
sprintf(rflo_fname,"%srflo.lime",optarg);
rflo_fd = fopen(rflo_fname,"r");
if (rflo_fd) {
printf("Loading RF LO parameters from %s\n",rflo_fname);
fscanf(rflo_fd,"%d %d %d %d",&rf_local[0],&rf_local[1],&rf_local[2],&rf_local[3]);
}
else
printf("%s not found, running with defaults\n",rflo_fname);
sprintf(rfdc_fname,"%srfdc.lime",optarg);
rfdc_fd = fopen(rfdc_fname,"r");
if (rfdc_fd) {
printf("Loading RF DC parameters from %s\n",rfdc_fname);
fscanf(rfdc_fd,"%d %d %d %d",&rf_rxdc[0],&rf_rxdc[1],&rf_rxdc[2],&rf_rxdc[3]);
}
else
printf("%s not found, running with defaults\n",rfdc_fname);
break;
/*
case 256:
mode = rx_calib_ue;
rx_input_level_dBm = atoi(optarg);
printf("Running with UE calibration on (LNA max), input level %d dBm\n",rx_input_level_dBm);
break;
case 257:
mode = rx_calib_ue_med;
rx_input_level_dBm = atoi(optarg);
printf("Running with UE calibration on (LNA med), input level %d dBm\n",rx_input_level_dBm);
break;
case 258:
mode = rx_calib_ue_byp;
rx_input_level_dBm = atoi(optarg);
printf("Running with UE calibration on (LNA byp), input level %d dBm\n",rx_input_level_dBm);
break;
case 259:
mode = debug_prach;
break;
case 260:
mode = no_L2_connect;
break;
*/
default:
break;
}
}
if (UE_flag==1)
printf("configuring for UE\n");
else
printf("configuring for eNB\n");
//randominit (0);
//set_taus_seed (0);
// initialize the log (see log.h for details)
logInit();
#if defined(ENABLE_ITTI)
itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info, messages_definition_xml, itti_dump_file);
# if defined(ENABLE_USE_MME)
if (itti_create_task(TASK_SCTP, sctp_eNB_task, NULL) < 0) {
LOG_E(EMU, "Create task failed");
LOG_D(EMU, "Initializing SCTP task interface: FAILED\n");
return -1;
}
if (itti_create_task(TASK_S1AP, s1ap_eNB_task, NULL) < 0) {
LOG_E(EMU, "Create task failed");
LOG_D(EMU, "Initializing S1AP task interface: FAILED\n");
return -1;
}
# endif
if (itti_create_task(TASK_L2L1, l2l1_task, NULL) < 0) {
LOG_E(EMU, "Create task failed");
LOG_D(EMU, "Initializing L2L1 task interface: FAILED\n");
return -1;
}
// Handle signals until all tasks are terminated
// itti_wait_tasks_end();
#endif
if (ouput_vcd) {
if (UE_flag==1)
vcd_signal_dumper_init("/tmp/openair_dump_UE.vcd");
else
vcd_signal_dumper_init("/tmp/openair_dump_eNB.vcd");
}
#ifdef NAS_NETLINK
netlink_init();
#endif
// to make a graceful exit when ctrl-c is pressed
signal(SIGSEGV, signal_handler);
signal(SIGINT, signal_handler);
#ifndef RTAI
check_clock();
#endif
g_log->log_component[HW].level = LOG_DEBUG;
g_log->log_component[HW].flag = LOG_HIGH;
#ifdef OPENAIR2
g_log->log_component[PHY].level = LOG_INFO;
#else
g_log->log_component[PHY].level = LOG_INFO;
#endif
g_log->log_component[PHY].flag = LOG_HIGH;
g_log->log_component[MAC].level = LOG_INFO;
g_log->log_component[MAC].flag = LOG_HIGH;
g_log->log_component[RLC].level = LOG_INFO;
g_log->log_component[RLC].flag = LOG_HIGH;
g_log->log_component[PDCP].level = LOG_INFO;
g_log->log_component[PDCP].flag = LOG_HIGH;
g_log->log_component[OTG].level = LOG_INFO;
g_log->log_component[OTG].flag = LOG_HIGH;
g_log->log_component[RRC].level = LOG_INFO;
g_log->log_component[RRC].flag = LOG_HIGH;
// Initialize card
ret = openair0_open();
if ( ret != 0 ) {
if (ret == -1)
printf("Error opening /dev/openair0");
if (ret == -2)
printf("Error mapping bigshm");
if (ret == -3)
printf("Error mapping RX or TX buffer");
return(ret);
}
printf ("Detected %d number of cards, %d number of antennas.\n", openair0_num_detected_cards, openair0_num_antennas[card]);
p_exmimo_config = openair0_exmimo_pci[card].exmimo_config_ptr;
p_exmimo_id = openair0_exmimo_pci[card].exmimo_id_ptr;
printf("Card %d: ExpressMIMO %d, HW Rev %d, SW Rev 0x%d\n", card, p_exmimo_id->board_exmimoversion, p_exmimo_id->board_hwrev, p_exmimo_id->board_swrev);
if (p_exmimo_id->board_swrev>=BOARD_SWREV_CNTL2)
p_exmimo_config->framing.eNB_flag = 0;
else
p_exmimo_config->framing.eNB_flag = !UE_flag;
p_exmimo_config->framing.tdd_config = DUPLEXMODE_FDD + TXRXSWITCH_LSB;
for (ant=0; ant<4; ant++)
p_exmimo_config->framing.resampling_factor[ant] = RESAMPLING_FACTOR;
/*
for (ant=0;ant<max(frame_parms->nb_antennas_tx,frame_parms->nb_antennas_rx);ant++)
p_exmimo_config->rf.rf_mode[ant] = rf_mode_base;
for (ant=0;ant<frame_parms->nb_antennas_tx;ant++)
p_exmimo_config->rf.rf_mode[ant] += (TXEN + DMAMODE_TX);
for (ant=0;ant<frame_parms->nb_antennas_rx;ant++)
p_exmimo_config->rf.rf_mode[ant] += (RXEN + DMAMODE_RX);
for (ant=max(frame_parms->nb_antennas_tx,frame_parms->nb_antennas_rx);ant<4;ant++) {
p_exmimo_config->rf.rf_mode[ant] = 0;
carrier_freq[ant] = 0; //this turns off all other LIMEs
}
*/
ant_offset = 0;
for (ant=0; ant<4; ant++) {
if (ant==ant_offset) {
//if (1) {
p_exmimo_config->rf.rf_mode[ant] = rf_mode_base;
//p_exmimo_config->rf.rf_mode[ant] += (TXEN + DMAMODE_TX);
p_exmimo_config->rf.rf_mode[ant] += (RXEN + DMAMODE_RX);
}
else {
p_exmimo_config->rf.rf_mode[ant] = 0;
carrier_freq[ant] = 0; //this turns off all other LIMEs
}
}
for (ant = 0; ant<4; ant++) {
p_exmimo_config->rf.do_autocal[ant] = 1;
p_exmimo_config->rf.rf_freq_rx[ant] = carrier_freq[ant];
p_exmimo_config->rf.rf_freq_tx[ant] = carrier_freq[ant];
p_exmimo_config->rf.rx_gain[ant][0] = rxgain[ant];
p_exmimo_config->rf.tx_gain[ant][0] = txgain[ant];
p_exmimo_config->rf.rf_local[ant] = rf_local[ant];
p_exmimo_config->rf.rf_rxdc[ant] = rf_rxdc[ant];
if ((carrier_freq[ant] >= 850000000) && (carrier_freq[ant] <= 865000000)) {
p_exmimo_config->rf.rf_vcocal[ant] = rf_vcocal_850[ant];
p_exmimo_config->rf.rffe_band_mode[ant] = DD_TDD;
}
else if ((carrier_freq[ant] >= 1900000000) && (carrier_freq[ant] <= 2000000000)) {
p_exmimo_config->rf.rf_vcocal[ant] = rf_vcocal[ant];
p_exmimo_config->rf.rffe_band_mode[ant] = B19G_TDD;
}
else {
p_exmimo_config->rf.rf_vcocal[ant] = rf_vcocal[ant];
p_exmimo_config->rf.rffe_band_mode[ant] = 0;
}
p_exmimo_config->rf.rffe_gain_txlow[ant] = 31;
p_exmimo_config->rf.rffe_gain_txhigh[ant] = 31;
p_exmimo_config->rf.rffe_gain_rxfinal[ant] = 52;
p_exmimo_config->rf.rffe_gain_rxlow[ant] = 31;
}
number_of_cards = openair0_num_detected_cards;
/*
if (p_exmimo_id->board_exmimoversion==1) //ExpressMIMO1
openair_daq_vars.timing_advance = 138;
else //ExpressMIMO2
openair_daq_vars.timing_advance = 0;
*/
openair0_dump_config(card);
printf("EXMIMO_CONFIG: rf_mode 0x %x %x %x %x, [0]: TXRXEn %d, TXLPFEn %d, TXLPF %d, RXLPFEn %d, RXLPF %d, RFBB %d, LNA %d, LNAGain %d, RXLPFMode %d, SWITCH %d, rf_rxdc %d, rf_local %d, rf_vcocal %d\n",
p_exmimo_config->rf.rf_mode[0],
p_exmimo_config->rf.rf_mode[1],
p_exmimo_config->rf.rf_mode[2],
p_exmimo_config->rf.rf_mode[3],
(p_exmimo_config->rf.rf_mode[0]&3), // RXen+TXen
(p_exmimo_config->rf.rf_mode[0]&4)>>2, //TXLPFen
(p_exmimo_config->rf.rf_mode[0]&TXLPFMASK)>>3, //TXLPF
(p_exmimo_config->rf.rf_mode[0]&128)>>7, //RXLPFen
(p_exmimo_config->rf.rf_mode[0]&RXLPFMASK)>>8, //TXLPF
(p_exmimo_config->rf.rf_mode[0]&RFBBMASK)>>16, // RFBB mode
(p_exmimo_config->rf.rf_mode[0]&LNAMASK)>>12, // RFBB mode
(p_exmimo_config->rf.rf_mode[0]&LNAGAINMASK)>>14, // RFBB mode
(p_exmimo_config->rf.rf_mode[0]&RXLPFMODEMASK)>>19, // RXLPF mode
(p_exmimo_config->framing.tdd_config&TXRXSWITCH_MASK)>>1, // Switch mode
p_exmimo_config->rf.rf_rxdc[0],
p_exmimo_config->rf.rf_local[0],
p_exmimo_config->rf.rf_vcocal[0]);
for (ant=0;ant<4;ant++)
p_exmimo_config->rf.do_autocal[ant] = 0;
#ifdef EMOS
error_code = rtf_create(CHANSOUNDER_FIFO_MINOR,CHANSOUNDER_FIFO_SIZE);
if (error_code==0)
printf("[OPENAIR][SCHED][INIT] Created EMOS FIFO %d\n",CHANSOUNDER_FIFO_MINOR);
else if (error_code==ENODEV)
printf("[OPENAIR][SCHED][INIT] Problem: EMOS FIFO %d is greater than or equal to RTF_NO\n",CHANSOUNDER_FIFO_MINOR);
else if (error_code==ENOMEM)
printf("[OPENAIR][SCHED][INIT] Problem: cannot allocate memory for EMOS FIFO %d\n",CHANSOUNDER_FIFO_MINOR);
else
printf("[OPENAIR][SCHED][INIT] Problem creating EMOS FIFO %d, error_code %d\n",CHANSOUNDER_FIFO_MINOR,error_code);
#endif
mlockall(MCL_CURRENT | MCL_FUTURE);
#ifdef RTAI
// make main thread LXRT soft realtime
task = rt_task_init_schmod(nam2num("MYTASK"), 9, 0, 0, SCHED_FIFO, 0xF);
// start realtime timer and scheduler
#ifdef TIMER_ONESHOT_MODE
rt_set_oneshot_mode();
start_rt_timer(0);
printf("started RTAI timer inoneshot mode\n");
#else
rt_set_periodic_mode();
period = start_rt_timer(nano2count(500000));
printf("started RTAI timer with period %llu ns\n",count2nano(period));
#endif
printf("Init mutex\n");
//mutex = rt_get_adr(nam2num("MUTEX"));
mutex = rt_sem_init(nam2num("MUTEX"), 1);
if (mutex==0)
{
printf("Error init mutex\n");
exit(-1);
}
else
printf("mutex=%p\n",mutex);
#endif
DAQ_MBOX = (volatile unsigned int *) openair0_exmimo_pci[card].rxcnt_ptr[0];
// this starts the DMA transfers
if (UE_flag!=1)
openair0_start_rt_acquisition(card);
#ifdef XFORMS
if (do_forms==1) {
fl_initialize (&argc, argv, NULL, 0, 0);
form_stats = create_form_stats_form();
if (UE_flag==1) {
form_ue[UE_id] = create_lte_phy_scope_ue();
sprintf (title, "LTE DL SCOPE UE");
fl_show_form (form_ue[UE_id]->lte_phy_scope_ue, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);
} else {
for(UE_id=0;UE_id<scope_enb_num_ue;UE_id++) {
form_enb[UE_id] = create_lte_phy_scope_enb();
sprintf (title, "UE%d LTE UL SCOPE eNB",UE_id+1);
fl_show_form (form_enb[UE_id]->lte_phy_scope_enb, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);
}
}
fl_show_form (form_stats->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "stats");
if (UE_flag==0) {
for (UE_id=0;UE_id<scope_enb_num_ue;UE_id++) {
if (otg_enabled) {
fl_set_button(form_enb[UE_id]->button_0,1);
fl_set_object_label(form_enb[UE_id]->button_0,"DL Traffic ON");
}
else {
fl_set_button(form_enb[UE_id]->button_0,0);
fl_set_object_label(form_enb[UE_id]->button_0,"DL Traffic OFF");
}
}
}
else {
if (openair_daq_vars.use_ia_receiver) {
fl_set_button(form_ue[UE_id]->button_0,1);
fl_set_object_label(form_ue[UE_id]->button_0, "IA Receiver ON");
}
else {
fl_set_button(form_ue[UE_id]->button_0,0);
fl_set_object_label(form_ue[UE_id]->button_0, "IA Receiver OFF");
}
}
ret = pthread_create(&thread2, NULL, scope_thread, NULL);
printf("Scope thread created, ret=%d\n",ret);
}
#endif
#ifdef EMOS
ret = pthread_create(&thread3, NULL, emos_thread, NULL);
printf("EMOS thread created, ret=%d\n",ret);
#endif
rt_sleep_ns(10*FRAME_PERIOD);
#ifndef RTAI
pthread_attr_init (&attr_dlsch_threads);
pthread_attr_setstacksize(&attr_dlsch_threads,OPENAIR_THREAD_STACK_SIZE);
//attr_dlsch_threads.priority = 1;
sched_param_dlsch.sched_priority = sched_get_priority_max(SCHED_FIFO); //OPENAIR_THREAD_PRIORITY;
pthread_attr_setschedparam (&attr_dlsch_threads, &sched_param_dlsch);
pthread_attr_setschedpolicy (&attr_dlsch_threads, SCHED_FIFO);
#endif
// start the main thread
if (UE_flag == 1) {
/*
#ifdef RTAI
thread1 = rt_thread_create(UE_thread, NULL, 100000000);
#else
error_code = pthread_create(&thread1, &attr_dlsch_threads, UE_thread, NULL);
if (error_code!= 0) {
LOG_D(HW,"[lte-softmodem.c] Could not allocate UE_thread, error %d\n",error_code);
return(error_code);
}
else {
LOG_D(HW,"[lte-softmodem.c] Allocate UE_thread successful\n");
}
#endif
#ifdef DLSCH_THREAD
init_rx_pdsch_thread();
rt_sleep_ns(FRAME_PERIOD/10);
init_dlsch_threads();
#endif
printf("UE threads created\n");
*/
}
else {
#ifdef RTAI
thread0 = rt_thread_create(eNB_thread, NULL, 100000000);
#else
error_code = pthread_create(&thread0, &attr_dlsch_threads, eNB_thread, NULL);
if (error_code!= 0) {
LOG_D(HW,"[lte-softmodem.c] Could not allocate eNB_thread, error %d\n",error_code);
return(error_code);
}
else {
LOG_D(HW,"[lte-softmodem.c] Allocate eNB_thread successful\n");
}
#endif
#ifdef ULSCH_THREAD
init_ulsch_threads();
#endif
printf("eNB threads created\n");
}
// wait for end of program
printf("TYPE <CTRL-C> TO TERMINATE\n");
//getchar();
while (oai_exit==0)
rt_sleep_ns(FRAME_PERIOD);
// stop threads
#ifdef XFORMS
printf("waiting for XFORMS thread\n");
if (do_forms==1)
{
pthread_join(thread2,&status);
fl_hide_form(form_stats->stats_form);
fl_free_form(form_stats->stats_form);
if (UE_flag==1) {
fl_hide_form(form_ue[UE_id]->lte_phy_scope_ue);
fl_free_form(form_ue[UE_id]->lte_phy_scope_ue);
} else {
for(UE_id=0;UE_id<scope_enb_num_ue;UE_id++) {
fl_hide_form(form_enb[UE_id]->lte_phy_scope_enb);
fl_free_form(form_enb[UE_id]->lte_phy_scope_enb);
}
}
}
#endif
printf("stopping MODEM threads\n");
// cleanup
if (UE_flag == 1) {
/*
#ifdef RTAI
rt_thread_join(thread1);
#else
pthread_join(thread1,&status);
#endif
#ifdef DLSCH_THREAD
cleanup_dlsch_threads();
cleanup_rx_pdsch_thread();
#endif
*/
}
else {
#ifdef RTAI
rt_thread_join(thread0);
#else
pthread_join(thread0,&status);
#endif
#ifdef ULSCH_THREAD
cleanup_ulsch_threads();
#endif
}
#ifdef OPENAIR2
//cleanup_pdcp_thread();
#endif
#ifdef RTAI
stop_rt_timer();
#endif
printf("stopping card\n");
openair0_stop(card);
printf("closing openair0_lib\n");
openair0_close();
#ifdef EMOS
printf("waiting for EMOS thread\n");
pthread_cancel(thread3);
pthread_join(thread3,&status);
#endif
#ifdef EMOS
error_code = rtf_destroy(CHANSOUNDER_FIFO_MINOR);
printf("[OPENAIR][SCHED][CLEANUP] EMOS FIFO closed, error_code %d\n", error_code);
#endif
if (ouput_vcd)
vcd_signal_dumper_close();
logClean();
return 0;
}
static void CB_cancel(FL_OBJECT *ob, long arg) {
fl_hide_form(INPUT_FORM);
fl_free_object(INPUT_OBJ1);
fl_free_object(INPUT_OBJ2);
fl_free_form(INPUT_FORM);
}
