void nrk_create_taskset ()
{
//priority of all 4 tasks was initially (1-4):
//GridEye, GPS, Task 1, Task 3
TaskOne.task = Task1;
nrk_task_set_stk( &TaskOne, Stack1, NRK_APP_STACKSIZE);
TaskOne.prio = 2;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 0;
TaskOne.period.nano_secs = 10 * NANOS_PER_MS;//changed from 5 to 150
TaskOne.cpu_reserve.secs = 0;
TaskOne.cpu_reserve.nano_secs = 0 * NANOS_PER_MS;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs = 0;
nrk_activate_task (&TaskOne);
TASK_GPS.task = TaskGPS;
nrk_task_set_stk( &TASK_GPS, StackGPS, NRK_APP_STACKSIZE);
TASK_GPS.prio = 3;
TASK_GPS.FirstActivation = TRUE;
TASK_GPS.Type = BASIC_TASK;
TASK_GPS.SchType = PREEMPTIVE;
TASK_GPS.period.secs = 0;
TASK_GPS.period.nano_secs = 10 * NANOS_PER_MS; //change from 50 to 150
TASK_GPS.cpu_reserve.secs = 0;
TASK_GPS.cpu_reserve.nano_secs = 0;
TASK_GPS.offset.secs = 0;
TASK_GPS.offset.nano_secs = 0;
nrk_activate_task (&TASK_GPS);
TaskThree.task = Task3;
nrk_task_set_stk( &TaskThree, Stack3, NRK_APP_STACKSIZE);
TaskThree.prio = 2;
TaskThree.FirstActivation = TRUE;
TaskThree.Type = BASIC_TASK;
TaskThree.SchType = PREEMPTIVE;
TaskThree.period.secs = 0;
TaskThree.period.nano_secs = 10 * NANOS_PER_MS;//changed from 250 to 150
TaskThree.cpu_reserve.secs = 1;
TaskThree.cpu_reserve.nano_secs = 0;
TaskThree.offset.secs = 0;
TaskThree.offset.nano_secs = 0;
nrk_activate_task (&TaskThree);
TASK_GRIDEYE.task = TaskGridEYE;
nrk_task_set_stk( &TASK_GRIDEYE, StackGridEYE, NRK_APP_STACKSIZE);
TASK_GRIDEYE.prio = 1;
TASK_GRIDEYE.FirstActivation = TRUE;
TASK_GRIDEYE.Type = BASIC_TASK;
TASK_GRIDEYE.SchType = PREEMPTIVE;
TASK_GRIDEYE.period.secs = 0;
TASK_GRIDEYE.period.nano_secs = 150*NANOS_PER_MS; //*NANOS_PER_MS; //changed 50 to 150
TASK_GRIDEYE.cpu_reserve.secs = 0;
TASK_GRIDEYE.cpu_reserve.nano_secs = 0;//200*NANOS_PER_MS;
TASK_GRIDEYE.offset.secs = 0;
TASK_GRIDEYE.offset.nano_secs= 0;
nrk_activate_task (&TASK_GRIDEYE);
}
void
nrk_create_taskset()
{
TaskOne.task = print_sensor_readings;
nrk_task_set_stk( &TaskOne, Stack1, NRK_APP_STACKSIZE);
TaskOne.prio = 1;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 2;
TaskOne.period.nano_secs = 0;
TaskOne.cpu_reserve.secs = 0;
TaskOne.cpu_reserve.nano_secs = 0;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs= 0;
nrk_activate_task (&TaskOne);
nrk_task_set_entry_function( &TaskTwo, collect_Audio_Data);
nrk_task_set_stk( &TaskTwo, Stack2, NRK_APP_STACKSIZE);
TaskTwo.prio = 2;
TaskTwo.FirstActivation = TRUE;
TaskTwo.Type = BASIC_TASK;
TaskTwo.SchType = PREEMPTIVE;
TaskTwo.period.secs = 2;
TaskTwo.period.nano_secs = 0;
TaskTwo.cpu_reserve.secs = 0;
TaskTwo.cpu_reserve.nano_secs = 0;
TaskTwo.offset.secs = 0;
TaskTwo.offset.nano_secs= 0;
nrk_activate_task (&TaskTwo);
}
void
nrk_create_taskset()
{
TaskOne.task = rx_task;
nrk_task_set_stk( &TaskOne, Stack1, NRK_APP_STACKSIZE);
TaskOne.prio = 1;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 10;
TaskOne.period.nano_secs = 250*NANOS_PER_MS;
TaskOne.cpu_reserve.secs = 0;
TaskOne.cpu_reserve.nano_secs = 50*NANOS_PER_MS;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs= 0;
nrk_activate_task (&TaskOne);
TaskTwo.task = tx_task;
nrk_task_set_stk( &TaskTwo, Stack2, NRK_APP_STACKSIZE);
TaskTwo.prio = 2;
TaskTwo.FirstActivation = TRUE;
TaskTwo.Type = BASIC_TASK;
TaskTwo.SchType = PREEMPTIVE;
TaskTwo.period.secs = 0;
TaskTwo.period.nano_secs = 500*NANOS_PER_MS;
TaskTwo.cpu_reserve.secs = 0;
TaskTwo.cpu_reserve.nano_secs = 100*NANOS_PER_MS;
TaskTwo.offset.secs = 0;
TaskTwo.offset.nano_secs= 0;
nrk_activate_task (&TaskTwo);
}
void nrk_create_taskset ()
{
nrk_task_set_entry_function (&rx_task_info, rx_task);
nrk_task_set_stk (&rx_task_info, rx_task_stack, NRK_APP_STACKSIZE);
rx_task_info.prio = 1;
rx_task_info.FirstActivation = TRUE;
rx_task_info.Type = BASIC_TASK;
rx_task_info.SchType = PREEMPTIVE;
rx_task_info.period.secs = 0;
rx_task_info.period.nano_secs = 250 * NANOS_PER_MS;
rx_task_info.cpu_reserve.secs = 0;
rx_task_info.cpu_reserve.nano_secs = 100 * NANOS_PER_MS;
rx_task_info.offset.secs = 0;
rx_task_info.offset.nano_secs = 0;
nrk_activate_task (&rx_task_info);
nrk_task_set_entry_function (&tx_task_info, tx_task);
nrk_task_set_stk (&tx_task_info, tx_task_stack, NRK_APP_STACKSIZE);
tx_task_info.prio = 1;
tx_task_info.FirstActivation = TRUE;
tx_task_info.Type = BASIC_TASK;
tx_task_info.SchType = PREEMPTIVE;
tx_task_info.period.secs = 0;
tx_task_info.period.nano_secs = 250 * NANOS_PER_MS;
tx_task_info.cpu_reserve.secs = 0;
tx_task_info.cpu_reserve.nano_secs = 100 * NANOS_PER_MS;
tx_task_info.offset.secs = 0;
tx_task_info.offset.nano_secs = 0;
nrk_activate_task (&tx_task_info);
tdma_task_config ();
}
void nrk_create_taskset()
{
type_task_snd.task = task_snd;
nrk_task_set_stk( &type_task_snd, stack_task_snd, NRK_APP_STACKSIZE);
type_task_snd.prio = SND_TASK_PRIO;
type_task_snd.FirstActivation = TRUE;
type_task_snd.Type = BASIC_TASK;
type_task_snd.SchType = PREEMPTIVE;
type_task_snd.period.secs = 0;
type_task_snd.period.nano_secs = SND_TASK_PERIOD_ms*NANOS_PER_MS;
type_task_snd.cpu_reserve.secs = 0;
type_task_snd.cpu_reserve.nano_secs = 0; //SND_TASK_RESERVE_ms*NANOS_PER_MS;
type_task_snd.offset.secs = 0;
type_task_snd.offset.nano_secs= 0;
nrk_activate_task (&type_task_snd);
type_task_rcv.task = task_rcv;
nrk_task_set_stk( &type_task_rcv, stack_task_rcv, NRK_APP_STACKSIZE);
type_task_rcv.prio = RCV_TASK_PRIO;
type_task_rcv.FirstActivation = TRUE;
type_task_rcv.Type = BASIC_TASK;
type_task_rcv.SchType = PREEMPTIVE;
type_task_rcv.period.secs = 0;
type_task_rcv.period.nano_secs = RCV_TASK_PERIOD_ms*NANOS_PER_MS;
type_task_rcv.cpu_reserve.secs = 0;
type_task_rcv.cpu_reserve.nano_secs = 0; //RCV_TASK_RESERVE_ms*NANOS_PER_MS;
type_task_rcv.offset.secs = 0;
type_task_rcv.offset.nano_secs= 0;
nrk_activate_task (&type_task_rcv);
}
void nrk_create_taskset ()
{
RX_TASK.task = rx_task;
nrk_task_set_stk (&RX_TASK, rx_task_stack, NRK_APP_STACKSIZE);
RX_TASK.prio = 2;
RX_TASK.FirstActivation = TRUE;
RX_TASK.Type = BASIC_TASK;
RX_TASK.SchType = PREEMPTIVE;
RX_TASK.period.secs = 1;
RX_TASK.period.nano_secs = 0;
RX_TASK.cpu_reserve.secs = 1;
RX_TASK.cpu_reserve.nano_secs = 0;
RX_TASK.offset.secs = 0;
RX_TASK.offset.nano_secs = 0;
nrk_activate_task (&RX_TASK);
TX_TASK.task = tx_task;
nrk_task_set_stk (&TX_TASK, tx_task_stack, NRK_APP_STACKSIZE);
TX_TASK.prio = 3;
TX_TASK.FirstActivation = TRUE;
TX_TASK.Type = BASIC_TASK;
TX_TASK.SchType = PREEMPTIVE;
TX_TASK.period.secs = 1;
TX_TASK.period.nano_secs = 0;
TX_TASK.cpu_reserve.secs = 1;
TX_TASK.cpu_reserve.nano_secs = 0;
TX_TASK.offset.secs = 0;
TX_TASK.offset.nano_secs = 0;
nrk_activate_task (&TX_TASK);
}
void
nrk_create_taskset()
{
TaskOne.task = Task1;
TaskOne.Ptos = (void *) &Stack1[NRK_APP_STACKSIZE];
TaskOne.Pbos = (void *) &Stack1[0];
TaskOne.prio = 1;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 0;
TaskOne.period.nano_secs = 250*NANOS_PER_MS;
TaskOne.cpu_reserve.secs = 0;
TaskOne.cpu_reserve.nano_secs = 50*NANOS_PER_MS;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs= 0;
nrk_activate_task (&TaskOne);
TaskTwo.task = Task2;
TaskTwo.Ptos = (void *) &Stack2[NRK_APP_STACKSIZE];
TaskTwo.Pbos = (void *) &Stack2[0];
TaskTwo.prio = 2;
TaskTwo.FirstActivation = TRUE;
TaskTwo.Type = BASIC_TASK;
TaskTwo.SchType = PREEMPTIVE;
TaskTwo.period.secs = 3;
TaskTwo.period.nano_secs = 0;
TaskTwo.cpu_reserve.secs = 0;
TaskTwo.cpu_reserve.nano_secs = 100*NANOS_PER_MS;
TaskTwo.offset.secs = 0;
TaskTwo.offset.nano_secs= 0;
nrk_activate_task (&TaskTwo);
}
void nrk_create_taskset()
{
TTaskSnd.task = TaskSnd;
TTaskSnd.Ptos = (void *) &StackTaskSnd[NRK_APP_STACKSIZE-1];
TTaskSnd.Pbos = (void *) &StackTaskSnd[0];
TTaskSnd.prio = SND_TASK_PRIO;
TTaskSnd.FirstActivation = TRUE;
TTaskSnd.Type = BASIC_TASK;
TTaskSnd.SchType = PREEMPTIVE;
TTaskSnd.period.secs = 0;
TTaskSnd.period.nano_secs = SND_TASK_PERIOD_ms*NANOS_PER_MS;
TTaskSnd.cpu_reserve.secs = 0;
TTaskSnd.cpu_reserve.nano_secs = SND_TASK_RESERVE_ms*NANOS_PER_MS;
TTaskSnd.offset.secs = 0;
TTaskSnd.offset.nano_secs= 0;
nrk_activate_task (&TTaskSnd);
TTaskRcv.task = TaskRcv;
TTaskRcv.Ptos = (void *) &StackTaskRcv[NRK_APP_STACKSIZE-1];
TTaskRcv.Pbos = (void *) &StackTaskRcv[0];
TTaskRcv.prio = RCV_TASK_PRIO;
TTaskRcv.FirstActivation = TRUE;
TTaskRcv.Type = BASIC_TASK;
TTaskRcv.SchType = PREEMPTIVE;
TTaskRcv.period.secs = 0;
TTaskRcv.period.nano_secs = RCV_TASK_PERIOD_ms*NANOS_PER_MS;
TTaskRcv.cpu_reserve.secs = 0;
TTaskRcv.cpu_reserve.nano_secs = RCV_TASK_RESERVE_ms*NANOS_PER_MS;
TTaskRcv.offset.secs = 0;
TTaskRcv.offset.nano_secs= 0;
nrk_activate_task (&TTaskRcv);
}
void
nrk_create_taskset()
{
nrk_task_set_entry_function( &TaskOne, Task1);
nrk_task_set_stk( &TaskOne, Stack1, NRK_APP_STACKSIZE);
TaskOne.prio = 1;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
#ifdef NRK_EDF
TaskOne.SchType = EDF;
#else
TaskOne.SchType = PREEMPTIVE;
#endif
TaskOne.period.secs = 6;
TaskOne.period.nano_secs = 0*NANOS_PER_MS;
TaskOne.cpu_reserve.secs = 6;
TaskOne.cpu_reserve.nano_secs = 0*NANOS_PER_MS;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs= 0;
nrk_activate_task (&TaskOne);
nrk_task_set_entry_function( &TaskTwo, Task2);
nrk_task_set_stk( &TaskTwo, Stack2, NRK_APP_STACKSIZE);
TaskTwo.prio = 2;
TaskTwo.FirstActivation = TRUE;
TaskTwo.Type = BASIC_TASK;
#ifdef NRK_EDF
TaskOne.SchType = EDF;
#else
TaskOne.SchType = PREEMPTIVE;
#endif
TaskTwo.period.secs = 12;
TaskTwo.period.nano_secs = 0*NANOS_PER_MS;
TaskTwo.cpu_reserve.secs = 12;
TaskTwo.cpu_reserve.nano_secs = 0*NANOS_PER_MS;
TaskTwo.offset.secs = 0;
TaskTwo.offset.nano_secs= 0;
nrk_activate_task (&TaskTwo);
nrk_task_set_entry_function( &TaskThree, Task3);
nrk_task_set_stk( &TaskThree, Stack3, NRK_APP_STACKSIZE);
TaskThree.prio = 3;
TaskThree.FirstActivation = TRUE;
TaskThree.Type = BASIC_TASK;
#ifdef NRK_EDF
TaskOne.SchType = EDF;
#else
TaskOne.SchType = PREEMPTIVE;
#endif
TaskThree.period.secs = 9;
TaskThree.period.nano_secs = 0;
TaskThree.cpu_reserve.secs = 8;
TaskThree.cpu_reserve.nano_secs = 0*NANOS_PER_MS;
TaskThree.offset.secs = 0;
TaskThree.offset.nano_secs= 0;
nrk_activate_task (&TaskThree);
return;
}
void nrk_create_taskset ()
{
RX_TASK.task = rx_task;
nrk_task_set_stk( &RX_TASK, rx_task_stack, NRK_APP_STACKSIZE);
RX_TASK.prio = 3;
RX_TASK.FirstActivation = TRUE;
RX_TASK.Type = BASIC_TASK;
RX_TASK.SchType = PREEMPTIVE;
RX_TASK.period.secs = 0;
RX_TASK.period.nano_secs = 500 *NANOS_PER_MS;
RX_TASK.cpu_reserve.secs = 1;
RX_TASK.cpu_reserve.nano_secs = 500 * NANOS_PER_MS;
RX_TASK.offset.secs = 0;
RX_TASK.offset.nano_secs = 0;
nrk_activate_task (&RX_TASK);
TX_TASK.task = tx_task;
nrk_task_set_stk( &TX_TASK, tx_task_stack, NRK_APP_STACKSIZE);
TX_TASK.prio = 2;
TX_TASK.FirstActivation = TRUE;
TX_TASK.Type = BASIC_TASK;
TX_TASK.SchType = PREEMPTIVE;
TX_TASK.period.secs = 1;
TX_TASK.period.nano_secs = 0;
TX_TASK.cpu_reserve.secs = 1;
TX_TASK.cpu_reserve.nano_secs = 500 * NANOS_PER_MS;
TX_TASK.offset.secs = 0;
TX_TASK.offset.nano_secs = 0;
nrk_activate_task (&TX_TASK);
/*
INTER_TX_TASK.task = inter_tx_task;
nrk_task_set_stk( &INTER_TX_TASK, inter_tx_task_stack, NRK_APP_STACKSIZE);
INTER_TX_TASK.prio = 2;
INTER_TX_TASK.FirstActivation = TRUE;
INTER_TX_TASK.Type = BASIC_TASK;
INTER_TX_TASK.SchType = PREEMPTIVE;
INTER_TX_TASK.period.secs = 1;
INTER_TX_TASK.period.nano_secs = 0;
INTER_TX_TASK.cpu_reserve.secs = 1;
INTER_TX_TASK.cpu_reserve.nano_secs = 500 * NANOS_PER_MS;
INTER_TX_TASK.offset.secs = 0;
INTER_TX_TASK.offset.nano_secs = 0;
nrk_activate_task (&INTER_TX_TASK);
*/
printf ("Create done\r\n");
}
void nrk_create_taskset ()
{
RX_TASK.task = rx_task;
nrk_task_set_stk (&RX_TASK, rx_task_stack, NRK_APP_STACKSIZE);
RX_TASK.prio = 2;
RX_TASK.FirstActivation = TRUE;
RX_TASK.Type = BASIC_TASK;
RX_TASK.SchType = PREEMPTIVE;
RX_TASK.period.secs = 0;
RX_TASK.period.nano_secs = 100 * NANOS_PER_MS;
RX_TASK.cpu_reserve.secs = 0;
RX_TASK.cpu_reserve.nano_secs = 0;
RX_TASK.offset.secs = 0;
RX_TASK.offset.nano_secs = 0;
nrk_activate_task (&RX_TASK);
TX_TASK.task = tx_task;
nrk_task_set_stk (&TX_TASK, tx_task_stack, NRK_APP_STACKSIZE);
TX_TASK.prio = 2;
TX_TASK.FirstActivation = TRUE;
TX_TASK.Type = BASIC_TASK;
TX_TASK.SchType = PREEMPTIVE;
TX_TASK.period.secs = 1;
TX_TASK.period.nano_secs = 0;
TX_TASK.cpu_reserve.secs = 0;
TX_TASK.cpu_reserve.nano_secs = 500 * NANOS_PER_MS;
TX_TASK.offset.secs = 0;
TX_TASK.offset.nano_secs = 0;
nrk_activate_task (&TX_TASK);
nrk_task_set_entry_function( &SYNT_TASK_T, synt_task);
nrk_task_set_stk( &SYNT_TASK_T, synt_task_stack, NRK_APP_STACKSIZE);
SYNT_TASK_T.prio = 1;
SYNT_TASK_T.FirstActivation = TRUE;
SYNT_TASK_T.Type = BASIC_TASK;
SYNT_TASK_T.SchType = PREEMPTIVE;
SYNT_TASK_T.period.secs = 0;
SYNT_TASK_T.period.nano_secs = 500*NANOS_PER_MS;
SYNT_TASK_T.cpu_reserve.secs = 0;
SYNT_TASK_T.cpu_reserve.nano_secs = 100*NANOS_PER_MS;
SYNT_TASK_T.offset.secs = 0;
SYNT_TASK_T.offset.nano_secs= 0;
nrk_activate_task (&SYNT_TASK_T);
}
uint8_t init_rftop(uint8_t priority)
{
uint8_t num_tasks = 0;
LOG("init: prio "); LOGP("%u\r\n", priority);
discover_signal = nrk_signal_create();
if (discover_signal == NRK_ERROR)
ABORT("create sig: discover\r\n");
num_tasks++;
DISCOVER_TASK.task = discover_task;
DISCOVER_TASK.Ptos = (void *) &discover_task_stack[STACKSIZE_DISCOVER - 1];
DISCOVER_TASK.Pbos = (void *) &discover_task_stack[0];
DISCOVER_TASK.prio = priority;
DISCOVER_TASK.FirstActivation = TRUE;
DISCOVER_TASK.Type = BASIC_TASK;
DISCOVER_TASK.SchType = PREEMPTIVE;
DISCOVER_TASK.period.secs = DISCOVER_TASK_PERIOD_S;
DISCOVER_TASK.period.nano_secs = 0;
DISCOVER_TASK.cpu_reserve.secs = 0;
DISCOVER_TASK.cpu_reserve.nano_secs = 0;
DISCOVER_TASK.offset.secs = 10;
DISCOVER_TASK.offset.nano_secs = 0;
nrk_activate_task (&DISCOVER_TASK);
ASSERT(num_tasks == NUM_TASKS_RFTOP);
return num_tasks;
}
uint8_t init_periodic(uint8_t priority, periodic_func_t **funcs)
{
uint8_t num_tasks = 0;
LOG("init: prio "); LOGP("%u\r\n", priority);
func_signal = nrk_signal_create();
if (func_signal == NRK_ERROR)
ABORT("create sig: func\r\n");
functions = funcs;
num_tasks++;
PERIODIC_TASK.task = periodic_task;
PERIODIC_TASK.Ptos = (void *) &periodic_task_stack[STACKSIZE_PERIODIC - 1];
PERIODIC_TASK.Pbos = (void *) &periodic_task_stack[0];
PERIODIC_TASK.prio = priority;
PERIODIC_TASK.FirstActivation = TRUE;
PERIODIC_TASK.Type = BASIC_TASK;
PERIODIC_TASK.SchType = PREEMPTIVE;
PERIODIC_TASK.period.secs = 0;
PERIODIC_TASK.period.nano_secs = 0;
PERIODIC_TASK.cpu_reserve.secs = 0;
PERIODIC_TASK.cpu_reserve.nano_secs = 0;
PERIODIC_TASK.offset.secs = 0;
PERIODIC_TASK.offset.nano_secs = 0;
nrk_activate_task (&PERIODIC_TASK);
return num_tasks;
}
void create_serial_task()
{
SERIAL_TASK.task = serial_task;
SERIAL_TASK.Ptos = (void *) &serial_task_stack[NRK_APP_STACKSIZE - 1];
SERIAL_TASK.Pbos = (void *) &serial_task_stack[0];
SERIAL_TASK.prio = 17;
SERIAL_TASK.FirstActivation = TRUE;
SERIAL_TASK.Type = BASIC_TASK;
SERIAL_TASK.SchType = PREEMPTIVE;
SERIAL_TASK.cpu_reserve.secs = 0;
SERIAL_TASK.cpu_reserve.nano_secs = 200 * NANOS_PER_MS;
SERIAL_TASK.period.secs = 0;
SERIAL_TASK.period.nano_secs = 250 * NANOS_PER_MS;
SERIAL_TASK.offset.secs = 0;
SERIAL_TASK.offset.nano_secs= 0;
nrk_activate_task (&SERIAL_TASK);
if(DEBUG_SR == 0)
{
nrk_kprintf(PSTR("Serial task activated\r\n"));
}
}
void
nrk_create_taskset()
{
nrk_task_set_entry_function( &TaskOne, Task_Accelorometer);
nrk_task_set_stk( &TaskOne, Stack1, NRK_APP_STACKSIZE);
TaskOne.prio = 1;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 0;
TaskOne.period.nano_secs = 250*NANOS_PER_MS;
TaskOne.cpu_reserve.secs = 0;
TaskOne.cpu_reserve.nano_secs = 250*NANOS_PER_MS;
TaskOne.offset.secs = 1;
TaskOne.offset.nano_secs= 0;
nrk_activate_task (&TaskOne);
nrk_task_set_entry_function( &TaskTwo, Task_Gyro);
nrk_task_set_stk( &TaskTwo, Stack2, NRK_APP_STACKSIZE);
TaskTwo.prio = 2;
TaskTwo.FirstActivation = TRUE;
TaskTwo.Type = BASIC_TASK;
TaskTwo.SchType = PREEMPTIVE;
TaskTwo.period.secs = 0;
TaskTwo.period.nano_secs = 250*NANOS_PER_MS;
TaskTwo.cpu_reserve.secs = 0;
TaskTwo.cpu_reserve.nano_secs = 250*NANOS_PER_MS;
TaskTwo.offset.secs = 1;
TaskTwo.offset.nano_secs= 0;
nrk_activate_task (&TaskTwo);
nrk_task_set_entry_function( &TaskThree, Task_Magneto);
nrk_task_set_stk( &TaskThree, Stack3, NRK_APP_STACKSIZE);
TaskThree.prio = 3;
TaskThree.FirstActivation = TRUE;
TaskThree.Type = BASIC_TASK;
TaskThree.SchType = PREEMPTIVE;
TaskThree.period.secs = 0;
TaskThree.period.nano_secs = 250*NANOS_PER_MS;
TaskThree.cpu_reserve.secs = 0;
TaskThree.cpu_reserve.nano_secs = 0*NANOS_PER_MS;
TaskThree.offset.secs = 1;
TaskThree.offset.nano_secs= 0;
nrk_activate_task (&TaskThree);
}
void nrk_create_taskset ()
{
TX_TASK.task = tx_task;
nrk_task_set_stk (&TX_TASK, tx_task_stack, NRK_APP_STACKSIZE);
TX_TASK.prio = 2;
TX_TASK.FirstActivation = TRUE;
TX_TASK.Type = BASIC_TASK;
TX_TASK.SchType = PREEMPTIVE;
TX_TASK.period.secs = 10;
TX_TASK.period.nano_secs = 0;
TX_TASK.cpu_reserve.secs = 1;
TX_TASK.cpu_reserve.nano_secs = 500 * NANOS_PER_MS;
TX_TASK.offset.secs = 0;
TX_TASK.offset.nano_secs = 0;
nrk_activate_task (&TX_TASK);
RX_TASK.task = rx_task;
nrk_task_set_stk (&RX_TASK, rx_task_stack, NRK_APP_STACKSIZE);
RX_TASK.prio = 3;
RX_TASK.FirstActivation = TRUE;
RX_TASK.Type = BASIC_TASK;
RX_TASK.SchType = PREEMPTIVE;
RX_TASK.period.secs = 10;
RX_TASK.period.nano_secs = 0;
RX_TASK.cpu_reserve.secs = 1;
RX_TASK.cpu_reserve.nano_secs = 500 * NANOS_PER_MS;
RX_TASK.offset.secs = 0;
RX_TASK.offset.nano_secs = 0;
nrk_activate_task (&RX_TASK);
CYCLING_TASK.task = cycling_task;
nrk_task_set_stk(&CYCLING_TASK, cycling_task_stack, NRK_APP_STACKSIZE);
CYCLING_TASK.prio = 1;
CYCLING_TASK.FirstActivation = TRUE;
CYCLING_TASK.Type = BASIC_TASK;
CYCLING_TASK.SchType = PREEMPTIVE;
CYCLING_TASK.period.secs = 0;
CYCLING_TASK.period.nano_secs = 100 * NANOS_PER_MS;
CYCLING_TASK.cpu_reserve.secs = 1;
CYCLING_TASK.cpu_reserve.nano_secs = 50 * NANOS_PER_MS;
CYCLING_TASK.offset.secs = 0;
CYCLING_TASK.offset.nano_secs = 0;
nrk_activate_task(&CYCLING_TASK);
}
void create_network_layer_tasks()
{
NL_RX_TASK.task = nl_rx_task;
NL_RX_TASK.Ptos = (void *) &nl_rx_task_stack[NRK_APP_STACKSIZE - 1];
NL_RX_TASK.Pbos = (void *) &nl_rx_task_stack[0];
NL_RX_TASK.prio = 19;
NL_RX_TASK.FirstActivation = TRUE;
NL_RX_TASK.Type = BASIC_TASK;
NL_RX_TASK.SchType = PREEMPTIVE;
NL_RX_TASK.cpu_reserve.secs = 0;
NL_RX_TASK.cpu_reserve.nano_secs = 700 * NANOS_PER_MS;
NL_RX_TASK.period.secs = 1;
NL_RX_TASK.period.nano_secs = 0;
NL_RX_TASK.offset.secs = 0;
NL_RX_TASK.offset.nano_secs= 0;
nrk_activate_task (&NL_RX_TASK);
/*****************************************************************************************/
NL_TX_TASK.task = nl_tx_task;
NL_TX_TASK.Ptos = (void *) &nl_tx_task_stack[NRK_APP_STACKSIZE - 1];
NL_TX_TASK.Pbos = (void *) &nl_tx_task_stack[0];
NL_TX_TASK.prio = 18;
NL_TX_TASK.FirstActivation = TRUE;
NL_TX_TASK.Type = BASIC_TASK;
NL_TX_TASK.SchType = PREEMPTIVE;
NL_TX_TASK.cpu_reserve.secs = 0;
NL_TX_TASK.cpu_reserve.nano_secs = 500 * NANOS_PER_MS;
NL_TX_TASK.period.secs = 1;
NL_TX_TASK.period.nano_secs = 0;
NL_TX_TASK.offset.secs = 0;
NL_TX_TASK.offset.nano_secs= 0;
nrk_activate_task (&NL_TX_TASK);
if(DEBUG_NL == 2)
nrk_kprintf(PSTR("create_network_layer_tasks(): Network layer task creation done\r\n"));
}
void nrk_create_taskset ()
{
TaskOne.task = Task1;
nrk_task_set_stk( &TaskOne, Stack1, NRK_APP_STACKSIZE);
TaskOne.prio = 1;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 1;
TaskOne.period.nano_secs = 500 * NANOS_PER_MS;
TaskOne.cpu_reserve.secs = 0;
TaskOne.cpu_reserve.nano_secs = 500 * NANOS_PER_MS;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs = 0;
//nrk_activate_task (&TaskOne);
TaskTwo.task = Task2;
nrk_task_set_stk( &TaskTwo, Stack2, NRK_APP_STACKSIZE);
TaskTwo.prio = 2;
TaskTwo.FirstActivation = TRUE;
TaskTwo.Type = BASIC_TASK;
TaskTwo.SchType = PREEMPTIVE;
TaskTwo.period.secs = 0;
TaskTwo.period.nano_secs = 250 * NANOS_PER_MS;
TaskTwo.cpu_reserve.secs = 0;
TaskTwo.cpu_reserve.nano_secs = 0;
//TaskTwo.cpu_reserve.nano_secs = 100 * NANOS_PER_MS;
TaskTwo.offset.secs = 0;
TaskTwo.offset.nano_secs = 0;
//nrk_activate_task (&TaskTwo);
TaskThree.task = Task3;
TaskThree.Ptos = (void *) &Stack3[NRK_APP_STACKSIZE - 1];
TaskThree.Pbos = (void *) &Stack3[0];
TaskThree.prio = 10;
TaskThree.FirstActivation = TRUE;
TaskThree.Type = BASIC_TASK;
TaskThree.SchType = PREEMPTIVE;
TaskThree.period.secs = 0;
TaskThree.period.nano_secs = 5 * NANOS_PER_MS;
TaskThree.cpu_reserve.secs = 0;
TaskThree.cpu_reserve.nano_secs = 0 * NANOS_PER_MS;
TaskThree.offset.secs = 0;
TaskThree.offset.nano_secs = 0;
nrk_activate_task (&TaskThree);
}
void
nrk_create_taskset()
{
nrk_task_set_entry_function( &TaskOne, Task1);
nrk_task_set_stk( &TaskOne, Stack1, NRK_APP_STACKSIZE);
TaskOne.prio = 1;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 5;
TaskOne.period.nano_secs = 250*NANOS_PER_MS;
TaskOne.cpu_reserve.secs = 1;
TaskOne.cpu_reserve.nano_secs = 50*NANOS_PER_MS;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs= 0;
nrk_activate_task (&TaskOne);
}
void nrk_create_taskset ()
{
MOBILE_TASK.task = tx_task;
nrk_task_set_stk (&MOBILE_TASK, mobile_task_stack, NRK_APP_STACKSIZE);
MOBILE_TASK.prio = 2;
MOBILE_TASK.FirstActivation = TRUE;
MOBILE_TASK.Type = BASIC_TASK;
MOBILE_TASK.SchType = PREEMPTIVE;
MOBILE_TASK.period.secs = 0;
MOBILE_TASK.period.nano_secs = 200 * NANOS_PER_MS;
MOBILE_TASK.cpu_reserve.secs = 0;
MOBILE_TASK.cpu_reserve.nano_secs = 200 * NANOS_PER_MS;
MOBILE_TASK.offset.secs = 0;
MOBILE_TASK.offset.nano_secs = 0;
nrk_activate_task (&MOBILE_TASK);
}
void nrk_create_taskset ()
{
WHACKY_TASK.task = whacky_task;
nrk_task_set_stk( &WHACKY_TASK, whacky_task_stack, NRK_APP_STACKSIZE);
WHACKY_TASK.prio = 2;
WHACKY_TASK.FirstActivation = TRUE;
WHACKY_TASK.Type = BASIC_TASK;
WHACKY_TASK.SchType = PREEMPTIVE;
WHACKY_TASK.period.secs = 2;
WHACKY_TASK.period.nano_secs = 0;
WHACKY_TASK.cpu_reserve.secs = 2;
WHACKY_TASK.cpu_reserve.nano_secs = 0;
WHACKY_TASK.offset.secs = 0;
WHACKY_TASK.offset.nano_secs = 0;
nrk_activate_task (&WHACKY_TASK);
printf ("Create done\r\n");
}
void
nrk_create_taskset()
{
TaskOne.task = Task1;
nrk_task_set_stk( &TaskOne, Stack1, NRK_APP_STACKSIZE);
TaskOne.prio = 1;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 0;
TaskOne.period.nano_secs = 5*NANOS_PER_MS;
// Disable reserve
TaskOne.cpu_reserve.secs = 0;
TaskOne.cpu_reserve.nano_secs = 0;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs= 0;
nrk_activate_task (&TaskOne);
}
/*PRE-EXISTING STUFF DO NOT TOUCH*/
void nrk_create_taskset()
{
TaskOne.task = Task1;
TaskOne.Ptos = (void *) &Stack1[NRK_APP_STACKSIZE-1];
TaskOne.Pbos = (void *) &Stack1[0];
TaskOne.prio = 2;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 1;
TaskOne.period.nano_secs = 0;
TaskOne.cpu_reserve.secs = 0;
TaskOne.cpu_reserve.nano_secs = 0;
TaskOne.cpu_reserve.nano_secs = 100*NANOS_PER_MS;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs= 0;
nrk_activate_task (&TaskOne);
nrk_kprintf( PSTR("Create Done\r\n") );
}
void bmac_task_config ()
{
nrk_task_set_entry_function( &bmac_task, bmac_nw_task);
nrk_task_set_stk( &bmac_task, bmac_task_stack, BMAC_STACKSIZE);
bmac_task.prio = BMAC_TASK_PRIORITY;
bmac_task.FirstActivation = TRUE;
bmac_task.Type = BASIC_TASK;
bmac_task.SchType = PREEMPTIVE;
bmac_task.period.secs = 0;
bmac_task.period.nano_secs = BMAC_MIN_CHECK_RATE_MS * NANOS_PER_MS;
bmac_task.cpu_reserve.secs = 5; // bmac reserve , 0 to disable
bmac_task.cpu_reserve.nano_secs = 0;
bmac_task.offset.secs = 0;
bmac_task.offset.nano_secs = 0;
#ifdef DEBUG
printf( "bmac activate\r\n" );
#endif
nrk_activate_task (&bmac_task);
}
void nrk_create_taskset ()
{
GATEWAY_TASK.task = gateway_task;
GATEWAY_TASK.Ptos = (void *) &gateway_task_stack[NRK_APP_STACKSIZE - 1];
GATEWAY_TASK.Pbos = (void *) &gateway_task_stack[0];
GATEWAY_TASK.prio = 2;
GATEWAY_TASK.FirstActivation = TRUE;
GATEWAY_TASK.Type = BASIC_TASK;
GATEWAY_TASK.SchType = PREEMPTIVE;
GATEWAY_TASK.period.secs = 0;
GATEWAY_TASK.period.nano_secs = 0;
GATEWAY_TASK.cpu_reserve.secs = 0;
GATEWAY_TASK.cpu_reserve.nano_secs =0 ;
GATEWAY_TASK.offset.secs = 0;
GATEWAY_TASK.offset.nano_secs = 0;
nrk_activate_task (&GATEWAY_TASK);
printf ("Create done\r\n");
}
void nrk_create_taskset()
{
TASK.task = task;
TASK.Ptos = (void *) &task_stack[NRK_APP_STACKSIZE - 1];
TASK.Pbos = (void *) &task_stack[0];
TASK.prio = 3;
TASK.FirstActivation = TRUE;
TASK.Type = BASIC_TASK;
TASK.SchType = PREEMPTIVE;
TASK.cpu_reserve.secs = 0;
TASK.cpu_reserve.nano_secs = 800 * NANOS_PER_MS;
TASK.period.secs = 1;
TASK.period.nano_secs = 0 * NANOS_PER_MS;
TASK.offset.secs = 0;
TASK.offset.nano_secs= 0;
nrk_activate_task (&TASK);
if(DEBUG_APP == 2)
nrk_kprintf(PSTR("Created the two application layer tasks\r\n"));
}
void
nrk_create_taskset()
{
myTask.task = Task1;
//nrk_task_set_stk( &myTask, tx_task_stack, NRK_APP_STACKSIZE);
myTask.Ptos = (void *) &my_task_stack[NRK_APP_STACKSIZE-1];
myTask.Pbos = (void *) &my_task_stack[0];
myTask.prio = 2;
myTask.FirstActivation = TRUE;
myTask.Type = BASIC_TASK;
myTask.SchType = PREEMPTIVE;
myTask.period.secs = 1;
myTask.period.nano_secs = 0;
myTask.cpu_reserve.secs = 0;
myTask.cpu_reserve.nano_secs = 0;
myTask.offset.secs = 2;
myTask.offset.nano_secs = 0;
nrk_activate_task (&myTask);
//nrk_kprintf ( PSTR("Create done\r\n") );
}
void create_serial_task() // CHECKED
{
SERIAL_TASK.task = serial_task;
SERIAL_TASK.Ptos = (void *) &serial_task_stack[NRK_APP_STACKSIZE - 1];
SERIAL_TASK.Pbos = (void *) &serial_task_stack[0];
SERIAL_TASK.prio = 19;
SERIAL_TASK.FirstActivation = TRUE;
SERIAL_TASK.Type = BASIC_TASK;
SERIAL_TASK.SchType = PREEMPTIVE;
SERIAL_TASK.cpu_reserve.secs = 0;
SERIAL_TASK.cpu_reserve.nano_secs = 200 * NANOS_PER_MS;
SERIAL_TASK.period.secs = 0;
SERIAL_TASK.period.nano_secs = 250 * NANOS_PER_MS;
SERIAL_TASK.offset.secs = 0;
SERIAL_TASK.offset.nano_secs= 0;
nrk_activate_task (&SERIAL_TASK);
nrk_kprintf(PSTR("SR: create_serial_task(): Serial Task started\r\n"));
return;
}
void nrk_create_taskset_2() {
nrk_task_set_entry_function(&TaskOne, Task1);
nrk_task_set_stk(&TaskOne, Stack1, NRK_APP_STACKSIZE);
TaskOne.prio = 1;
TaskOne.FirstActivation = TRUE;
TaskOne.Type = BASIC_TASK;
TaskOne.SchType = PREEMPTIVE;
TaskOne.period.secs = 2;
TaskOne.period.nano_secs = 0;
TaskOne.cpu_reserve.secs = 2;
TaskOne.cpu_reserve.nano_secs = 0;
TaskOne.offset.secs = 0;
TaskOne.offset.nano_secs = 0;
printf("Activating Task 1\r\n");
nrk_activate_task(&TaskOne);
nrk_task_set_entry_function(&TaskTwo, Task2);
nrk_task_set_stk(&TaskTwo, Stack2, NRK_APP_STACKSIZE);
TaskTwo.prio = 2;
TaskTwo.FirstActivation = TRUE;
TaskTwo.Type = BASIC_TASK;
TaskTwo.SchType = PREEMPTIVE;
TaskTwo.period.secs = 1;
TaskTwo.period.nano_secs = 0;
TaskTwo.cpu_reserve.secs = 1;
TaskTwo.cpu_reserve.nano_secs = 0;
TaskTwo.offset.secs = 0;
TaskTwo.offset.nano_secs = 0;
printf("Activating Task 2\r\n");
nrk_activate_task(&TaskTwo);
nrk_task_set_entry_function( &TaskThree, Task3);
nrk_task_set_stk( &TaskThree, Stack3, NRK_APP_STACKSIZE);
TaskThree.prio = 3;
TaskThree.FirstActivation = TRUE;
TaskThree.Type = BASIC_TASK;
TaskThree.SchType = PREEMPTIVE;
TaskThree.period.secs = 0;
TaskThree.period.nano_secs = 250 * NANOS_PER_MS;
TaskThree.cpu_reserve.secs = 0;
TaskThree.cpu_reserve.nano_secs = 250 * NANOS_PER_MS;
TaskThree.offset.secs = 0;
TaskThree.offset.nano_secs= 0;
printf("Activating Task 3\r\n");
nrk_activate_task (&TaskThree);
nrk_task_set_entry_function( &TaskFour, Task4);
nrk_task_set_stk( &TaskFour, Stack4, NRK_APP_STACKSIZE);
TaskFour.prio = 4;
TaskFour.FirstActivation = TRUE;
TaskFour.Type = BASIC_TASK;
TaskFour.SchType = PREEMPTIVE;
TaskFour.period.secs = 0;
TaskFour.period.nano_secs = 500 * NANOS_PER_MS;
TaskFour.cpu_reserve.secs = 0;
TaskFour.cpu_reserve.nano_secs = 500 * NANOS_PER_MS;
TaskFour.offset.secs = 0;
TaskFour.offset.nano_secs= 0;
printf("Activating Task 4\r\n");
nrk_activate_task (&TaskFour);
}
//Create all the tasks
void nrk_create_taskset ()
{
RX_TASK.task = rx_task;
nrk_task_set_stk( &RX_TASK, rx_task_stack, NRK_APP_STACKSIZE);
RX_TASK.prio = 10;
RX_TASK.FirstActivation = TRUE;
RX_TASK.Type = BASIC_TASK;
RX_TASK.SchType = PREEMPTIVE;
RX_TASK.period.secs = 1;
RX_TASK.period.nano_secs =0;
RX_TASK.cpu_reserve.secs = 0;
RX_TASK.cpu_reserve.nano_secs = 200 * NANOS_PER_MS;
RX_TASK.offset.secs = 0;
RX_TASK.offset.nano_secs = 0;
TX_TASK.task = tx_task;
nrk_task_set_stk( &TX_TASK, tx_task_stack, NRK_APP_STACKSIZE);
TX_TASK.prio = 10;
TX_TASK.FirstActivation = TRUE;
TX_TASK.Type = BASIC_TASK;
TX_TASK.SchType = PREEMPTIVE;
TX_TASK.period.secs = 1;
TX_TASK.period.nano_secs = 0;
TX_TASK.cpu_reserve.secs = 0;
TX_TASK.cpu_reserve.nano_secs = 200 * NANOS_PER_MS;
TX_TASK.offset.secs = 0;
TX_TASK.offset.nano_secs = 0;
RE_TX_TASK.task = re_tx_task;
nrk_task_set_stk( &RE_TX_TASK, re_tx_task_stack, NRK_APP_STACKSIZE);
RE_TX_TASK.prio = 1;
RE_TX_TASK.FirstActivation = TRUE;
RE_TX_TASK.Type = BASIC_TASK;
RE_TX_TASK.SchType = PREEMPTIVE;
RE_TX_TASK.period.secs = 2;
RE_TX_TASK.period.nano_secs = 0;
RE_TX_TASK.cpu_reserve.secs = 0;
RE_TX_TASK.cpu_reserve.nano_secs = 100 * NANOS_PER_MS;
RE_TX_TASK.offset.secs = 0;
RE_TX_TASK.offset.nano_secs = 0;
ACK_TX_TASK.task = ack_tx_task;
nrk_task_set_stk( &ACK_TX_TASK, ack_tx_task_stack, NRK_APP_STACKSIZE);
ACK_TX_TASK.prio = 1;
ACK_TX_TASK.FirstActivation = TRUE;
ACK_TX_TASK.Type = BASIC_TASK;
ACK_TX_TASK.SchType = PREEMPTIVE;
ACK_TX_TASK.period.secs = 1;
ACK_TX_TASK.period.nano_secs = 0;
ACK_TX_TASK.cpu_reserve.secs = 0;
ACK_TX_TASK.cpu_reserve.nano_secs = 100 * NANOS_PER_MS;
ACK_TX_TASK.offset.secs = 0;
ACK_TX_TASK.offset.nano_secs = 0;
nrk_activate_task (&RX_TASK);
nrk_activate_task (&TX_TASK);
nrk_activate_task (&RE_TX_TASK);
nrk_activate_task (&ACK_TX_TASK);
printf ("Create done\r\n");
}
