static void task_suspend_taskB() { task_delay(50); printf("msgB\n"); task_suspend(task_suspendA); task_delay(150); }
static void test_readwrite_start(int n) { rw_task_finished = 0; sem_initialize(&sem_rw, 1); mtx_initialize(&mtx_rw); taskrw[0] = task_create("tRA", task_reader, &n, NULL, 0x1000, 220, 10, 0); task_resume_noschedule(taskrw[0]); taskrw[1] = task_create("tRB", task_reader, &n, NULL, 0x1000, 220, 10, 0); task_resume_noschedule(taskrw[1]); taskrw[2] = task_create("tRC", task_reader, &n, NULL, 0x1000, 220, 10, 0); task_resume_noschedule(taskrw[2]); taskrw[3] = task_create("tWA", task_writer, &n, NULL, 0x1000, 220, 10, 0); task_resume_noschedule(taskrw[3]); /* wait test task to exit */ printf("Reader/Writer started\n"); while(rw_task_finished < 4) task_delay(50); printf("Reader/Writer finished\n"); }
static void task_pinherit_taskB() { task_delay(10); mtx_pend(&mtx_pinherit, -1); printf("taskB\n"); mtx_post(&mtx_pinherit); }
static void task_ipctimeout0_taskA(void *p) { printf("taskA\n"); sem_pend(&sem_timeout0, TIME_WAIT_FOREVER); task_delay(200); sem_post(&sem_timeout0); }
static void test_multitasks_start() { task_t taskA, taskB; kprintf("create taskA with pri=200\n"); taskA = task_create("ttaskA", task_multitasks_taskA, NULL, NULL, 0x1000, 200, 0, 0); task_resume_noschedule(taskA); kprintf("create taskB with pri=210\n"); taskB = task_create("ttaskB", task_multitasks_taskB, NULL, NULL, 0x1000, 210, 0, 0); task_resume_noschedule(taskB); task_set_schedule_hook(sched_hook); kprintf("cmd task Delay 500 ticks\n"); task_delay(500); kprintf("destroy taskA\n"); task_destroy(taskA); kprintf("destroy taskB\n"); task_destroy(taskB); task_set_schedule_hook(NULL); kprintf("testcase multitasks end\n"); }
static void lwip_perf_thread(void *arg) { static struct netconn *conn; static struct netbuf *buf; //static ip_addr_t *addr; static unsigned short port; char *buffer; lwip_perf_cmd_t cmd; err_t err = ERR_OK; uint16_t len, i, j; LWIP_UNUSED_ARG(arg); conn = netconn_new(NETCONN_UDP); LWIP_ASSERT("con != NULL", conn != NULL); netconn_bind(conn, NULL, 7); // echo port buffer = malloc(PERF_MAX_PAYLOAD_SIZE); assert(buffer); while (1) { err = netconn_recv(conn, &buf); if (err == ERR_OK) { //addr = netbuf_fromaddr(buf); port = netbuf_fromport(buf); uprintf(UPRINT_INFO, UPRINT_BLK_NET, "LWIP perf Rx: port=%d\n", port); len = netbuf_copy(buf, (char *)&cmd, sizeof(lwip_perf_cmd_t)); /* no need netconn_connect here, since the netbuf contains the address */ if(len != sizeof(lwip_perf_cmd_t)) { LWIP_DEBUGF(LWIP_DBG_ON, ("netbuf_copy failed\n")); } else { /* check packet size */ if(cmd.nSize>PERF_MAX_PAYLOAD_SIZE || cmd.nSize==0) cmd.nSize = PERF_MAX_PAYLOAD_SIZE; /* link buffer to netbuf */ err = netbuf_ref(buf, buffer, cmd.nSize); LWIP_DEBUGF(LWIP_DBG_ON, ("lwip perf: nPacket=%d nSize=%d nDelay=%d\n", cmd.nPacket, cmd.nSize, cmd.nDelay)); for(i=0; i<cmd.nPacket && err==ERR_OK; i++) { /* simulate buffer construction */ for(j=0; j<cmd.nSize; j++) buffer[j] = (j&0xFF); /* send packet now */ err = netconn_send(conn, buf); if(err != ERR_OK) { LWIP_DEBUGF(LWIP_DBG_ON, ("netconn_send failed: %d\n", (int)err)); } if(cmd.nDelay) task_delay(cmd.nDelay); } LWIP_DEBUGF(LWIP_DBG_ON, ("lwip perf: send %d packets\n", i)); } netbuf_delete(buf); } } free(buffer); }
/** * @brief Enables the task and schedules it for execution after a delay * * @param delay - delay before starting the task */ void task::enable_delayed(uint32_t delay){ /* * Set enabled */ _enabled = true; task_delay(delay); }
static void task_pinherit_taskC() { while(1) { printf("taskC\n"); task_delay(50); } }
static void task_destroyipc_taskB() { int ret; printf("taskB\n"); ret = sem_pend(&sem_destroyipc, -1); printf("taskB: ret = %d\n", ret); while(1) task_delay(10); }
static void lcd_command(char command) { // Clear RS to indicate 'command' LCD_RS_CLR(); lcd_write_byte(command); task_delay(LCD_VERY_SHORT_DELAY); }
static void task_setopt_taskA() { unsigned char priority = 180; task_delay(1000); printf("msgA\n"); task_setopt(taskSetoptB, TASK_OPTION_PRIORITY, &priority, sizeof(unsigned char)); }
static void test_destroyipc_start() { task_t taskA, taskB; sem_initialize(&sem_destroyipc, 1); taskA = task_create("ttaskA", task_destroyipc_taskA, NULL, NULL, 0x1000, 150, 0, 0); task_resume_noschedule(taskA); taskB = task_create("ttaskB", task_destroyipc_taskB, NULL, NULL, 0x1000, 150, 0, 0); task_resume_noschedule(taskB); task_delay(200); sem_destroy(&sem_destroyipc); task_delay(300); task_destroy(taskA); task_destroy(taskB); }
static void lcd_data(char data) { // Assert RS to indicate 'data' LCD_RS_SET(); lcd_write_byte(data); // Wait for command to be processed task_delay(LCD_VERY_SHORT_DELAY); }
void led_demo() { /// --- Initialization ------------------------------------------------------------------------ const millisecond delay { 500 }; /// --- Infinite Loop ------------------------------------------------------------------------ for (;;) { LED_Green.toggle(); LED_Orange.toggle(); LED_Red.toggle(); LED_Blue.toggle(); task_delay(delay); LED_Green.toggle(); task_delay(delay); LED_Orange.toggle(); task_delay(delay); LED_Red.toggle(); task_delay(delay); LED_Blue.toggle(); task_delay(delay); LED_Green.toggle(); LED_Orange.toggle(); LED_Red.toggle(); LED_Blue.toggle(); task_delay(delay); } }
void my_cyclic_callback (void * arg) { while (1) { task_delay(tick_from_ms (20000)); stats_get_load (&load1s, &load5s, &load10s); DPRINT ("%d:%d:%d (1s:5s:10s)\n", load1s, load5s, load10s); DPRINT ("Local bootstate: %d App.state: %d\n", local_boot_state,App.state); DPRINT ("AlStatus : 0x%x, AlError : 0x%x, Watchdog : %d \n", (ESCvar.ALstatus & 0x001f),ESCvar.ALerror,wd_cnt); } }
int comm_wait ( COMM *sio, unsigned long millisec ) { if ( (sio)->inpbuf.filled == 0 ) { if ( _curr_task && sio->_qCOMM ) { qCOMM_add(sio,TASK_RX) ; task_delay(millisec*128/125) ; if ( _curr_task->wakeupFlags != WAKEUP_COMM ) return -1 ; } else { delay(millisec) ; } } return (sio)->inpbuf.filled ; }
static void test_tasklock_start() { task_t taskA, taskB; taskA = task_create("ttaskA", task_lock_taskA, NULL, NULL, 0x1000, 210, 0, 0); task_resume_noschedule(taskA); taskB = task_create("ttaskB", task_lock_taskB, NULL, NULL, 0x1000, 90, 0, 0); task_resume_noschedule(taskB); task_delay(500); task_destroy(taskA); task_destroy(taskB); }
/*---------------------------------------------------------------------------*/ static void task2 (void) { u8 msg[32] = "Hello World" ; usys stat ; while (1) { if ((stat = msg_send (t1_id, 32, msg)) != GOOD) printf ("ERR: Task 2. msg_send(). Stat %d\n", stat) ; task_delay (50) ; } } /* End of Function task2() */
static void test_signal_start() { static task_t tsig1, tsig2; tsig1 = task_create("tsig1", task_signal_taskA, NULL, NULL, 0x1000, 220, 0, 0); task_resume_noschedule(tsig1); tsig2 = task_create("tsig2", task_signal_taskB, NULL, NULL, 0x1000, 210, 0, 0); task_resume_noschedule(tsig2); task_delay(470); sig_task(tsig1, 1); sig_task(tsig2, 7); }
static void test_ipctimeout0_start() { task_t tt; sem_initialize(&sem_timeout0, 1); tt = task_create("taskA", task_ipctimeout0_taskA, NULL, NULL, 0x1000, 220, 0, 0); assert(tt != RERROR); task_resume_noschedule(tt); tt = task_create("taskB", task_ipctimeout0_taskB, NULL, NULL, 0x1000, 220, 0, 0); assert(tt != RERROR); task_resume_noschedule(tt); task_delay(500); }
static void test_multitake_start() { task_t taskA, taskB; mtx_initialize(&mtx_multitake); taskA = task_create("ttaskA", task_multitake_taskA, NULL, NULL, 0x1000, 150, 0, 0); task_resume_noschedule(taskA); taskB = task_create("ttaskB", task_multitake_taskB, NULL, NULL, 0x1000, 150, 0, 0); task_resume_noschedule(taskB); task_delay(500); task_destroy(taskA); task_destroy(taskB); mtx_destroy(&mtx_multitake); }
static void test_suspend_start() { task_t taskB, taskC; task_suspendA = task_create("ttaskA", task_suspend_taskA, NULL, NULL, 0x1000, 150, 0, 0); task_resume_noschedule(task_suspendA); taskB = task_create("ttaskB", task_suspend_taskB, NULL, NULL, 0x1000, 100, 0, 0); task_resume_noschedule(taskB); taskC = task_create("ttaskC", task_suspend_taskC, NULL, NULL, 0x1000, 120, 0, 0); task_resume_noschedule(taskC); task_delay(500); task_destroy(task_suspendA); task_destroy(taskB); task_destroy(taskC); }
static void test_taskpriority_start() { task_t taskA, taskB, taskC; taskA = task_create("ttaskA", task_priority_taskA, NULL, NULL, 0x1000, 150, 0, 0); task_resume_noschedule(taskA); taskB = task_create("ttaskB", task_priority_taskB, NULL, NULL, 0x1000, 90, 0, 0); task_resume_noschedule(taskB); taskC = task_create("ttaskC", task_priority_taskC, NULL, NULL, 0x1000, 80, 0, 0); task_resume_noschedule(taskC); task_delay(500); task_destroy(taskA); task_destroy(taskB); task_destroy(taskC); }
static void task_signal_taskB(void *p) { struct sigaction action; sig_recved[1] = 0; action.sa_handler = sig_handler; action.sa_mask = 0; action.sa_flags = 0; sigaction(7, &action, NULL); printf("%s: waiting to receive signal...\n", current->name); while(sig_recved[1] == 0) task_delay(50); printf("%s: received signal 7\n", current->name); }
int comm_wait_key ( COMM *sio, unsigned long millisec ) { int sts ; sts = tComm_wait_key(sio) ; if ( sts ) return sts ; if ( _curr_task == NULL || sio->_qCOMM == NULL ) { /* not in TASK */ delay(millisec) ; sts = tComm_wait_key(sio) ; return sts ? sts : WAKEUP_TIMER ; } qCOMM_add(sio,TASK_RX) ; qKBD_add() ; task_delay(millisec*128/125) ; return _curr_task->wakeupFlags ; }
static void test_pinherit_start() { task_t taskA, taskB, taskC; mtx_initialize(&mtx_pinherit); taskA = task_create("ttaskA", task_pinherit_taskA, NULL, NULL, 0x1000, 250, 0, 0); task_resume_noschedule(taskA); taskB = task_create("ttaskB", task_pinherit_taskB, NULL, NULL, 0x1000, 210, 0, 0); task_resume_noschedule(taskB); taskC = task_create("ttaskC", task_pinherit_taskC, NULL, NULL, 0x1000, 220, 0, 0); task_resume_noschedule(taskC); task_delay(500); task_destroy(taskA); task_destroy(taskB); task_destroy(taskC); mtx_destroy(&mtx_pinherit); }
/***************************************************************************** * * check_network_connected * * \param None * * \return TRUE if network ready, FALSE if not * * \brief Checks to see that network is still connected. * *****************************************************************************/ unsigned char check_network_connected(void) { int network_connected = 0; if (WFisConnected() != TRUE) { LED1_IO = 0; LED2_IO = 0; network_connected = 0; if (CFGCXT.type != WF_SOFT_AP && AppConfig.networkType == WF_INFRASTRUCTURE && network_connected == 0) { if (task_delay(TICK_MINUTE, 1)) wifi_fail_count++; } } if (DHCPIsBound(0)) network_connected = 1; else network_connected = 0; if (tcp_fail_count > 5 || unknown_status > 5) { LED1_IO = 0; LED2_IO = 0; } if (wifi_fail_count > 2) { wifi_fail_count = 0; // Reset(); } if (tcp_fail_count > 50 || unknown_status > 50) { tcp_fail_count = 0; unknown_status = 0; wifi_fail_count = 0; network_connected = 0; // Reset(); } return network_connected; }
void captouch_task(void *params) { Button *button; long result; long warmup; bool pressed; for (warmup = WARMUP - 1; warmup >= 0; warmup--) { for (button = buttons; button < buttons + sizeof (buttons) / sizeof (buttons[0]); button++) { button->avg += captouch_sense(button); if (!warmup) { button->avg = button->avg / WARMUP; button->low = button->avg - (button->avg >> 2); button->high = button->avg + (button->avg >> 3); } } task_delay(DELAY / PORT_TICK_RATE_MS); }
static void taskcomm ( COMM *sio, int type, unsigned millisec ) { switch( type ) { case TASK_INIT : if ( sio->_qCOMM == NULL ) tComm_init(sio) ; return ; case TASK_FINISH : tqueue_free(sio->_qCOMM) ; return ; } if ( _curr_task == NULL || sio->_qCOMM == NULL ) { /* not in TASK */ delay(millisec) ; return ; } if ( type == TASK_WDELAY || type == TASK_RDELAY ) { qCOMM_add(sio,type==TASK_WDELAY?TASK_TX:TASK_RX) ; } task_delay((unsigned long)millisec*128/125) ; /* 1/1024 unit */ }
/** SOES main loop. Start by initializing the stack software followed by * the application loop for cyclic read the EtherCAT state and staus, update * of I/O. */ void soes (void *arg) { DPRINT ("SOES (Simple Open EtherCAT Slave)\n"); TXPDOsize = SM3_sml = sizeTXPDO (); RXPDOsize = SM2_sml = sizeRXPDO (); /* Setup post config hooks */ static esc_cfg_t config = { .pre_state_change_hook = NULL, .post_state_change_hook = post_state_change_hook }; ESC_config ((esc_cfg_t *)&config); ESC_reset(); ESC_init (spi_name); task_delay (tick_from_ms (200)); /* wait until ESC is started up */ while ((ESCvar.DLstatus & 0x0001) == 0) { ESC_read (ESCREG_DLSTATUS, (void *) &ESCvar.DLstatus, sizeof (ESCvar.DLstatus)); ESCvar.DLstatus = etohs (ESCvar.DLstatus); } /* Pre FoE to set up Application information */ bootstrap_foe_init (); /* Init FoE */ FOE_init(); /* reset ESC to init state */ ESC_ALstatus (ESCinit); ESC_ALerror (ALERR_NONE); ESC_stopmbx (); ESC_stopinput (); ESC_stopoutput (); DPRINT ("Application_loop GO\n"); /* application run loop */ while (1) { /* On init restore PDO mappings to default size */ if((ESCvar.ALstatus & 0x0f) == ESCinit) { txpdomap = DEFAULTTXPDOMAP; rxpdomap = DEFAULTRXPDOMAP; txpdoitems = DEFAULTTXPDOITEMS; rxpdoitems = DEFAULTTXPDOITEMS; } /* Read local time from ESC*/ ESC_read (ESCREG_LOCALTIME, (void *) &ESCvar.Time, sizeof (ESCvar.Time)); ESCvar.Time = etohl (ESCvar.Time); /* Check the state machine */ ESC_state (); /* If else to two separate execution paths * If we're running BOOSTRAP * - MailBox * - FoE * Else we're running normal execution * - MailBox * - CoE */ if(local_boot_state) { if (ESC_mbxprocess ()) { ESC_foeprocess (); ESC_xoeprocess (); } bootstrap_state (); } else { if (ESC_mbxprocess ()) { ESC_coeprocess (); ESC_xoeprocess (); } DIG_process (); } }; }