Example #1
0
int main(void)
{
	RT_TASK *Main_Task;
	long msg;

	if (!(Main_Task = rt_thread_init(nam2num("MNTSK"), 10, 0, SCHED_FIFO, 0xF))) {
		printf("CANNOT INIT MAIN TASK\n");
		exit(1);
	}

	if (!(hard_timer_running = rt_is_hard_timer_running())) {
		start_rt_timer(0);
	}
	barrier = rt_sem_init(nam2num("PREMS"), 4);
	latency_thread = rt_thread_create(latency_fun, NULL, 0);
	fast_thread    = rt_thread_create(fast_fun, NULL, 0);
	slow_thread    = rt_thread_create(slow_fun, NULL, 0);
	start = rt_get_time() + nano2count(200000000);
	rt_sem_wait_barrier(barrier);
	rt_receive(0, &msg);
	end = 1;
	rt_sem_wait_barrier(barrier);
	rt_thread_join(latency_thread);
	rt_thread_join(fast_thread);
	rt_thread_join(slow_thread);
	if (!hard_timer_running) {
		stop_rt_timer();
	}
	rt_sem_delete(barrier);
	rt_thread_delete(Main_Task);
	return 0;
}
Example #2
0
int main(void)
{
	RT_TASK *mytask;
	int smbx, rmbx[NTASKS];
	int i, bthread, mthread[NTASKS];
	char msg[] = "let's end the game";

	mytask = rt_thread_init(nam2num("MAIN"), 2, 0, SCHED_FIFO, 0xF);
	barrier = rt_sem_init(rt_get_name(0), NTASKS + 1);

	smbx    = rt_msgget(nam2num("SMSG"), 0x666 | IPC_CREAT);
	for (i = 0; i < NTASKS; i++) {
		char mname[6] = "RMBX";
		mname[4] = i + '0';
		mname[5] = 0;
		rmbx[i] = rt_msgget(nam2num(mname), 0x666 | IPC_CREAT);
	}

	rt_set_oneshot_mode();
	start_rt_timer(0);

	bthread = rt_thread_create(bfun, 0, 0x8000);
	for (i = 0; i < NTASKS; i++) {
		mthread[i] = rt_thread_create(mfun, (void *)i, 0x8000);
	}

	printf("IF NOTHING HAPPENS IS OK, TYPE ENTER TO FINISH.\n");
	getchar();

	for (i = 0; i < NTASKS; i++) {
		end = i;
		rt_msgsnd_nu(rmbx[i], 1, msg, sizeof(msg), 0);
		rt_thread_join(mthread[i]);
	}

	end = NTASKS;
	rt_msgsnd_nu(smbx, 1, msg, sizeof(msg), 0);
	rt_thread_join(bthread);

	for (i = 0; i < NTASKS; i++) {
		rt_msgctl(rmbx[i], IPC_RMID, NULL);
		printf("TASK %d, LOOPS: %d.\n", i, cnt[i]); 
	}
	rt_msgctl(smbx, IPC_RMID, NULL);

	stop_rt_timer();
	rt_sem_delete(barrier);
	rt_task_delete(mytask);
	printf("MAIN TASK ENDS.\n");
	return 0;
}
Example #3
0
int main(int argc, char *argv[])
{
        RT_TASK *task;
        struct sockaddr_in addr;
	int i, srvport;

        if (!(task = rt_task_init(nam2num("TSKCOD"), 0, 0, 0))) {
                printf("CANNOT INIT TASK CODE\n");
                exit(1);
        }
        comnode = 0;
        if (argc == 2 && strstr(argv[1], "ComNode=")) {
              	inet_aton(argv[1] + 8, &addr.sin_addr);
                comnode = addr.sin_addr.s_addr;
        }
        if (!comnode) {
                inet_aton("127.0.0.1", &addr.sin_addr);
                comnode = addr.sin_addr.s_addr;
        }
        init_module();
        for (i = 0; i < NUM_TASKS; i++) {
		rt_thread_join(thread[i]);
        }
	while ((srvport = rt_request_port(comnode)) <= 0) {
		msleep(100);
	}
	RT_sem_signal(comnode, srvport, end_sem);
	rt_release_port(comnode, srvport);
	rt_task_delete(task);
	exit(0);
}
Example #4
0
int main(void)
{
	int i, indx[NTASKS];       
	unsigned long mytask_name = nam2num("MASTER");

	signal(SIGINT, endme);

 	if (!(mytask = rt_task_init(mytask_name, 1, 0, 0))) {
		printf("CANNOT INIT TASK %lu\n", mytask_name);
		exit(1);
	}
	printf("MASTER INIT: name = %lu, address = %p.\n", mytask_name, mytask);

	sem = rt_sem_init(10000, 0); 
	rt_set_oneshot_mode();
//	rt_set_periodic_mode();
	start_rt_timer(0);

	for (i = 0; i < ntasks; i++) {
		indx[i] = i;
		if (!(task[i] = rt_thread_create(thread_fun, &indx[i], 10000))) {
			printf("ERROR IN CREATING THREAD %d\n", indx[i]);
			exit(1);
 		}       
 	}       

	for (i = 0; i < ntasks; i++) {
		while (!rt_get_adr(taskname(i))) {
			rt_sleep(nano2count(20000000));
		}
	}

	for (i = 0; i < ntasks; i++) {
		rt_send(rt_get_adr(taskname(i)), (unsigned long)sem);
	}

	for (i = 0; i < ntasks; i++) {
		rt_sem_wait(sem);
	}

	for (i = 0; i < ntasks; i++) {
		while (rt_get_adr(taskname(i))) {
			rt_sleep(nano2count(20000000));
		}
	}

	for (i = 0; i < ntasks; i++) {
		rt_thread_join(task[i]);
	}
	rt_sem_delete(sem);
	stop_rt_timer();
	rt_task_delete(mytask);
	printf("MASTER %lu %p ENDS\n", mytask_name, mytask);
	return 0;
}
int main (void)
{	
	
	M3EcSystemShm * sys;
	RT_TASK *task;
	pthread_t ptsys;
	int cntr=0;
	
	signal(SIGINT, endme);

	sys = rtai_malloc (nam2num(SHMNAM_M3MKMD),1);
	if (sys==-1) 
	{
		printf("Error allocating shared memory\n");
		return 0;
	}
	int ns=sys->slaves_active;
	printf("Found %d active M3 EtherCAT slaves\n",ns);
	if (ns==0)
	{
		printf("No slaves available. Exiting...\n");
		return 0;
	}
	rt_allow_nonroot_hrt();
	if (!(task = rt_task_init_schmod(nam2num("M3MAIN"), RT_TASK_PRIORITY, 0, 0, SCHED_FIFO, 0xF)))
	{
		rt_shm_free(nam2num(SHMNAM_M3MKMD));
		printf("Cannot init the RTAI task %s\n","M3MAIN");
		return 0;
	}
	hst=rt_thread_create((void*)rt_system_thread, sys, 10000);
	usleep(100000); //Let start up
	if (!sys_thread_active)
	{
		rt_task_delete(task);
		rt_shm_free(nam2num(SHMNAM_M3MKMD));
		printf("Startup of thread failed.\n",0);
		return 0;
	}
	while(!end)
	{
		//SysEcShmPrettyPrint(sys);
		usleep(250000);
		
	}
	printf("Removing RT thread...\n",0);
	sys_thread_end=1;
	rt_thread_join(hst);
	if (sys_thread_active)printf("Real-time thread did not shutdown correctly\n");
	rt_task_delete(task);
	rt_shm_free(nam2num(SHMNAM_M3MKMD));
	return 0;
}
int main(void)
{
    long signal_a;
    long signal_b;
    t_info a = {
        .id = 'A',
    };
    t_info b = {
        .id = 'B',
    };

    finish = 0;

    rt_set_periodic_mode();
    start_rt_timer(nano2count(TICK_TIME));
    rt_make_hard_real_time();

    a.delay = 0;
    a.period = nano2count(TICK_TIME);
    signal_a = rt_thread_create(&signal_func, &a, 500);
    if (!signal_a) {
        printf("Can not initialize signal A\n");
        return -ENODEV;
    }

    b.delay = nano2count(DELAY_TIME);
    b.period = nano2count(TICK_TIME);
    signal_b = rt_thread_create(&signal_func, &b, 500);
    if (!signal_b) {
        printf("Can not initialize signal B\n");
        return -ENODEV;
    }
    scanf("%d", &finish);
    finish = 1;

    rt_thread_join(signal_a);
    rt_thread_join(signal_b);
    pthread_exit(NULL);
    return 0;
}
Example #7
0
/*
 * Shutdown all of the worker threads and free up their resources
 */
void destroy_render_threads(scenedef * scene) {
    thr_parms * parms = (thr_parms *) scene->threadparms;
    rt_thread_t * threads = (rt_thread_t *) scene->threads;
    int thr;
#if defined(MPI) && defined(THR)
    int row;
#endif

    if (scene->threads != NULL) {
        /* wake up sleepers and tell them to exit */
        rt_thread_barrier(parms[0].runbar, 0);

        /* wait for all sleepers to exit */
        for (thr=1; thr<parms[0].nthr; thr++)
            rt_thread_join(threads[thr], NULL);

        /* destroy the thread barrier */
        rt_thread_barrier_destroy(parms[0].runbar);

        free(scene->threads);
    }

    if (scene->threadparms != NULL) {
        /* deallocate thread parameter buffers
         * NOTE: This has to use the remembered number of threads stored in the
         *       thread parameter area for thread 0, since the one in the scene
         *       may have changed on us.
         */
        for (thr=0; thr < parms[0].nthr; thr++) {
            if (parms[thr].local_mbox != NULL)
                free(parms[thr].local_mbox);
        }

#if defined(MPI) && defined(THR)
        /* destroy and free row barriers for MPI builds */
        for (row=0; row<parms[0].numrowbars; row++) {
            rt_atomic_int_destroy(&parms[0].rowbars[row]);
        }
        rt_atomic_int_destroy(parms[0].rowsdone);
        free(parms[0].rowbars);
        free(parms[0].rowsdone);
#endif

        free(scene->threadparms);
    }

    scene->threads = NULL;
    scene->threadparms = NULL;
}
Example #8
0
int main(void)
{
	rt_thread_init(nam2num("MNTSK"), 100, 0, SCHED_FIFO, 0x1);
	rt_printk("\nTESTING THE SCHEDULER WITH SEMs [%d LOOPs].\n", LOOPS);

	sem1 = rt_sem_init(nam2num("SEM1"), 0);    
	sem2 = rt_sem_init(nam2num("SEM2"), 0);    

	thread1 = rt_thread_create(task1, NULL, STACK_SIZE);
	poll(NULL, 0, 100);
	thread2 = rt_thread_create(task2, NULL, STACK_SIZE);

	rt_thread_join(thread2);
	end = 1;
	rt_sem_signal(sem1);
	rt_thread_join(thread1);

	rt_sem_delete(sem1);    
	rt_sem_delete(sem2);    

        rt_task_delete(NULL);
	rt_printk("END SCHEDULER TEST WITH SEMs.\n\n");
	return 0;
}
Example #9
0
File: sound.c Project: ArcEye/RTAI
int main(void)
{
	pthread_t thread;
	unsigned int player, cnt;
	unsigned long msg;
	RT_TASK *mytask;
	MBX *mbx;
	char data[BUFSIZE];

	signal(SIGINT, endme);
	rt_allow_nonroot_hrt();

	if ((player = open("../../../share/linux.au", O_RDONLY)) < 0) {
		printf("ERROR OPENING SOUND FILE (linux.au)\n");
		exit(1);
	}
 	if (!(mytask = rt_task_init(nam2num("SNDMAS"), 2, 0, 0))) {
		printf("CANNOT INIT MASTER TASK\n");
		exit(1);
	}
	mlockall(MCL_CURRENT | MCL_FUTURE);
	printf("\nINIT MASTER TASK %p\n\n(CTRL-C TO END EVERYTHING)\n", mytask);

	mbx = rt_typed_named_mbx_init("SNDMBX", 2000, FIFO_Q);
	rt_set_oneshot_mode();
	start_rt_timer(0);
	thread = rt_thread_create(intr_handler, NULL, 10000);
	rt_mbx_receive(mbx, &data, 1);

	while (!end) {	
		lseek(player, 0, SEEK_SET);
		while(!end && (cnt = read(player, &data, BUFSIZE)) > 0) {
			rt_mbx_send(mbx, data, cnt);
		}
	}

	rt_rpc(rt_get_adr(nam2num("SOUND")), msg, &msg); 
	while (rt_get_adr(nam2num("SOUND"))) {
		rt_sleep(nano2count(1000000));
	}
	rt_task_delete(mytask);
	rt_mbx_delete(mbx);
	stop_rt_timer();
	close(player);
	printf("\nEND MASTER TASK %p\n", mytask);
	rt_thread_join(thread);
	return 0;
}
Example #10
0
int main(int argc, char *argv[])
{
        RT_TASK *task;
        struct sockaddr_in addr;
	int i, srvport;

        if (!(task = rt_task_init(nam2num("STRTSK"), 0, 0, 0))) {
                printf("CANNOT INIT START_TASK TASK\n");
                exit(1);
        }

        comnode = tasknode = 0;
        for (i = 0; i < argc; i++) {
                if (strstr(argv[i], "ComNode=")) {
                	inet_aton(argv[i] + 8, &addr.sin_addr);
	                comnode = addr.sin_addr.s_addr;
                        argv[i] = 0;
                        continue;
                }
                if (strstr(argv[i], "TaskNode=")) {
                	inet_aton(argv[i] + 9, &addr.sin_addr);
	                tasknode = addr.sin_addr.s_addr;
                        argv[i] = 0;
                        continue;
                }
        }
        if (!comnode) {
                inet_aton("127.0.0.1", &addr.sin_addr);
                comnode = addr.sin_addr.s_addr;
        }
        if (!tasknode) {
                inet_aton("127.0.0.1", &addr.sin_addr);
                tasknode = addr.sin_addr.s_addr;
        }
	rt_grow_and_lock_stack(100000);
	init_module();
	rt_thread_join(thread);
        while ((srvport = rt_request_hard_port(comnode)) <= 0) {
                msleep(100);
        }
	rt_make_hard_real_time();
        RT_sem_signal(comnode, srvport, end_sem);
	rt_make_soft_real_time();
        rt_release_port(comnode, srvport);
        rt_task_delete(task);
	exit(0);
}
Example #11
0
int main(void)
{
	RT_TASK *mytask;
	RT_MSGQ *smbx;
	int bthread;
	char msg[] = "let's end the game";

	mytask = rt_thread_init(nam2num("MAIN"), 2, 0, SCHED_FIFO, 0xF);

	smbx = rt_msgq_init(nam2num("SMSG"), 0, 0);
	bthread = rt_thread_create(bfun, 0, 0x8000);

	printf("IF NOTHING HAPPENS IS OK, TYPE ENTER TO FINISH.\n");
	getchar();

	end = 1;
	rt_msg_send(smbx, msg, sizeof(msg), 1);
	rt_thread_join(bthread);

	rt_task_delete(mytask);
	printf("MAIN TASK ENDS.\n");
	return 0;
}
Example #12
0
void TestRTAI::stop()
{
    continueRunning = false;
    rt_thread_join(rtThreadID);  // blocks until the real-time thread exits.
    rt_task_delete(normalTask);
}
Example #13
0
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;
}
Example #14
0
int calc_grid_energies_excl_mgrid(float* atoms, float* grideners, long int numplane, long int numcol, long int numpt, long int natoms, float gridspacing, unsigned char* excludepos, int maxnumprocs) {
// cionize_params* params, cionize_molecule* molecule, cionize_grid* grid) {
  int i;
  enthrparms *parms;
  rt_thread_t * threads;

#if defined(THR)
  int numprocs;
  int availprocs = rt_thread_numprocessors();
  if (params->maxnumprocs <= availprocs) {
    numprocs = params->maxnumprocs;
  } else {
    numprocs = availprocs;
  }
#else
  int numprocs = 1;
#endif

  printf("calc_grid_energies_excl_mgrid()\n");

  /* DH: setup and compute long-range */
  MgridParam mg_prm;
  MgridSystem mg_sys;
  Mgrid mg;
  //MgridLattice *lattice;
  int j, k;
  int gridfactor;

  double h, h_1;
  int nspacings;

  double *eh;
  int ndim;
  int ii, jj, kk;
  int im, jm, km;
  int ilo, jlo, klo;
  double dx_h, dy_h, dz_h;
  double xphi[4], yphi[4], zphi[4];
  double t, en, c;
  int koff, jkoff, index;

  rt_timerhandle timer;
  float totaltime;

  memset(&mg_prm, 0, sizeof(mg_prm));
  memset(&mg_sys, 0, sizeof(mg_sys));

  /*
   * set mgrid parameters
   *
   * make sure origin of mgrid's grid is at ionize's grid origin (0,0,0)
   *
   * length is (number of grid spacings) * (grid spacing),
   * where the number of spacings is one less than number of grid points
   */
  mg_prm.length = (numpt-1) * gridspacing;
  mg_prm.center.x = 0.5 * mg_prm.length;
  mg_prm.center.y = 0.5 * mg_prm.length;
  mg_prm.center.z = 0.5 * mg_prm.length;

  /* make sure domain and grid are both cubic */
  if (numpt != numcol || numcol != numplane) {
    printf("ERROR: grid must be cubic\n");
    return -1;
  }

  /*
   * grid used by mgrid needs spacing h >= 2
   *
   * determine grid factor:  (2^gridfactor)*h_ionize = h_mgrid
   */
  gridfactor = 0;
  //nspacings = numpt - 1;
  nspacings = numpt;
    /* add one more spacing so that interpolation loop below will work */
  h = gridspacing;
  while (h < 2.0) {
    h *= 2;
    nspacings = ((nspacings & 1) ? nspacings/2 + 1 : nspacings/2);
    gridfactor++;
  }
  mg_prm.nspacings = nspacings;

  /* have to modify mgrid length */
  mg_prm.length += h;
  mg_prm.center.x = 0.5 * mg_prm.length;
  mg_prm.center.y = 0.5 * mg_prm.length;
  mg_prm.center.z = 0.5 * mg_prm.length;
  h_1 = 1.0/h;

  mg_prm.cutoff = CUTOFF;
  mg_prm.boundary = MGRID_NONPERIODIC;

  /* choice of splitting must be consistent with short-range below */
#if defined(CUBIC_TAYLOR2)
  mg_prm.approx = MGRID_CUBIC;
  mg_prm.split = MGRID_TAYLOR2;
#elif defined(QUINTIC1_TAYLOR3)
  mg_prm.approx = MGRID_QUINTIC1;
  mg_prm.split = MGRID_TAYLOR3;
#elif defined(HEPTIC1_TAYLOR4)
  mg_prm.approx = MGRID_HEPTIC1;
  mg_prm.split = MGRID_TAYLOR4;
  /*
#elif defined(HERMITE_TAYLOR3)
  mg_prm.approx = MGRID_HERMITE;
  mg_prm.split = MGRID_TAYLOR3;
  */
#endif

  mg_prm.natoms = natoms;
  printf("natom = %d\n", mg_prm.natoms);
  printf("mgrid center = %g %g %g\n",
      mg_prm.center.x, mg_prm.center.y, mg_prm.center.z);
  printf("mgrid length = %g\n", mg_prm.length);
  printf("mgrid nspacings = %d\n", mg_prm.nspacings);

  /* setup mgrid system */
  mg_sys.f_elec = (MD_Dvec *) calloc(mg_prm.natoms, sizeof(MD_Dvec));
  mg_sys.pos = (MD_Dvec *) calloc(mg_prm.natoms, sizeof(MD_Dvec));
  mg_sys.charge = (double *) calloc(mg_prm.natoms, sizeof(double));
  for (i = 0;  i < mg_prm.natoms;  i++) {
    mg_sys.pos[i].x  = atoms[4*i    ];
    mg_sys.pos[i].y  = atoms[4*i + 1];
    mg_sys.pos[i].z  = atoms[4*i + 2];
    mg_sys.charge[i] = atoms[4*i + 3];
  }

  /* setup mgrid solver and compute */
  if (mgrid_param_config(&mg_prm)) {
    printf("ERROR: mgrid_param_config() failed\n");
    return -1;
  }
  printf("spacing = %g\n", mg_prm.spacing);
  if (mgrid_init(&mg)) {
    printf("ERROR: mgrid_init() failed\n");
    return -1;
  }
  if (mgrid_setup(&mg, &mg_sys, &mg_prm)) {
    printf("ERROR: mgrid_setup() failed\n");
    return -1;
  }

  timer = rt_timer_create();
  rt_timer_start(timer);

  if (mgrid_force(&mg, &mg_sys)) {
    printf("ERROR: mgrid_force() failed\n");
    return -1;
  }
  /* DH: end setup and compute long-range */

  printf("  using %d processors\n", numprocs);  

  /* allocate array of threads */
  threads = (rt_thread_t *) calloc(numprocs * sizeof(rt_thread_t), 1);

  /* allocate and initialize array of thread parameters */
  parms = (enthrparms *) malloc(numprocs * sizeof(enthrparms));
  for (i=0; i<numprocs; i++) {
    parms[i].threadid = i;
    parms[i].threadcount = numprocs;
    parms[i].atoms = atoms;
    parms[i].grideners = grideners;
    parms[i].numplane = numplane;
    parms[i].numcol = numcol;
    parms[i].numpt = numpt;
    parms[i].natoms = natoms;
    parms[i].gridspacing = gridspacing;
    parms[i].excludepos = excludepos;
  }

#if defined(THR)
  /* spawn child threads to do the work */
  for (i=0; i<numprocs; i++) {
    rt_thread_create(&threads[i], energythread, &parms[i]);
  }

  /* join the threads after work is done */
  for (i=0; i<numprocs; i++) {
    rt_thread_join(threads[i], NULL);
  } 
#else
  /* single thread does all of the work */
  energythread((void *) &parms[0]);
#endif

  /* DH: tabulate and cleanup long-range */

  /* interpolate from mgrid potential lattice */

  eh = (double *)(mg.egrid[0].data); /* mgrid's long-range potential lattice */
  ndim = mg.egrid[0].ni;  /* number of points in each dimension of lattice */

  for (kk = 0;  kk < numplane;  kk++) {
    for (jj = 0;  jj < numcol;  jj++) {
      for (ii = 0;  ii < numpt;  ii++) {

        /* distance between atom and corner measured in grid points */
        dx_h = (ii*gridspacing) * h_1;
        dy_h = (jj*gridspacing) * h_1;
        dz_h = (kk*gridspacing) * h_1;

        /* find closest mgrid lattice point less than or equal to */
        im = ii >> gridfactor;
        jm = jj >> gridfactor;
        km = kk >> gridfactor;

#if defined(CUBIC_TAYLOR2)
        ilo = im-1;
        jlo = jm-1;
        klo = km-1;

        /* find t for x dimension and compute xphi */
        t = dx_h - ilo;
        xphi[0] = 0.5 * (1 - t) * (2 - t) * (2 - t);
        t--;
        xphi[1] = (1 - t) * (1 + t - 1.5 * t * t);
        t--;
        xphi[2] = (1 + t) * (1 - t - 1.5 * t * t);
        t--;
        xphi[3] = 0.5 * (1 + t) * (2 + t) * (2 + t);

        /* find t for y dimension and compute yphi */
        t = dy_h - jlo;
        yphi[0] = 0.5 * (1 - t) * (2 - t) * (2 - t);
        t--;
        yphi[1] = (1 - t) * (1 + t - 1.5 * t * t);
        t--;
        yphi[2] = (1 + t) * (1 - t - 1.5 * t * t);
        t--;
        yphi[3] = 0.5 * (1 + t) * (2 + t) * (2 + t);

        /* find t for z dimension and compute zphi */
        t = dz_h - klo;
        zphi[0] = 0.5 * (1 - t) * (2 - t) * (2 - t);
        t--;
        zphi[1] = (1 - t) * (1 + t - 1.5 * t * t);
        t--;
        zphi[2] = (1 + t) * (1 - t - 1.5 * t * t);
        t--;
        zphi[3] = 0.5 * (1 + t) * (2 + t) * (2 + t);

        /* determine 64=4*4*4 eh grid stencil contribution to potential */
        en = 0;
        for (k = 0;  k < 4;  k++) {
          koff = (k + klo) * ndim;
          for (j = 0;  j < 4;  j++) {
            jkoff = (koff + (j + jlo)) * ndim;
            c = yphi[j] * zphi[k];
            for (i = 0;  i < 4;  i++) {
              index = jkoff + (i + ilo);
              /*
              ASSERT(&eh[index]
                  == mgrid_lattice_elem(&(mg.egrid[0]), i+ilo, j+jlo, k+klo));
                  */
              if (&eh[index] !=
                  mgrid_lattice_elem(&(mg.egrid[0]), i+ilo, j+jlo, k+klo)) {
                printf("ndim=%d  index=%d  i+ilo=%d  j+jlo=%d  k+klo=%d\n"
                    "ia=%d  ib=%d  ni=%d\n"
                    "ja=%d  jb=%d  nj=%d\n"
                    "ka=%d  kb=%d  nk=%d\n",
                    ndim, index, i+ilo, j+jlo, k+klo,
                    mg.egrid[0].ia, mg.egrid[0].ib, mg.egrid[0].ni,
                    mg.egrid[0].ja, mg.egrid[0].jb, mg.egrid[0].nj,
                    mg.egrid[0].ka, mg.egrid[0].kb, mg.egrid[0].nk
                    );
                abort();
              }

              en += eh[index] * xphi[i] * c;
            }
          }
        }
        /* end CUBIC */
#endif

        //ENERGY(grid->eners[k*numcol*numpt + j*numpt + i]);

        grideners[kk*numcol*numpt + jj*numpt + ii] += (float)en;

        //  (float) *((double *)mgrid_lattice_elem(lattice, i, j, k));

        //ENERGY((float) *((double *)mgrid_lattice_elem(lattice, i, j, k)));
        //ENERGY(grid->eners[k*numcol*numpt + j*numpt + i]*560.47254);
      }
    }
  }

  totaltime = rt_timer_timenow(timer);
  printf("total time for mgrid: %.1f\n", totaltime);
  rt_timer_destroy(timer);

  /* cleanup mgrid */
  mgrid_done(&mg);
  free(mg_sys.f_elec);
  free(mg_sys.pos);
  free(mg_sys.charge);
  /* DH: tabulate and cleanup long-range */

  /* free thread parms */
  free(parms);
  free(threads);

  return 0;
}
Example #15
0
int main(int argc, char *argv[])
{
	unsigned long sndnode;
	long sndport, i, r;
	RT_TASK *rcvtsk, *sndtsk;
        struct sockaddr_in addr;
	static MBX *sndmbx;

	SERVER = atoi(argv[1]);
 	if (!(rcvtsk = rt_task_init_schmod(nam2num("RCVTSK"), 2, 0, 0, SCHED_FIFO, 0xF))) {
		printf("CANNOT INIT RECEIVER TASK\n");
		exit(1);
	}

        mbx = rt_mbx_init(nam2num("MBX"), 100);
        athread = rt_thread_create(async_fun, NULL, 10000);
        sndnode = 0;
        if (argc == 3 && strstr(argv[2], "SndNode=")) {
                inet_aton(argv[2] + 8, &addr.sin_addr);
		sndnode = addr.sin_addr.s_addr;
        }
        if (!sndnode) {
                inet_aton("127.0.0.1", &addr.sin_addr);
                sndnode = addr.sin_addr.s_addr;
        }

	rt_set_oneshot_mode();
	start_rt_timer(0);
	while ((sndport = rt_request_port_mbx(sndnode, mbx)) <= 0 && sndport != -EINVAL);
        while (!(sndmbx = RT_get_adr(sndnode, sndport, "SNDMBX"))) {
                rt_sleep(nano2count(100000000));
        }
	sndtsk = RT_get_adr(sndnode, sndport, "SNDTSK");
	printf("\nRECEIVER TASK RUNNING\n");
	mlockall(MCL_CURRENT | MCL_FUTURE);
	rt_make_hard_real_time();

	while (!end) {	
		r = RT_mbx_receive(sndnode, -sndport, sndmbx, &i, sizeof(long));
		rt_printk("RECEIVE %ld %ld\n", r, i);
if (SERVER) {
		rt_sleep(nano2count(100000000)); 
} else {
		while (!end && rt_waiting_return(sndnode, sndport)) {
			rt_sleep(nano2count(1000000)); 
		}
		if (!end) {
			unsigned long long retval;
			long i1, i2;
			int l1, l2;
			if (rt_sync_net_rpc(sndnode, -sndport)) {
				l1 = l2 = sizeof(long);
				rt_get_net_rpc_ret(mbx, &retval, &i1, &l1, &i2, &l2, 0LL, MBX_RECEIVE);
				rt_printk("RECEIVER ASYNC MSG: RETVAL = %d, MSG = %ld, LEN = %d.\n", (int)retval, i1, l1);
				if (i1 < 0) {
					end = 1;
					break;
				}
			}
		}
}
	}

	rt_mbx_delete(mbx);
	rt_release_port(sndnode, sndport);
	rt_make_soft_real_time();
	rt_thread_join(athread);
	rt_return(rt_receive(0, &i), i);
	rt_task_delete(rcvtsk);
	stop_rt_timer();
	printf("\nRECEIVER TASK STOPS\n");
	return 0;
}
Example #16
0
File: clock.c Project: ArcEye/RTAI
int main(int argc, char* argv[])
{
	extern int init_cmdclk(void);
	extern int init_cmdcrn(void);
	extern int init_dispclk(void);
	extern int cleanup_cmdclk(void);
	extern int cleanup_cmdcrn(void);
	extern int cleanup_dispclk(void);
	RT_TASK *mytask;

	hide = FALSE;
	Pause = FALSE;
	sem_init(&sync_sem, 0, 0);

	rt_set_oneshot_mode();
	init_cmdclk();
	init_cmdcrn();
	init_dispclk();

 	if (!(mytask = rt_task_init(nam2num("MASTER"), 1, 0, 0))) {
		printf("CANNOT INIT MASTER TASK\n");
		exit(1);
	}
	printf("\nINIT MASTER TASK %p.\n", mytask);

	OneUnit = nano2count(ONE_UNIT);
	start_rt_timer(0);

	if (!(Read = rt_thread_create(ClockChrono_Read, NULL, 10000))) { 
		printf("ERROR IN CREATING ClockChrono_Read\n");
		exit(1);
 	}       

	if (!(Chrono = rt_thread_create(ClockChrono_Chrono, NULL, 10000))) { 
		printf("ERROR IN CREATING ClockChrono_Chrono\n");
		exit(1);
 	}       

	if (!(Clock = rt_thread_create(ClockChrono_Clock, NULL, 10000))) { 
		printf("ERROR IN CREATING ClockChrono_Clock\n");
		exit(1);
 	}       

	if (!(Write = rt_thread_create(ClockChrono_Write, NULL, 10000))) {
		printf("ERROR IN CREATING ClockChrono_Write\n");
		exit(1);
 	}       

	rt_task_suspend(mytask);

	while (rt_get_adr(nam2num("READ"))) {
		rt_sleep(nano2count(1000000));
	}
	while (rt_get_adr(nam2num("CLOCK"))) {
		rt_sleep(nano2count(1000000));
	}
	while (rt_get_adr(nam2num("CHRONO"))) {
		rt_sleep(nano2count(1000000));
	}
	while (rt_get_adr(nam2num("WRITE"))) {
		rt_sleep(nano2count(1000000));
	}
	cleanup_cmdclk();
	cleanup_cmdcrn();
	cleanup_dispclk();
	rt_thread_join(Chrono);
	rt_thread_join(Clock);
	rt_thread_join(Read);
	rt_thread_join(Write);
	sem_destroy(&sync_sem);
	rt_task_delete(mytask);
	printf("\nEND MASTER TASK %p.\n", mytask);
	return 0;
}
Example #17
0
void TestRTAI::runTest(double period)
{
    std::cout << "TestRTAI::runTest: Method called!" << std::endl;

    // Compute the period of the real-time servo loop.
    rtPeriod_ns = period * 1e9;
    long long const rtPeriod_us(rtPeriod_ns / 1000);
    
    // Allow non-root user to use Linux POSIX soft real-time process management and
    // memory lock functions.
    // See: https://www.rtai.org/userfiles/documentation/magma/html/api/group__lxrt.html#ga74
    rt_allow_nonroot_hrt();

    // Change scheduler of this thread to be RTAI
    std::cout << "TestRTAI::runTest: Switching to RTAI scheduler..." << std::endl;

    normalTask = rt_task_init_schmod(
        nam2num("MY_TASK"),    // name
        NON_REALTIME_PRIORITY, // priority
        0,                     // stack_size
        0,                     // max_msg_size
        SCHED_FIFO,            // scheduling policy
        0xF                    // CPUs allowed
    );

    if (!normalTask)
        throw std::runtime_error("rt_task_init_schmod failed for non-RT task");
    
    rtThreadState = RT_THREAD_UNDEF;

    // Spawn the real-time thread. The real-time thread executes call_rtMethod().
    std::cout << "TestRTAI::runTest: Spawning RT thread..." << std::endl;

    rtThreadID = rt_thread_create(
        (void*)call_rtMethod, // method to call
        this,                 // parameters
        50000                 // stack size
    ); 

    // Wait up to MAX_START_LATENCY_CYCLES for real-time thread to begin running
    std::cout << "TestRTAI::runTest: Waiting for RT thread to run..." << std::endl;
    for (int ii = 0; ii < MAX_START_LATENCY_CYCLES; ii++) 
    {
        if (rtThreadState == RT_THREAD_RUNNING || rtThreadState == RT_THREAD_ERROR) 
            break;
        usleep(rtPeriod_us);
    }
    
    if (rtThreadState != RT_THREAD_RUNNING) 
    {
        std::stringstream ss;
        ss << "TestRTAI::runTest: ERROR: Real-time thread not running, state is: ";

        switch (rtThreadState) 
        {
            case RT_THREAD_UNDEF:   ss << "RT_THREAD_UNDEF";   break;
            case RT_THREAD_INIT:    ss << "RT_THREAD_INIT";    break;
            case RT_THREAD_RUNNING: ss << "RT_THREAD_RUNNING"; break;
            case RT_THREAD_CLEANUP: ss << "RT_THREAD_CLEANUP"; break;
            case RT_THREAD_ERROR:   ss << "RT_THREAD_ERROR";   break;
            case RT_THREAD_DONE:    ss << "RT_THREAD_DONE";    break;
            default:                ss << "Invalid state: " << rtThreadState;
        }

        std::cout << ss.str() << std::endl;

        usleep(15 * rtPeriod_us);
        rt_task_delete(normalTask);
        rt_thread_join(rtThreadID);  // blocks until the real-time thread exits.
        throw std::runtime_error("TestRTAI::runTest: RT thread failed to start");
    }  
    
    std::cout << "TestRTAI::runTest: OK - real-time thread started." << std::endl;
}
Example #18
0
int main(void)
{
	RTIME tsr, tss, tsm, trpc;
	RT_TASK *mainbuddy;
	int i, k, s;
	unsigned long msg;

	printf("\n\nWait for it ...\n");
	if (!(mainbuddy = rt_thread_init(nam2num("MASTER"), 1000, 0, SCHED_FIFO, 0x1))) {
		printf("CANNOT INIT TASK %lu\n", nam2num("MASTER"));
		exit(1);
	}

	sem = rt_sem_init(nam2num("SEMAPH"), 1);
	change =  0;

	for (i = 0; i < NR_RT_TASKS; i++) {
		indx[i] = i;
		if (!(thread[i] = rt_thread_create(thread_fun, indx + i, 0))) {
			printf("ERROR IN CREATING THREAD %d\n", indx[i]);
			exit(1);
 		}
 	}

	do {
		msleep(50);
		s = 0;
		for (i = 0; i < NR_RT_TASKS; i++) {
			s += hrt[i];
		}
	} while (s != NR_RT_TASKS);
	mlockall(MCL_CURRENT | MCL_FUTURE);

	rt_make_hard_real_time();
	tsr = rt_get_cpu_time_ns();
	for (i = 0; i < LOOPS; i++) {
		for (k = 0; k < NR_RT_TASKS; k++) {
			rt_task_resume(mytask[k]);
		}
	}
	tsr = rt_get_cpu_time_ns() - tsr;

	change = 1;

	for (k = 0; k < NR_RT_TASKS; k++) {
		rt_task_resume(mytask[k]);
	}

	tss = rt_get_cpu_time_ns();
	for (i = 0; i < LOOPS; i++) {
		for (k = 0; k < NR_RT_TASKS; k++) {
			rt_sem_signal(sem);
		}
	}
	tss = rt_get_cpu_time_ns() - tss;

	change = 2;

	for (k = 0; k < NR_RT_TASKS; k++) {
		rt_sem_signal(sem);
	}

	tsm = rt_get_cpu_time_ns();
	for (i = 0; i < LOOPS; i++) {
		for (k = 0; k < NR_RT_TASKS; k++) {
			rt_send(mytask[k], 0);
		}
	}
	tsm = rt_get_cpu_time_ns() - tsm;

	change = 3;

	for (k = 0; k < NR_RT_TASKS; k++) {
		rt_send(mytask[k], 0);
	}

	trpc = rt_get_cpu_time_ns();
	for (i = 0; i < LOOPS; i++) {
		for (k = 0; k < NR_RT_TASKS; k++) {
			rt_rpc(mytask[k], 0, &msg);
		}
	}
	trpc = rt_get_cpu_time_ns() - trpc;

	rt_make_soft_real_time();

	printf("\n\nFOR %d TASKS: ", NR_RT_TASKS);
	printf("TIME %d (ms), SUSP/RES SWITCHES %d, ", (int)(tsr/1000000), 2*NR_RT_TASKS*LOOPS);
	printf("SWITCH TIME %d (ns)\n", (int)(tsr/(2*NR_RT_TASKS*LOOPS)));

	printf("\nFOR %d TASKS: ", NR_RT_TASKS);
	printf("TIME %d (ms), SEM SIG/WAIT SWITCHES %d, ", (int)(tss/1000000), 2*NR_RT_TASKS*LOOPS);
	printf("SWITCH TIME %d (ns)\n", (int)(tss/(2*NR_RT_TASKS*LOOPS)));

	printf("\nFOR %d TASKS: ", NR_RT_TASKS);
	printf("TIME %d (ms), SEND/RCV SWITCHES %d, ", (int)(tsm/1000000), 2*NR_RT_TASKS*LOOPS);
	printf("SWITCH TIME %d (ns)\n", (int)(tsm/(2*NR_RT_TASKS*LOOPS)));

	printf("\nFOR %d TASKS: ", NR_RT_TASKS);
	printf("TIME %d (ms), RPC/RCV-RET SWITCHES %d, ", (int)(tsm/1000000), 2*NR_RT_TASKS*LOOPS);
	printf("SWITCH TIME %d (ns)\n\n", (int)(trpc/(2*NR_RT_TASKS*LOOPS)));

	fflush(stdout);

	end = 1;
	for (i = 0; i < NR_RT_TASKS; i++) {
		rt_rpc(mytask[i], 0, &msg);
	}
	do {
		msleep(50);
		s = 0;
		for (i = 0; i < NR_RT_TASKS; i++) {
			s += hrt[i];
		}
	} while (s);

	rt_sem_delete(sem);
	rt_task_delete(mainbuddy);
	for (i = 0; i < NR_RT_TASKS; i++) {
		rt_thread_join(thread[i]);
	}

	return 0;
}