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 ();
}
};
}
