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"); } }
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); }
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; }
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; }
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 } }
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"); } }
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"); }
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"); }
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 ++; } } }
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); } }
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_; }
/* 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); }
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); }
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); }
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; }
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; }
static void *_thread_routine(void *arg) { while(1) { sleepms(stm->sleep_time); _update(); } return NULL; }
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} }
WebGetter::WebGetter(const string &cacheDir) : cacheDir(cacheDir) { sessions.reserve(4); quit = false; workerThread = thread([&]() { while(!quit) { sleepms(50); update(); } }); }
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]); } }
} /* 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");
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; }
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; }
} /* 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);
/*------------------------------------------------------------------------ * 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"); }
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 ++; } }
//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"); }
/* 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; } }
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; }
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; }