Exemplo n.º 1
0
void asmtest3() // asynchronous message test 3
{
	pid32 ar1 = create(asyncrec,1024,20,"asyncreceiver",0,NULL);
	pid32 as1 = create(asyncsend,1024,20,"asyncsender1",2,ar1,'A');
	pid32 as2 = create(asyncsend,1024,20,"asyncsender2",2,ar1,'B');	
	pid32 as3 = create(asyncsend,1024,20,"asyncsender3",2,ar1,'C');
	pid32 as4 = create(asyncsend,1024,20,"asyncsender4",2,ar1,'D');
	
	resume(ar1);
	sleepms(25);
	resume(as1);
	sleepms(25);
	resume(as2);
	sleepms(25);
	resume(as3);
	sleepms(25);
	resume(as4);
	sleepms(25);

	if(msgglob == 'D' || pidchecker == ar1){
		kprintf("Test3 passed!\n");
	}
	else{
		kprintf("Test3 failed\n");
	}
}
Exemplo n.º 2
0
void Reset_554(void)
{
   // reset 16C554. Reset pin of 16C554 is connected to PB0 of MEGA64
      PORTE.3 = 1;                                                         
   // Delay  
      sleepms(500);
   // Recover from reset
      PORTE.3 = 0;          
   // Delay
      sleepms(500);
}
Exemplo n.º 3
0
void bmstest1() // test1
{
	pid32 receiver = create(messagerec,1024,20,"receiver",1,2);
	pid32 sender1 = create(messagesent,1024,20,"sender1",3,receiver,'D',2000);
	resume(sender1);
	sleepms(1000);
	resume(receiver);
	sleepms(1000);
	a = 1;


}
Exemplo n.º 4
0
void bmstest4() // test 4
{
	pid32 receiver = create((void*)messagerec,1024,20,"receiver",1,5);
	pid32 sender1 = create((void*)messagesent,1024,20,"sender1",3,receiver,'D',2000);
	pid32 sender2 = create((void*)messagesent,1024,20,"sender2",3,receiver,'E',2000);	
	
	resume(sender1);
	sleepms(1000);
	resume(sender2);
	sleepms(1000);
	resume(receiver);
	sleepms(1000);

	d = 1;
}
Exemplo n.º 5
0
 void killDb( int port, pid_t _pid, int signal ) {
     pid_t pid;
     if ( port > 0 ) {
         if( dbs.count( port ) != 1 ) {
             cout << "No db started on port: " << port << endl;
             return;
         }
         pid = dbs[ port ].first;
     } else {
         pid = _pid;
     }
     
     assert( 0 == kill( pid, signal ) );
     
     int i = 0;
     for( ; i < 65; ++i ) {
         if ( i == 5 ) {
             char now[64];
             time_t_to_String(time(0), now);
             now[ 20 ] = 0;
             cout << now << " process on port " << port << ", with pid " << pid << " not terminated, sending sigkill" << endl;
             assert( 0 == kill( pid, SIGKILL ) );
         }        
         int temp;
         int ret = waitpid( pid, &temp, WNOHANG );
         if ( ret == pid )
             break;
         sleepms( 1000 );
     }
     if ( i == 65 ) {
         char now[64];
         time_t_to_String(time(0), now);
         now[ 20 ] = 0;
         cout << now << " failed to terminate process on port " << port << ", with pid " << pid << endl;
         assert( "Failed to terminate process" == 0 );
     }
     
     if ( port > 0 ) {
         close( dbs[ port ].second );
         dbs.erase( port );
     } else {
         close( shells[ pid ] );
         shells.erase( pid );
     }
     if ( i > 4 || signal == SIGKILL ) {
         sleepms( 4000 ); // allow operating system to reclaim resources
     }
 }
Exemplo n.º 6
0
void asmtest1() // asynchronous message test 1
{
	pid32 ar1 = create(asyncrec,1024,20,"asyncreceiver",0,NULL);
	pid32 as1 = create(asyncsend,1024,20,"asyncsender1",2,ar1,'A');
	resume(ar1);
	sleepms(25);
	resume(as1);
	sleepms(25);
	if(msgglob != 'A' || pidchecker != ar1){
		kprintf("Test1 failed\n");
		printf("Currpid is %d\n",currpid );
	}
	else{
		kprintf("Test1 passed!\n");
	}
}
Exemplo n.º 7
0
static void ICACHE_FLASH_ATTR writeByByteTest()
{
	time = system_get_time();
	errors = 0;
	address = 0;
	console_printf("-----------------------------------------------\r\n");
	console_printf("Write byte test:\r\n");
	console_printf("Start address: %d, End address: %d\r\n", MIN_ADDRESS, MAX_ADDRESS);
	console_printf("Writing data: ");
	for (address = MIN_ADDRESS; address <= MAX_ADDRESS; address++)
	{
		wdata = address % loop_size;
		if(!eeprom_writeByte(DEVICEADDRESS, address, wdata))
			console_printf("Failed write, address: %d, data: %d\r\n", address, (uint8_t)wdata);
		else
		{
			if (!(address % 500)) {
				//console_printf( "Address: %d, data: %d\r\n", address, (uint8_t)wdata);
				console_printf("..500..");
			}
		}
		sleepms(3);
	}
	finishTime = system_get_time() - time;
	console_printf("DONE!\r\n");
	console_printf("Total Time (seconds): %d\r\n", (uint32_t)(finishTime / 1000000));
	console_printf("Write operations per second: %d\r\n", (uint32_t)(MAX_ADDRESS / (finishTime / 1000000)));
	console_printf("-----------------------------------------------\r\n");
	console_printf("\r\n");
}
Exemplo n.º 8
0
static void ICACHE_FLASH_ATTR readByByteTest()
{
	time = system_get_time();
	errors = 0;
	address = 0;
	console_printf("-----------------------------------------------\r\n");
	console_printf("Read byte test:\r\n");
	console_printf("Start address: %d, End address: %d\r\n", MIN_ADDRESS, MAX_ADDRESS);
	console_printf("Reading data:");
	for (address = MIN_ADDRESS; address <= MAX_ADDRESS; address++)
	{
		rdata = eeprom_readByte(DEVICEADDRESS, address);
		wdata = address % loop_size;
		if (rdata != (uint8_t)wdata)
		{
			console_printf("Address: %d", address);
			console_printf(" Should be: %d", (uint8_t)wdata);
			console_printf(" Read val: %d\r\n", rdata);
			errors++;
		}
		if (!(address % 500)) console_printf("..500..");
		sleepms(3);
	}
	finishTime = system_get_time() - time;
	console_printf("DONE\r\n");
	console_printf("Total time (seconds): %d\r\n", (uint32_t)(finishTime / 1000000));
	console_printf("Read operations per second: %d\r\n", (uint32_t)(MAX_ADDRESS / (finishTime / 1000000)));
	console_printf("Total errors: %d\r\n", errors);
	console_printf("-----------------------------------------------\r\n");
	console_printf("\r\n");
}
Exemplo n.º 9
0
void	shellconsume(void) {
		uint32 i,j;
		
		for(i = 0; i < 2048; i++) {
			for(j = 0; j <5; j++) {
				cstring[i][j] = ' ';
			}
		}

		for(j = 0; j < 2048; j++) {
				pipread(shell_pipid_test, cstring[j], 5, j*5);
				sleepms(100);
				if (cstring[j][0] == 'A') {
					vacount ++;
				}
				if (cstring[j][0] == 'E') {
					vecount ++;
				}
				if (cstring[j][0] == 'I') {
					vicount ++;
				}
				if (cstring[j][0] == 'O') {
					vocount ++;
				}
				if (cstring[j][0] == 'U') {
					vucount ++;
				}		
			}
}
Exemplo n.º 10
0
int main()
{		
	struct point p;
	p.x = p.y = p.z = 1;
	int i = 0;
	for(; i < 1000; ++i)
	{
		g_points[i] = create_atomic_type(sizeof(p));
		SetPoint(g_points[i],p);
	}
	thread_t t1 = CREATE_THREAD_RUN(1,SetRotine,NULL);
	thread_t t2 = CREATE_THREAD_RUN(1,GetRoutine,(void*)1);	
	thread_t t3 = CREATE_THREAD_RUN(1,GetRoutine,(void*)2);	
	thread_t t4 = CREATE_THREAD_RUN(1,GetRoutine,(void*)3);	
	uint32_t tick = GetSystemMs();
	while(1)
	{
		uint32_t new_tick = GetSystemMs();
		if(new_tick - tick >= 1000)
		{
			printf("get:%d,set:%d,miss:%d\n",get_count,set_count,miss_count);
			get_count = set_count = miss_count = 0;
			tick = new_tick;
		}
		sleepms(50);
	}
}
Exemplo n.º 11
0
 mongo::BSONObj JSSleep(const mongo::BSONObj &args){
     assert( args.nFields() == 1 );
     assert( args.firstElement().isNumber() );
     int ms = int( args.firstElement().number() );
     sleepms( ms );
     return undefined_;
 }
Exemplo n.º 12
0
/*
  Readv() calls the member function Read() repeatedly, til all
  demand bytes were received. To avoid an endless loop, you
  can refer an integer, which was set unequal zero after a
  specific time. (See the timer class)
*/
    int IOBase::Readv(char* buf,size_t len,int* timeout_flag,bool nice)
    {
	   size_t toread = len;
	   int n = 0;
	   char *cp = buf;

	   while(toread > 0) {
		  if(timeout_flag && (*timeout_flag > 0)) {
			 return (len - toread);
		  }
		  if((n = Read(cp,toread)) < 0) {
			 return (len - toread);
		  }
		  if(!n && nice) {
			 sleepms(1);
		  }
		  if (n > 0)
		  {
			 toread -= n;
			 cp += n;
		  }
	   }
	   // ok, all bytes received
	   return(len - toread);
    }
Exemplo n.º 13
0
    int IOBase::Readv(char* buf,size_t len,unsigned int timeout_in_ms)
    {
	   char *cp = buf;
	   int n = 0;
	   int timeout = 0;
	   size_t toread = len;

	   Timer t(timeout_in_ms,&timeout,NULL);
	   if(timeout_in_ms != 0xFFFFFFFF) {
		  t.start();
	   }

	   while(!timeout && (toread > 0)) {
		  if((n = Read(cp,toread)) < 0) {
			 break;
		  }
		  if(!n) {
			 sleepms(1);
		  }
		  toread -= n;
		  cp += n;
	   }
	   // ok, all bytes received
	   return(len - toread);
    }
Exemplo n.º 14
0
    int IOBase::Writev(char* buf,size_t len,unsigned int timeout_in_ms)
    {
	   char *cp = buf;
	   int n = 0;
	   int timeout = 0;
	   size_t towrite = len;

	   Timer t(timeout_in_ms,&timeout,NULL);
	   if(timeout_in_ms != 0xFFFFFFFF) {
		  t.start();
	   }

	   while(!timeout && (towrite > 0)) {
		  if((n = Write(cp,towrite)) < 0) {
			 // an error occurs
			 break;
		  }
		  if(!n) {
			 sleepms(1);
		  }
		  towrite -= n;
		  cp += n;
	   }
	   return (len - towrite);
    }
Exemplo n.º 15
0
void bmstest2() // test 3
{
	pid32 receiver1 = create(messagerec,1024,20,"receiver",1,2);
	pid32 sender1 = create(messagesent,1024,20,"sender1",3,receiver1,'D',2000);
	pid32 receiver2 = create(messagerec,1024,20,"receiver",1,2);
	pid32 sender2 = create(messagesent,1024,20,"sender2",3,receiver2,'E',2000);
	resume(sender1);
	sleepms(1000);
	resume(sender2);
	sleepms(1000);
	resume(receiver1);
	sleepms(1000);
	resume(receiver2);
	sleepms(1000);

	b = 1;
}
Exemplo n.º 16
0
int main(int argc,char **argv)
{
    //msgque_flush_time = 5;
    setup_signal_handler();
    InitNetSystem();

    //共用网络层,两个线程各运行一个echo服务
    wpacket_allocator = new_obj_allocator(sizeof(struct wpacket),8192);
    rpacket_allocator = new_obj_allocator(sizeof(struct rpacket),8192);
    asynnet_t asynet = asynnet_new(2);
    msgdisp_t  disp1 = new_msgdisp(asynet,5,
                                   CB_CONNECT(asynconnect),
                                   CB_CONNECTED(asynconnected),
                                   CB_DISCNT(asyndisconnected),
                                   CB_PROCESSPACKET(asynprocesspacket),
                                   CB_CONNECTFAILED(asynconnectfailed));

    /*msgdisp_t  disp2 = new_msgdisp(asynet,
                                  asynconnect,
                                  asynconnected,
                                  asyndisconnected,
                                  asynprocesspacket,
                                  asynconnectfailed);
    */
    thread_t service1 = create_thread(THREAD_JOINABLE);
    //thread_t service2 = create_thread(THREAD_JOINABLE);

    ip = argv[1];
    port = atoi(argv[2]);

    thread_start_run(service1,service_main,(void*)disp1);
    //sleepms(1000);
    //thread_start_run(service2,service_main,(void*)disp2);

    uint32_t tick,now;
    tick = now = GetSystemMs();
    while(!stop){
        sleepms(1000);
        now = GetSystemMs();
        //if(now - tick > 1000)
        {
            uint32_t elapse = now-tick;
            recvsize = (recvsize/elapse)/1000;
            printf("client_count:%d,recvsize:%d,recvcount:%d\n",client_count,recvsize,recvcount);
            tick = now;
            packet_send_count = 0;
            recvcount = 0;
            recvsize = 0;
        }
    }

    thread_join(service1);
    //thread_join(service2);

    CleanNetSystem();
    return 0;
}
Exemplo n.º 17
0
static void *_thread_routine(void *arg)
{
	while(1)
	{
		sleepms(stm->sleep_time);
		_update();
	}
	return NULL;
}
Exemplo n.º 18
0
LOCAL void ICACHE_FLASH_ATTR read_input_pin(void *arg)
{
	uint32 gpio_status;
	ETS_GPIO_INTR_DISABLE(); // Disable gpio interrupts
	sleepms(15);
	if(!GPIO_INPUT_GET(PIN_GPIO13)) {
	button_counter++;
	console_printf("READ_INPUT_PIN executed...");
	console_printf("COUNTER:%d\n",button_counter);
	os_timer_disarm(&input_pin_timer); // Disarm input pin timer
	os_timer_setfn(&input_pin_timer, (os_timer_func_t *)handle_pin_press, NULL); // Setup input pin timer
	os_timer_arm(&input_pin_timer, button_timeout, 1); // Arm input pin timer, 0,5sec, repeat
	sleepms(button_debounce);  // debounce time
	}
	gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
	GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status); 	//clear interrupt status

	ETS_GPIO_INTR_ENABLE(); // Enable gpio interrupts}
}
Exemplo n.º 19
0
WebGetter::WebGetter(const string &cacheDir) : cacheDir(cacheDir) {
	sessions.reserve(4);
	quit = false;
	workerThread = thread([&]() {
		while(!quit) {
			sleepms(50);
			update();
		}
	});
}
Exemplo n.º 20
0
void lab2q5t1()
{
    pid32 pr[6];
    int i, times[] = {100, 500, 50, 2000, 100, 0};
    for(i = 0; i < 6; i++){
        /* Initial priority is set to 200 so that the main process can complete creating all the processes and all the processes
         * are in the ready queue.*/
        resume(pr[i] = create(cpubound, 1024, 10, "cpubound process", 2, 30, 50000));
        sleepms(times[i]);
    }
}
Exemplo n.º 21
0
}
/* thread to send keep alive for monitor port --------------------------------*/
static void *sendkeepalive(void *arg)
{
    trace(3,"sendkeepalive: start\n");
    
    while (keepalive) {
        strwrite(&moni,(unsigned char *)"\r",1);
        sleepms(INTKEEPALIVE);
    }
    trace(3,"sendkeepalive: stop\n");
Exemplo n.º 22
0
int insecure_compare_32(unsigned char *a, unsigned char *b, int n)
{
	int i;
	for (i = 0; i < n; ++i) {
		if (a[i] != b[i]) {
			return b[i] - a[i];
		}
		sleepms(1);
	}
	return 0;
}
Exemplo n.º 23
0
int main(int argc,char **argv)
{
    setup_signal_handler();
    InitNetSystem();

    asynnet_t asynet = asynnet_new(3);//3个poller,1个用于监听,1个用于处理客户端连接,1个用于处理服务器连接

    msgdisp_t  disp_to_server = new_msgdisp(asynet,3,
                                            CB_CONNECT(to_server_connect),
                                            CB_CONNECTED(to_server_connected),
                                            CB_PROCESSPACKET(to_server_process));

    msgdisp_t  disp_to_client = new_msgdisp(asynet,2,
                                            CB_CONNECT(to_client_connect),
                                            CB_ASYNPROCESSPACKET(to_client_process));

    thread_t service1 = create_thread(THREAD_JOINABLE);
    thread_t service2 = create_thread(THREAD_JOINABLE);

    to_client_ip = argv[1];
    to_client_port = atoi(argv[2]);


    to_server_ip = argv[3];
    to_server_port = atoi(argv[4]);

    thread_start_run(service1,service_toserver,(void*)disp_to_server);
    sleepms(1000);
    thread_start_run(service2,service_toclient,(void*)disp_to_client);

    while(!stop){
        sleepms(100);
    }

    thread_join(service1);
    thread_join(service2);

    CleanNetSystem();
    return 0;
}
Exemplo n.º 24
0
}
/* close monitor port --------------------------------------------------------*/
static void closemoni(void)
{
    trace(3,"closemoni:\n");
    keepalive=0;
    
    /* send disconnect message */
    strwrite(&moni,(unsigned char *)MSG_DISCONN,strlen(MSG_DISCONN));
    
    /* wait fin from clients */
    sleepms(1000);
    
Exemplo n.º 25
0
/*------------------------------------------------------------------------
 *  cmdhistoryadd  -  add a cmd to the history
 *------------------------------------------------------------------------
 */
void cmdhistoryadd(char *buf, uint32 len) {

	struct strlist *tmpcmd = cmdhistory;
	int i = 0;

	LOG("\n cmdhistoryadd: starting \n");

	char *newcmd = getmem(len+1);
	strncpy(newcmd,buf,len);
	*(newcmd + len) = '\0';

	char *prevstr = NULL;

	LOG("\n cmdhistoryadd: set tmpcmd to cmdhistory (val: %x) \n",cmdhistory);
	LOG("\n cmdhistoryadd: alloc newcmd (%x) to len: %d and copy in str: %s \n",newcmd,len+1,newcmd);

	LOG("\n cmdhistoryadd: loop \n");

	/* loop through the history list, bumping each cmd string to a previous slot */
	while(tmpcmd != NULL && newcmd != NULL) {
		LOG("\n cmdhistoryadd: for loop %d: set prevstr to tmpcmd->str (%x) (val: %x) \n",
				i, &(tmpcmd->str), tmpcmd->str);
		LOG("\n \t tmp->str: str val = %s", tmpcmd->str);
		prevstr = tmpcmd->str;
		LOG("\n cmdhistoryadd: for loop %d: set tmp->str (%x) to newcmd (val: %x) \n",
				i, &(tmpcmd->str), newcmd);
		LOG("\n \t newcmd: str val = %s", newcmd);
		tmpcmd->str = newcmd;
		LOG("\n cmdhistoryadd: for loop %d: set newcmd to prevstr (val: %x) \n",
				i, prevstr);
		LOG("\n \t prevstr: str val = %s", prevstr);
		newcmd = prevstr;
		LOG("\n cmdhistoryadd: for loop %d: set tmpcmd to tmpcmd->prev (%x) (val: %x) \n",
				i, &(tmpcmd->prev), tmpcmd->prev);
		tmpcmd = tmpcmd->prev;
		LOG("\n cmdhistoryadd: loop iteration %d complete",i++);
	}

	/* if one cmd string fell off the back of the list, then free it */
	if(newcmd) {
		LOG("\n cmdhistoryadd: about to free last used cmd \n");
		LOG("\n cmdhistoryadd: str size is %d bytes", strlen(newcmd)+1);
		LOG("\n cmdhistoryadd: str ptr address is %x", newcmd);
		LOG("\n cmdhistoryadd: str val is %s", newcmd);
		if(envtab[EV_DEBUG].val == EV_VALUE_YES) sleepms(500);
		freemem(newcmd,strlen(newcmd)+1);
	}
	LOG("\n cmdhistoryadd: finished \n");
}
Exemplo n.º 26
0
void	shellproduce(void) {
		uint32 i,j;
		uint32 seed = 7;
		for(i = 0; i < 2048; i++) {
			for(j = 0; j <5; j++) {
				pstring[i][j] = words[seed][j];
			}
		seed = (seed*81799)%2048;
		}
		for(i = 0;i < 2048;i++) {
			pipwrite(shell_pipid_test, pstring[i], 5, i*5);
			sleepms(100);
			pcount ++;
		}
}
Exemplo n.º 27
0
//Main routine. Initialize stdout, the I/O and the webserver and we're done.
void user_init(void) {
// HTTPD
	stdoutInit();
	ioInit();
	httpdInit(builtInUrls, 80);
//MQTT
	uart_init(115200, 115200);
	CFG_Load();
	sleepms(1000);

	MQTT_InitConnection(&mqttClient, sysCfg.mqtt_host, sysCfg.mqtt_port, SEC_NONSSL);
	//MQTT_InitConnection(&mqttClient, "192.168.11.122", 1880, 0);
	MQTT_InitClient(&mqttClient, sysCfg.device_id, sysCfg.mqtt_user, sysCfg.mqtt_pass, sysCfg.mqtt_keepalive, 1);
	//MQTT_InitClient(&mqttClient, "client_id", "user", "pass", 120, 1);

//	MQTT_InitLWT(&mqttClient, "/lwt", "offline", 0, 0);
	MQTT_OnConnected(&mqttClient, mqttConnectedCb);
	MQTT_OnDisconnected(&mqttClient, mqttDisconnectedCb);
	MQTT_OnPublished(&mqttClient, mqttPublishedCb);
	MQTT_OnData(&mqttClient, mqttDataCb);

	INFO("device_ID:%s\r\n",sysCfg.device_id);
	INFO("MQTTHOST:%s\r\n",sysCfg.mqtt_host);
//DS18B20 timers
	os_timer_disarm(&ds18b20_timer);
	os_timer_setfn(&ds18b20_timer, (os_timer_func_t *)ds18b20_cb, (void *)0);
	os_timer_arm(&ds18b20_timer, DELAY, 1);

//NTP timers
		ntp_get_time();
		os_timer_disarm(&NTP_timer);
		os_timer_setfn(&NTP_timer, (os_timer_func_t *)ntp_get_time, (void *)0);
		os_timer_arm(&NTP_timer, NTPDELAY, 1);

// initialize GPIO2
	PIN_FUNC_SELECT(PIN_GPIO2_MUX, PIN_GPIO2_FUNC);
	GPIO_OUTPUT_SET(PIN_GPIO2, 0);
	INFO("GPIO2 set to OFF\r\n");

	WIFI_Connect(sysCfg.sta_ssid, sysCfg.sta_pwd, wifiConnectCb);

	os_printf("\nReady\n");
}
Exemplo n.º 28
0
/* send receiver command -------------------------------------------------------
* send receiver commands to stream
* args   : stream_t *stream I   stream
*          char   *cmd      I   receiver command strings
* return : none
*-----------------------------------------------------------------------------*/
extern void strsendcmd(stream_t *str, const char *cmd)
{
    unsigned char buff[1024];
    const char *p=cmd,*q;
    char msg[1024],cmdend[]="\r\n";
    int n,m,ms;
    
    tracet(3,"strsendcmd: cmd=%s\n",cmd);
    
    for (;;) {
        for (q=p;;q++) if (*q=='\r'||*q=='\n'||*q=='\0') break;
        n=(int)(q-p); strncpy(msg,p,n); msg[n]='\0';
        
        if (!*msg||*msg=='#') { /* null or comment */
            ;
        }
        else if (*msg=='!') { /* binary escape */
            
            if (!strncmp(msg+1,"WAIT",4)) { /* wait */
                if (sscanf(msg+5,"%d",&ms)<1) ms=100;
                if (ms>3000) ms=3000; /* max 3 s */
                sleepms(ms);
            }
            else if (!strncmp(msg+1,"UBX",3)) { /* ublox */
                if ((m=gen_ubx(msg+4,buff))>0) strwrite(str,buff,m);
            }
            else if (!strncmp(msg+1,"STQ",3)) { /* skytraq */
                if ((m=gen_stq(msg+4,buff))>0) strwrite(str,buff,m);
            }
            else if (!strncmp(msg+1,"NVS",3)) { /* nvs */
                if ((m=gen_nvs(msg+4,buff))>0) strwrite(str,buff,m);
            }
            else if (!strncmp(msg+1,"LEXR",3)) { /* lex receiver */
                if ((m=gen_lexr(msg+5,buff))>0) strwrite(str,buff,m);
            }
        }
        else {
            strwrite(str,(unsigned char *)msg,n);
            strwrite(str,(unsigned char *)cmdend,2);
        }
        if (*q=='\0') break; else p=q+1;
    }
}
Exemplo n.º 29
0
void *Routine3(void *arg)
{
	msgque_open_write(mq1);
	for(;;){
		int j = 0;
		for(; j < 5;++j)
		{
			int i = 0;
			for(; i < 10000000; ++i)
			{
				msgque_put(mq1,&node_list3[j][i]);
			}
			msgque_flush();
			sleepms(200);
		}
	}
	printf("Routine3 end\n");
	return NULL;
}
Exemplo n.º 30
0
process	main(void)
{
	/* Start the network */

	//ethinit(&devtab[ETHER0]);

	uint32	*macaddr = 0x44e10630;
	kprintf("mac addr: %x %x\n", *macaddr, *(macaddr+1));
	int32 i;
/*	for(i = 0; i < 6; i++) {
		NetData.ethucast[i] = i;
		NetData.ethbcast[i] = 0xff;
	}*/

	//kprintf("reading packet from ETHER0\n");
	//struct netpacket pkt;
	//read(ETHER0, &pkt, 1518);

	//resume(create(counterproc, 8192, 19, "counter proc", 0, NULL));
	//sleep(10);
	//kprintf("Counter value: %d\n", gcounter);

	//DELAY(5000000);

	// Commented by Bryce Himebaugh on 9/02/1015. Generating run time error messages. 
	// netstart();

	kprintf("\n...creating a shell\n");
	recvclr();
	resume(create(shell, 8192, 50, "shell", 1, CONSOLE));

	/* Wait for shell to exit and recreate it */

	while (TRUE) {
		receive();
		sleepms(200);
		kprintf("\n\nMain process recreating shell\n\n");
		resume(create(shell, 4096, 20, "shell", 1, CONSOLE));
	}
	return OK;
}