eibdrv_sim.c

欧洲安装总线系统的USB串口接口驱动c程序源代码.软件代码由西门子公司提供

   fl_ext_formobjects_add_text(&obj,FL_NO_BOX,35,230,160,20,"Number of processes:",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
   fl_ext_formobjects_add_counter(&fdui->ProcessCounter,FL_SIMPLE_COUNTER,200,230,170,20,"",
         FL_ALIGN_LEFT,1,100,1,10,0,
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
      fl_set_counter_value(fdui->ProcessCounter, 1);
      sim->act_parameter->proc_count=1;
      fl_set_object_callback(fdui->ProcessCounter,ProcessCounter_cb,0);

   fl_ext_formobjects_add_labelframe(FL_ENGRAVED_FRAME,20,290,180,115,"Write Mode",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
   fl_bgn_group();
   fl_ext_formobjects_add_checkbtn(&fdui->NonblockingWModeCheckbtn,FL_RADIO_BUTTON,
         30,300,130,20,"Nonblocking Standard",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
      fl_set_object_callback(fdui->NonblockingWModeCheckbtn,WModeCheckbtn_cb,EIBDRV_SIM_NONBLOCKSTDWMODE);
   fl_ext_formobjects_add_checkbtn(&fdui->BlockingWModeCheckbtn,FL_RADIO_BUTTON,
         30,325,130,20,"Blocking Standard",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
      fl_set_object_callback(fdui->BlockingWModeCheckbtn,WModeCheckbtn_cb,EIBDRV_SIM_BLOCKSTDWMODE);
   fl_ext_formobjects_add_checkbtn(&fdui->NonblockingAckWModeCheckbtn,FL_RADIO_BUTTON,
         30,350,130,20,"Nonblocking Acknowledged",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
      fl_set_object_callback(fdui->NonblockingAckWModeCheckbtn,WModeCheckbtn_cb,EIBDRV_SIM_NONBLOCKACKWMODE);
   fl_ext_formobjects_add_checkbtn(&fdui->BlockingAckWModeCheckbtn,FL_RADIO_BUTTON,
         30,375,130,20,"Blocking Acknowledged",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
      fl_set_object_callback(fdui->BlockingAckWModeCheckbtn,WModeCheckbtn_cb,EIBDRV_SIM_BLOCKACKWMODE);
      fl_set_button(fdui->NonblockingAckWModeCheckbtn,1);
      sim->act_parameter->wmode=EIBDRV_SIM_NONBLOCKACKWMODE;
   fl_end_group();

   fl_ext_formobjects_add_labelframe(FL_ENGRAVED_FRAME,220,290,170,115,"Write Interval",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
   fl_bgn_group();
   fl_ext_formobjects_add_checkbtn(&fdui->WIntervalCheckbtn,FL_RADIO_BUTTON,
         230,300,130,20,"Without Penalty Reduction",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
      fl_set_object_callback(fdui->WIntervalCheckbtn,WIntervalCheckbtn_cb,EIBDRV_SIM_INTERVAL);
      fl_set_button(fdui->WIntervalCheckbtn,1);      
      sim->act_parameter->winterval=EIBDRV_SIM_INTERVAL;
   fl_ext_formobjects_add_checkbtn(&fdui->WIntervalRedCheckbtn,FL_RADIO_BUTTON,
         230,325,130,20,"With Penalty Reduction",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
      fl_set_object_callback(fdui->WIntervalRedCheckbtn,WIntervalCheckbtn_cb,EIBDRV_SIM_REDINTERVAL);
   fl_end_group();

   fl_ext_formobjects_add_btn(&fdui->StartBtn,FL_NORMAL_BUTTON,
         410,345,90,25,"Start",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
      fl_set_object_callback(fdui->StartBtn,StartBtn_cb,0);
   fl_ext_formobjects_add_btn(&fdui->ExitBtn,FL_NORMAL_BUTTON,
         410,380,90,25,"Exit",
         FL_RESIZE_NONE,FL_NorthWest,FL_NorthWest);
      fl_set_object_callback(fdui->ExitBtn,ExitBtn_cb,0);

   fl_end_form();
   fdui->VisForm->fdui = fdui;
   fdui->VisForm->u_vdata=sim;
   return fdui;
}


int create_Log(Eib_bcu2_sim *sim)
{
   /*  This function write both driver statistics and simulation results
       to a logfile. It returs -1, if an error occured or 0 otherwise.
    */ 

   int i,j;
   time_t log_time;
   char line[96];
   char singleline[218];
   int avg_w1time;
          
   if ((sim->log_fd=fopen(EIBDRV_SIM_LOGFILE,"w"))==NULL)
      return -1;

   time(&log_time);
   for (i=0;i<95;i++) line[i]='='; line[95]='\0';
   for (i=0;i<218;i++) singleline[i]='-'; singleline[218]='\0';

   i=0;
   while(i<=17)
   {  if (baudrates[i][0]==sim->ftstation_settings->symb_baudrate)
         break;
      i++;
   }

   fprintf(sim->log_fd,"%s\nLOG for: %s\nFile:    %s\nDate:    %s%s\n",
         line,"eibdrv_sim","eibdrv_sim.log",ctime(&log_time),line);
   fprintf(sim->log_fd,"\n\nCONFIGURATION:\n\nDevice:                        %s\n",sim->device);
   fprintf(sim->log_fd,"Mode:                          %s\n",
         (sim->ftstation_settings->mode==FT_STANDARDMODE ? "Standard Mode" : "Server Mode"));
   fprintf(sim->log_fd,"Baudrate:                      %i\n",baudrates[i][1]);
   fprintf(sim->log_fd,"Port:                          %s\n",sim->ftstation_settings->port);

   fprintf(sim->log_fd,"Process buffer size - Write:   %li\n",sim->ftstation_settings->wpbuf_size);
   fprintf(sim->log_fd,"                    - Read:    %li\n",sim->ftstation_settings->rpbuf_size);
   fprintf(sim->log_fd,"Message buffer size - Write:   %li\n",sim->ftstation_settings->outbuf_size);
   fprintf(sim->log_fd,"                    - Read:    %li\n%s",
         sim->ftstation_settings->rpbuf_msgbuf_size,line);
   fprintf(sim->log_fd,"\n\nSIMULATION PARAMETER:\n\n");
   fprintf(sim->log_fd,"Run time (min):                %i\n",sim->sim_parameter->run_time);
   fprintf(sim->log_fd,"Write interval (ms):           %i\n",sim->sim_parameter->write_interval);
   fprintf(sim->log_fd,"Minimal message length (byte): %i\n",sim->sim_parameter->min_len);
   fprintf(sim->log_fd,"Maximal message length (byte): %i\n",sim->sim_parameter->max_len);
   fprintf(sim->log_fd,"Number of processes:           %i\n",sim->sim_parameter->proc_count);
   fprintf(sim->log_fd,"Write mode:                    %s\n",get_wmode_text(sim->sim_parameter->wmode));
   fprintf(sim->log_fd,"Write interval:                %s\n",get_winterval_text(sim->sim_parameter->winterval));
   fprintf(sim->log_fd,"%s\n\n",line);

   fprintf(sim->log_fd,"%s\nWrite        Result  Rest          Message Length (Byte)\n",singleline);
   fprintf(sim->log_fd,"Process No.          Penalty Time  ");
   for (i=0;i<EIB_BUF_ELEMENT_SIZE;i++) fprintf(sim->log_fd,"%7i ",i+1);
   fprintf(sim->log_fd,"\n%s",singleline);
   for (j=0;j<sim->sim_parameter->proc_count;j++)
   {  fprintf(sim->log_fd,"\n   %4i      success   %9li   ",j+1,(sim->shm_results+j)->tp);
      for (i=0;i<EIB_BUF_ELEMENT_SIZE;i++)
         fprintf(sim->log_fd,"%7li ",(sim->shm_results+j)->rw[i]);
      fprintf(sim->log_fd,"\n             failed                ");
      for (i=0;i<EIB_BUF_ELEMENT_SIZE;i++)
         fprintf(sim->log_fd,"%7li ",(sim->shm_results+j)->w_failed[i]);
      fprintf(sim->log_fd,"\n");
   }        
   fprintf(sim->log_fd,"%s\n\n",singleline);

   fprintf(sim->log_fd,"%s\nRead                               Message Length (Byte)\n",singleline);
   fprintf(sim->log_fd,"Process No.                        ");
   for (i=0;i<EIB_BUF_ELEMENT_SIZE;i++) fprintf(sim->log_fd,"%7i ",i+1);
   fprintf(sim->log_fd,"\n%s",singleline);
   for (j=0;j<sim->sim_parameter->proc_count;j++)
   {  fprintf(sim->log_fd,"\n   %4i                            ",j+1);
      for (i=0;i<EIB_BUF_ELEMENT_SIZE;i++)
         fprintf(sim->log_fd,"%7li ",(sim->shm_results+sim->sim_parameter->proc_count+j)->rw[i]);
   }        
   fprintf(sim->log_fd,"\n%s\n",singleline);
   
   fprintf(sim->log_fd,"\n\nWrite Messages (1/2/3 attemps/failed):  %9li %9li %9li %9li\n",
         sim->stat->write[1],sim->stat->write[2],sim->stat->write[3],sim->stat->write[0]);
   fprintf(sim->log_fd,"Read Messages  (0/1/2 retransmissions): %9li %9li %9li\n",
         sim->stat->read[0],sim->stat->read[1],sim->stat->read[2]);
   if (sim->stat->write[1]>0)   
      avg_w1time=((sim->stat->total_w1time.tv_sec+sim->stat->total_w1time.tv_usec/1000000.0)
                 *1000)/sim->stat->write[1];
   else
      avg_w1time=0;
   fprintf(sim->log_fd,"\nAverage total time for write with success in first attempt (ms): %9i\n%s\n",
         avg_w1time,line);      
      
   fclose(sim->log_fd);
   
   return 0;
}

    
void write_sigalrm_handler()
{  
   /*  SIGALRM is raised after the expiry of the run time by
       a time initialized in all write/read processes.
    */
    
   sim->f_stop_readwrite=1;
}   


void write_sigterm_handler()
{  
   /*  SIGTERM is raised after one of the write or read
       processes exits with a status != 0 or the 
       Stop or Exit button is pressed.
    */
    
   shmdt(sim->shm_results);
   if (rw_sim.eib_fd>0)
      close(rw_sim.eib_fd);
   exit(97);
}   


void sim_write(Eib_bcu2_sim_shm *shm_segment)
{  int flags;
   unsigned long t1,t2,tu,tp,tp1;
   clock_t start_time,end_time;
   struct tms tms_start,tms_end;
   ssize_t nwritten;
   int msg_len;
   double ms_per_clock;
   int i;
   struct sigaction write_sigalrm;
   struct sigaction write_sigterm;


   char *msg="ZBCDEFGHIJKLMNOPQRSTUVW";  // dummy message written to the driver
//   char *msg=(char *)malloc(23*sizeof(char)); // for PEI_IDENTIFY-service
//   msg[0]=0xA7; 

   // must be before P()
   sim->f_stop_readwrite=0;
   rw_sim.eib_fd=0;
   
   P(sim->sem_start_rw);     // wait for start of all write and read processes
                             // unlocked by split process after creation of 
                             // all write and read processes

   rw_sim.shm_segment=shm_segment;

   rw_sim.local_results.result=0;
   rw_sim.local_results.tp=0;
   for (i=0;i<EIB_BUF_ELEMENT_SIZE;i++) 
   {  rw_sim.local_results.rw[i]=0;
      rw_sim.local_results.w_failed[i]=0;
   }
   write_sigalrm.sa_handler=write_sigalrm_handler;
   sigfillset(&write_sigalrm.sa_mask);
   write_sigalrm.sa_flags=0;
   if (sigaction(SIGALRM,&write_sigalrm,NULL)==-1)
   {  shmdt(sim->shm_results);
      exit(10);
   }
   write_sigterm.sa_handler=write_sigterm_handler;
   sigfillset(&write_sigterm.sa_mask);
   write_sigterm.sa_flags=0;
   if (sigaction(SIGTERM,&write_sigterm,NULL)==-1)
   {  shmdt(sim->shm_results);
      exit(11);
   }
   
   switch(sim->sim_parameter->wmode)
   {  case EIBDRV_SIM_NONBLOCKSTDWMODE: flags=O_RDWR|O_NONBLOCK; break;
      case EIBDRV_SIM_BLOCKSTDWMODE:    flags=O_RDWR; break;
      case EIBDRV_SIM_NONBLOCKACKWMODE: flags=O_RDWR|O_NONBLOCK; break;
      case EIBDRV_SIM_BLOCKACKWMODE:    flags=O_RDWR; break;
   }
   
   if ((rw_sim.eib_fd=open(sim->device,flags,0))<0)
   {  shmdt(sim->shm_results);
      exit(12);
   }
   
   if ((sim->sim_parameter->wmode==EIBDRV_SIM_BLOCKACKWMODE)&&
       (sim->ftstation_settings->mode==FT_SERVERMODE))
   {  if (ioctl(rw_sim.eib_fd,FT_SET_WRITE_MODE,FT_WRITE_ACKNOWLEDGED)<0)
      {  shmdt(sim->shm_results);
         close(rw_sim.eib_fd);
         exit(13);
      }
   }

   /*  if processes pass that point within one second, same random sequences
       are createc because of same time argument; use getpid() to avoid this.
    */  
    
   srand(time(NULL)-getpid());             

   alarm(sim->sim_parameter->run_time*60);
   ms_per_clock=1000/sysconf(_SC_CLK_TCK);
   tp=0;tp1=0;

   while(!sim->f_stop_readwrite)
   {  t1=rand() % sim->sim_parameter->write_interval;
      if (sim->sim_parameter->winterval==EIBDRV_SIM_REDINTERVAL)
      {  if (tp>t1) {  tp-=t1; tp1=t1; t1=0;  }
         else       {  tp1=tp; t1-=tp; tp=0;  }
      }
      if ((sim->sim_parameter->max_len - sim->sim_parameter->min_len)>0)
         msg_len=(rand() % (sim->sim_parameter->max_len - sim->sim_parameter->min_len + 1))+ 
            sim->sim_parameter->min_len;
      else
         msg_len=sim->sim_parameter->min_len;
      delay(t1*1000);
      start_time=times(&tms_start);
      if ((nwritten=write(rw_sim.eib_fd,msg,msg_len))==msg_len)
         rw_sim.local_results.rw[msg_len-1]++;
      else
         rw_sim.local_results.w_failed[msg_len-1]++;
      end_time=times(&tms_end);
      if ((tu=t1+tp1+(time_t)((end_time-start_time)*ms_per_clock))<sim->sim_parameter->write_interval)
      {  t2=sim->sim_parameter->write_interval-tu;
         if (sim->sim_parameter->winterval==EIBDRV_SIM_REDINTERVAL)
         {  if (tp>t2) {  tp-=t2; t2=0;  }
            else       {  t2-=tp; tp=0;  }
         }
      } 
      else
      {  t2=0;
         if (sim->sim_parameter->winterval==EIBDRV_SIM_REDINTERVAL)
            tp+=tu-sim->sim_parameter->write_interval;
            
      }
      delay(t2*1000);
      rw_sim.local_results.tp=tp;
   }
   alarm(0);  
   
   /* copy local results into shared memory segment */
   P(sim->sem_shm_results);
   *rw_sim.shm_segment=rw_sim.local_results;
   V(sim->sem_shm_results);

   shmdt(sim->shm_results);
   close(rw_sim.eib_fd);
   exit(0);
}


void read_sigio_handler()
{  
   /*  SIGIO is raised, when a message is available at the eibdrv driver. If
       the driveris operated in Standard Mode and several read processes are
       created, they compete for messages and my return with result 0.
    */
    
   ssize_t nread;
   unsigned char msg[EIB_BUF_ELEMENT_SIZE];
   
   if ((nread=read(rw_sim.eib_fd,&msg[0],EIB_BUF_ELEMENT_SIZE))>0)
      rw_sim.local_results.rw[nread-1]++;
}


void read_sigalrm_handler()
{  
   /*  SIGALRM is raised after the expiry of the run time by
       a time initialized in all write/read processes.
    */
    
   sim->f_stop_readwrite=1;
}


void read_sigterm_handler()
{
   /*  SIGTERM is raised after one of the write or read
       processes exits with a status != 0 or the