int user_after_syscall(void *cpu_env, bitmask_transtbl *fcntl_flags_tbl,
                       int num, abi_long arg1, abi_long arg2, abi_long arg3,
                       abi_long arg4, abi_long arg5, abi_long arg6,
                       abi_long arg7, abi_long arg8, void *p, abi_long ret){
    switch (num){
        case TARGET_NR_read:
            user_read(ret, arg1, p);
            break;
        case TARGET_NR_write:
            user_write(ret, arg1, p);
            break;
        case TARGET_NR_open:
            user_open(fcntl_flags_tbl, ret, p, arg2);
            break;
        case TARGET_NR_openat:
            user_open(fcntl_flags_tbl, ret, p, arg3);
            break;
        case TARGET_NR_creat:
            user_creat(ret, p);
            break;
        default:
            break;
    }
    return 0;
}
Exemple #2
0
int	write_state(t_server *server, t_client *client)
{
  if (queue_empty(client->queue))
    return (-1);
  user_write(server, client);
  return (0);
}
void ComprDataIO::UnpWrite( byte* out, uint count )
{
	if ( !SkipUnpCRC )
	{
		if ( write_error == unrar_ok )
			write_error = user_write( user_write_data, out, count );

        UnpHash.Update(out,count);
	}
}
void ComprDataIO::UnpWrite( byte* out, uint count )
{
	if ( !SkipUnpCRC )
	{
		if ( write_error == unrar_ok )
			write_error = user_write( user_write_data, out, count );

		if ( OldFormat )
			UnpFileCRC = OldCRC( (ushort) UnpFileCRC, out, count );
		else
			UnpFileCRC = CRC( UnpFileCRC, out, count );
	}
}
Exemple #5
0
SHELL	void	sign_up()
{
	clrvar(user.mptr);
	clrvar(user.var);
	user.number=user.member+1;
	ult(user.number)->mpost =0;
	ult(user.number)->post  =0;
	ult(user.number)->mlogin=0;
	ult(user.number)->login =0;
	setvar("mpost","0",user.var);
	setvar("post","0",user.var);
	setvar("mlogin","0",user.var);
	setvar("login","0",user.var);

	for(;;)
		{
		 setvar("pass","",user.var);
		 msgout(IC_act "今からサインアップを行います。");

		 user_chk(1);
	 	 user_rep(user.member+1);
		 user_disp();
		 msgout(IC_act "以上でよろしいでしょうか?");
		 if (ynq())
		 	break;
		 msgout(IC_act "中止しますか?");
		 if (ynq())
		 	{
		 	 user_guest("");
		 	 return;
		 	}
		}
	user_add();
	user_write();
	sys_log("| User登録");
	where_seta();
}
Exemple #6
0
int main(int argc, char **argv)
{
	char buffer[256];
	int s, addrlen = sizeof(struct sockaddr_in);
	struct sockaddr_in addr;
	struct hostent *hp;
	struct servent *sp;
	int verbose = 1;

	paclen_in = 1024;
	paclen_out = 1024;

	while ((s = getopt(argc, argv, "ci:o:q")) != -1) {
		switch (s) {
		case 'c':
			init_compress();
			compression = 1;
			break;
		case 'i':
			paclen_in = atoi(optarg);
			break;
		case 'o':
			paclen_out = atoi(optarg);
			break;
		case 'q':
			verbose = 0;
			break;
		case ':':
		case '?':
			err("ERROR: invalid option usage\n");
			return 1;
		}
	}

	if (paclen_in < 1 || paclen_out < 1) {
		err("ERROR: invalid paclen\n");
		return 1;
	}

	/*
	 * Arguments should be "tcp_call remaddr remport"
	 */
	if ((argc - optind) != 2) {
		strcpy(buffer, "ERROR: invalid number of parameters\n");
		err(buffer);
	}

	/*
	 * Open the socket into the kernel.
	 */
	if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		sprintf(buffer, "ERROR: can't open socket: %s\n", strerror(errno));
		err(buffer);
	}

	/*
	 * Resolve the hostname.
	 */
	hp = gethostbyname(argv[optind]);
	if (hp == NULL) {
		err("ERROR: Unknown host\n");
	}
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = ((struct in_addr *)(hp->h_addr))->s_addr;

	/*
	 * And the service name.
	 */
	if ((sp = getservbyname(argv[optind+1], "tcp")) != NULL)
		addr.sin_port = sp->s_port;
	else
		addr.sin_port = htons(atoi(argv[optind+1]));

	if (addr.sin_port == 0) {
		err("ERROR: Unknown service\n");
	}

	if (verbose) {
		sprintf(buffer, "*** Connecting to %s ...\n", hp->h_name);
		user_write(STDOUT_FILENO, buffer, strlen(buffer));
	}

	/*
	 * If no response in 30 seconds, go away.
	 */
	alarm(30);

	signal(SIGALRM, alarm_handler);

	/*
	 * Lets try and connect to the far end.
	 */
	if (connect(s, (struct sockaddr *)&addr, addrlen) != 0) {
		sprintf(buffer, "ERROR: can't connect: %s\n", strerror(errno));
		err(buffer);
	}

	/*
	 * We got there.
	 */
	alarm(0);

	if (verbose) {
		strcpy(buffer, "*** Connected\n");
		user_write(STDOUT_FILENO, buffer, strlen(buffer));
	}

	select_loop(s);

	if (verbose) {
		strcpy(buffer, "\n*** Disconnected\n");
		user_write(STDOUT_FILENO, buffer, strlen(buffer));
	}

	end_compress();

	return 0;
}
unsigned char application_display(bit init)
{
static bit b0_old = 0, b1_old = 0, b2_old = 0, b3_old = 0, 
   station_on_old = 0, valve_locked_old = 0;

   if (init)
      lcd_clear();

   /* display pressures */
   lcd_goto(0, 0);
   if (user_data.relais[0] && user_data.relais[1])
      printf("P1*: %9.2E mbar", user_data.vv_mbar);
   else
      printf("P1: %10.2E mbar", user_data.vv_mbar);
   
   lcd_goto(0, 1);
   if (user_data.turbo_on && (user_data.relais[2] || user_data.relais[3]))
      printf("P2*: %9.2E mbar", user_data.hv_mbar);
   else
      printf("P2: %10.2E mbar", user_data.hv_mbar);
 
   lcd_goto(0, 2);
   if (user_data.error & ERR_TURBO_COMM)
      printf("ERROR: turbo comm.  ");
   else if (user_data.error & ERR_FOREVAC)
      printf("ERROR: fore vaccuum ");
   else if (user_data.error & ERR_MAINVAC)
      printf("ERROR: main vaccuum ");
   else if (user_data.error & ERR_TURBO)
      printf("TMP ERROR: %s    ", turbo_err);
   else {
      if (user_data.man_mode) {
         printf("TMP: %4d Hz, %4.2f A", user_data.rot_speed, user_data.tmp_current);
      } else {
         if (pump_state == ST_OFF) {
            if (user_data.rot_speed > 10)
               printf("Rmp down TMP:%4d Hz", user_data.rot_speed);
            else
               printf("Pump station off    ");
         } else if (pump_state == ST_START_FORE)
            printf("Starting fore pump  ");
         else if (pump_state == ST_EVAC_FORE)
            printf("Pumping buffer tank ");
         else if (pump_state == ST_EVAC_MAIN)
            printf("Pumping recipient   ");
         else
            printf("TMP: %4d Hz, %4.2f A", user_data.rot_speed, user_data.tmp_current);
      }
   }

   if (user_data.man_mode) {

      lcd_goto(0, 3);
      printf(user_data.relais[0] ? "FP0" : "FP1");

      lcd_goto(5, 3);
      printf(user_data.relais[1] ? "VV0" : "VV1");

      lcd_goto(11, 3);
      printf(user_data.relais[2] ? "HV0" : "HV1");

      lcd_goto(16, 3);
      printf(user_data.relais[3] ? "BV0" : "BV1");

      if (b0 && !b0_old)
         user_data.relais[0] = !user_data.relais[0];
      if (b1 && !b1_old)
         user_data.relais[1] = !user_data.relais[1];
      if (b2 && !b2_old)
         user_data.relais[2] = !user_data.relais[2];
      if (b3 && !b3_old)
         user_data.relais[3] = !user_data.relais[3];
         
      user_write(4);
      user_write(5);
      user_write(6);
      user_write(7);

      /* enter menu on buttons 2 & 3 */                                   
      if (b2 && b3) {

         /* wait for buttons to be released */
         do {
           sr_read();
           } while (b2 || b3);

         return 1;
      }

   } else {

      lcd_goto(0, 3);
      printf(user_data.station_on ? "OFF" : "ON ");
   
      lcd_goto(4, 3);
      printf(user_data.valve_locked ? "UNLOCK" : " LOCK ");
   
      /* toggle main switch with button 0 */
      if (b0 && !b0_old)
         user_data.station_on = !user_data.station_on;
   
      /* toggle locking with button 1 */
      if (b1 && !b1_old)
         user_data.valve_locked = !user_data.valve_locked;
   
      /* enter menu on release of button 3 */
      if (!init)
         if (!b3 && b3_old)
            return 1;
   }

   b0_old = b0;
   b1_old = b1;
   b2_old = b2;
   b3_old = b3;

   /*---- Pump station turn on logic ----*/

   if (user_data.station_on && !station_on_old) {

      /* start station */
      
      /* vent enable off */
      tc600_write(12, 6, 0);

      set_mainvalve(0);
      set_bypassvalve(0);

      set_forepump(1);
      pump_state = ST_START_FORE;

      start_time = time();     // remember start time
   }

   /* wait 5s for forepump to start (turbo could be still rotating!) */
   if (pump_state == ST_START_FORE && time() > start_time + 5*100) {

      set_forevalve(1);

      start_time = time();     // remember start time
      pump_state = ST_EVAC_FORE;
   }

   /* check if buffer tank gets evacuated in less than 15 min */
   if (pump_state == ST_EVAC_FORE && time() > start_time + 15*60*100) {
      pump_state = ST_ERROR;
      user_data.error = ERR_FOREVAC;
      set_forevalve(0);
      set_forepump(0);
   }

   /* check if evacuation of forepump and buffer tank is ready */
   if (pump_state == ST_EVAC_FORE && user_data.vv_mbar < 1) {

      if (user_data.hv_mbar < 1) {
         
         /* recipient is already evacuated, go to running mode */
         start_time = time();     // remember start time
         pump_state = ST_EVAC_MAIN ;
      
      } else {

         if (user_data.valve_locked) {
            /* go immediately to running mode */
            user_data.turbo_on = 1;
            set_forevalve(1);
      
            start_time = time();     // remember start time
            pump_state = ST_RAMP_TURBO;

         } else {
         
            /* evacuate recipient through bypass valve */
            set_forevalve(0);
            delay_ms(2000);          // wait 2s
            set_bypassvalve(1);
      
            start_time = time();     // remember start time
            pump_state = ST_EVAC_MAIN;
         }
      }
   }

   /* check if recipient gets evacuated in less than evac_timeout minutes */
   if (pump_state == ST_EVAC_MAIN && 
       user_data.evac_timeout > 0 && 
       time() > start_time + (unsigned long)user_data.evac_timeout*60*100) {
      pump_state = ST_ERROR;
      user_data.error = ERR_MAINVAC;
      set_forevalve(0);
      set_forepump(0);
   }

   /* check if evacuation of main recipient is ready, may take very long time */
   if (pump_state == ST_EVAC_MAIN && user_data.hv_mbar < 1) {
      
      set_forevalve(1);        // now evacuate both recipient and buffer tank
   }

   /* check if vacuum on both sides of main valve is ok */
   if (pump_state == ST_EVAC_MAIN && user_data.hv_mbar < 1 && user_data.vv_mbar < 1) {

      /* turn on turbo pump */
      user_data.turbo_on = 1;

      start_time = time();     // remember start time
      pump_state = ST_RAMP_TURBO;
   }

   /* check if vacuum leak after ramping */
   if (pump_state == ST_RAMP_TURBO || pump_state == ST_RUN_FPON || pump_state == ST_RUN_FPOFF ||
       pump_state == ST_RUN_FPUP || pump_state == ST_RUN_FPDOWN) {

       if (user_data.hv_mbar > 4 && user_data.valve_locked == 0) {

          /* protect turbo pump */
          set_mainvalve(0);
          set_forevalve(0);
          user_data.turbo_on = 0;

          /* force restart of pump station */
          if (user_data.station_on) {
             station_on_old = 0;
             pump_state = ST_OFF;
             return 0;
          }
       }
   }
   

   /* check if turbo pump started successfully in unlocked mode */
   if (user_data.valve_locked == 0 && pump_state == ST_RAMP_TURBO && 
       user_data.rot_speed > user_data.final_speed*0.8 &&
       user_data.hv_mbar < 1 && user_data.vv_mbar < 1) {
    
      set_bypassvalve(0);

      /* now open main (gate) valve */
      set_mainvalve(1);

      start_time = time();     // remember start time
      pump_state = ST_RUN_FPON;
   }

   /* check if turbo pump started successfully in locked mode */
   if (user_data.valve_locked == 1 && pump_state == ST_RAMP_TURBO && 
       user_data.rot_speed > user_data.final_speed*0.8 &&
       user_data.vv_mbar < 1) {
    
      start_time = time();     // remember start time
      pump_state = ST_RUN_FPON;
   }


   /* check for fore pump off */
   if (pump_state == ST_RUN_FPON) {

      if (time() > start_time + user_data.fp_cycle*100 && 
          user_data.vv_mbar < user_data.vv_min) {
         set_forevalve(0);
         pump_state = ST_RUN_FPDOWN;
         start_time = time();
      }
   }

   /* turn fore pump off */
   if (pump_state == ST_RUN_FPDOWN) {

      if (time() > start_time + 3*100) {  // wait 3s
         set_forepump(0);                 // turn fore pump off
         pump_state = ST_RUN_FPOFF;
      }
   }

   /* check for fore pump on */
   if (pump_state == ST_RUN_FPOFF) {

      if (user_data.vv_mbar > user_data.vv_max) {
         set_forepump(1);
         pump_state = ST_RUN_FPUP;
         start_time = time();
      }
   }
   
   /* turn fore pump on */
   if (pump_state == ST_RUN_FPUP) {

      if (time() > start_time + 10*100) { // wait 10s
         set_forevalve(1); 
         pump_state = ST_RUN_FPON;
      }
   }
   
   /* set vacuum status */
   user_data.vacuum_ok = (user_data.hv_mbar <= user_data.hv_thresh);
   user_write(3);

   /*---- Pump station turn off logic ----*/

   if (!user_data.station_on && station_on_old) {

      /* close all valves */
      
      set_forevalve(0);
      set_mainvalve(0);
      set_bypassvalve(0);
      set_forepump(0);

      /* stop turbo pump */
      user_data.turbo_on = 0;

      /* vent enable on */
      tc600_write(12, 6, 111111);
   
      /* vent mode auto */
      tc600_write(30, 3, 0);

      pump_state = ST_OFF;
      user_data.error = 0;
   }
   
   /*---- Lock logic ----*/
   
   if (user_data.valve_locked && !valve_locked_old) {
      set_mainvalve(0);
      set_bypassvalve(0);
   }

   if (!user_data.valve_locked && valve_locked_old) {
      if (user_data.station_on) {
         start_time = time();       // remember start time
         pump_state = ST_EVAC_FORE; // start with buffer tank evacuation
         set_forepump(1);
         delay_ms(1000);
         set_forevalve(1);
      }
   }

   station_on_old = user_data.station_on;
   valve_locked_old = user_data.valve_locked;

   return 0;
}
void set_bypassvalve(unsigned char flag)
{
   user_data.relais[3] = flag;
   user_write(7);
}
void set_mainvalve(unsigned char flag)
{
   user_data.relais[2] = flag;
   user_write(6);
}
Exemple #10
0
void set_forevalve(unsigned char flag)
{
   user_data.relais[1] = flag;
   user_write(5);
}
Exemple #11
0
void set_forepump(unsigned char flag)
{
   user_data.relais[0] = flag;
   user_write(4);
}
Exemple #12
0
void user_init(unsigned char init)
{
   unsigned char i;
   xdata char str[64];

   SFRPAGE = ADC0_PAGE;
   AMX0CF = 0x00;               // select single ended analog inputs
   ADC0CF = 0xE0;               // 16 system clocks, gain 1
   ADC0CN = 0x80;               // enable ADC 
   REF0CN = 0x00;               // use external voltage reference

   SFRPAGE = LEGACY_PAGE;
   REF0CN = 0x02;               // select external voltage reference

   SFRPAGE = DAC0_PAGE;
   DAC0CN = 0x80;               // enable DAC0
   SFRPAGE = DAC1_PAGE;
   DAC1CN = 0x80;               // enable DAC1

   /* open drain(*) /push-pull: 
      P0.0 TX1      P1.0 TP6          P2.0 LED1         P3.0 RELAIS0
      P0.1*RX1      P1.1 BACKLIGHT    P2.1 LCD_E        P3.1 RELAIS1
      P0.2 TX2      P1.2 TP5          P2.2 LCD_RW       P3.2 RELAIS2
      P0.3*RX2      P1.3 TP7          P2.3 LCD_RS       P3.3 RELAIS3
                                                                      
      P0.4 EN1      P1.4 WATCHDOG     P2.4 LCD_DB4      P3.4 DOUT0
      P0.5 EN2      P1.5 SRSTROBE     P2.5 LCD_DB5      P3.5 DOUT1
      P0.6 LED2     P1.6*SRIN         P2.6 LCD_DB6      P3.6 DOUT2
      P0.7 BUZZER   P1.7 SRCLK        P2.7 LCD_DB7      P3.7 DOUT3
    */
   SFRPAGE = CONFIG_PAGE;
   P0MDOUT = 0xF5;
   P1MDOUT = 0xBF;
   P2MDOUT = 0xFF;
   P3MDOUT = 0xFF;

   /* initial EEPROM value */
   if (init) {

      user_data.station_on = 0;
      user_data.valve_locked = 0;
      user_data.vacuum_ok = 0;
      user_data.man_mode = 0;

      for (i=0 ; i<4 ; i++)
         user_data.relais[i] = 0;

      for (i=0 ; i<8 ; i++) {
         user_data.aofs[i] = 0;
         user_data.again[i] = 1;
      }

      user_data.evac_timeout = 60; // 1h to pump recipient
      user_data.fp_cycle = 20;     // run fore pump for min. 20 sec.
      user_data.vv_max = 4;        // start fore pump at 4 mbar     
      user_data.vv_min = 0.4;      // stop fore pump at 0.4 mbar
      user_data.hv_thresh = 1E-3;  // vacuum ok if < 10^-3 mbar
   }

   /* write digital outputs */
   for (i=0 ; i<20 ; i++)
      user_write(i);

   /* initialize UART1 for TC600 */
   uart_init(1, BD_9600);

   /* turn on turbo pump motor (not pump station) */
   tc600_write(23, 6, 111111);

   /* get parameter 315 (TMP finspd) */
   tc600_read(315, str);
   user_data.final_speed = atoi(str);

   /* display startup screen */
   lcd_goto(0, 0);
   for (i=0 ; i<7-strlen(sys_info.node_name)/2 ; i++)
      puts(" ");
   puts("** ");
   puts(sys_info.node_name);
   puts(" **");
   lcd_goto(0, 1);
   printf("  Address:   %04X", sys_info.node_addr);
   lcd_goto(0, 2);
   strcpy(str, svn_revision + 21);
   *strchr(str, ' ') = 0;
   printf("  Revision:  %s", str);

   user_data.error = 0;
}
Exemple #13
0
/**
 * @ingroup shell
 *
 * Take a system call number and run that system call.  This is only for
 * demonstration.
 * @param nargs number of arguments
 * @param args  array of arguments
 * @return non-zero value on error
 */
shellcmd xsh_user(int nargs, char **args)
{
    static mailbox mybox;
    int call_num;
    char buffer[BUF_LENGTH];

    if (nargs != 2)
    {
        printf("Insufficient arguments.\n");
        printf("Try again later.\n");
        return 1;
    }

    call_num = atoi(args[1]);

    switch (call_num)
    {
    case 0:
        user_none();
        break;
    case 1:
        user_yield();
        break;
    case 2:
        user_sleep(4000);
        break;
    case 3:
        user_kill(5);           // pick a better number
        break;
    case 4:
        user_open(LOOP, 0);
        break;
    case 5:
        user_control(LOOP, 0, 1, 2);
        break;
    case 6:
        sprintf(buffer, "Process %d\n", gettid());
        user_write(LOOP, buffer, BUF_LENGTH);
        break;
    case 7:
        user_read(LOOP, buffer, BUF_LENGTH);
        printf("%s\n", buffer);
        break;
    case 8:
        user_putc(LOOP, 'm');
        break;
    case 9:
        printf("%c\n", user_getc(LOOP));
        break;
    case 10:
        user_seek(LOOP, 5);
        break;
    case 11:
        user_close(LOOP);
        break;
    case 12:
        printf("%d\n", user_getdev("LOOP"));
        break;
    case 13:
        mybox = user_mboxalloc(50);
        printf("Mailbox %d assigned.\n", mybox);
        break;
    case 14:
        user_mboxfree(mybox);
        break;
    case 15:
        user_mboxsend(mybox, 0xa5a5a5a5);
        break;
    case 16:
        printf("0x%08x\n", user_mboxrecv(mybox));
        break;
    default:
        printf("No corresponding call.\n");
    }

    return 0;
}
Exemple #14
0
void user_init(unsigned char init)
{
   unsigned char i;

   ADC0CN = 0x00;               // disable ADC 
   DAC0CN = 0x00;               // disable DAC0
   DAC1CN = 0x00;               // disable DAC1
   REF0CN = 0x00;               // disenable internal reference

   /* push-pull:
      P0.0    TX
      P0.1
      P0.2    SW_ADC
      P0.3    DAC_NCS

      P0.4    DAC_SCK
      P0.5    DAC_DIN
      P0.6 
      P0.7    DAC_CLR
    */
   PRT0CF = 0xBD;
   P0 = 0xFF;

   /* push-pull:
      P1.0    SW_DAC
      P1.1
      P1.2    ADC_NRES
      P1.3    ADC_SCLK

      P1.4    ADC_NCS
      P1.5    
      P1.6 
      P1.7    ADC_DIN
    */
   PRT1CF = 0x9D;
   P1 = 0xFF;

   /* initial EEPROM value */
   if (init) {

      for (i = 0; i < 8; i++)
         user_data.dac[i] = 0;
   }

   /* set-up DAC & ADC */
   DAC_CLR = 1;
   ADC_NRES = 1;
   write_adc(REG_FILTER, 82);                   // SF value for 50Hz rejection
   write_adc(REG_MODE, 3);                      // continuous conversion
   write_adc(REG_CONTROL, adc_chn << 4 | 0x0F); // Chn. 1, +2.56V range

   /* write DACs and UNI_BIP */
   for (i=0 ; i<8 ; i++)
      user_write(i+8);

   user_write(16);

   /* swich unipolar/bipolar */
   user_data.uni_dac = 0;
   user_data.uni_adc = 0;
   user_data.adc_25 = 0;
   
   UNI_DAC = user_data.uni_dac;
   UNI_ADC = !user_data.uni_adc;
}