void netInit()
{
POSTASK_t t;
int i;
uipGiant = posSemaCreate(0);
uipMutex = posMutexCreate();
pollTicks = INFINITE;
P_ASSERT("netInit", uipGiant != NULL && uipMutex != NULL);
POS_SETEVENTNAME(uipGiant, "uip:giant");
POS_SETEVENTNAME(uipMutex, "uip:mutex");
// uosFS setup
netFS.base.mountPoint = "/socket";
netFS.base.cf = &netFSConf;
uosMount(&netFS.base);
// Initialize contiki-style timers (used by uip code)
etimer_init();
dataToSend = 0;
for(i = 0; i < UIP_CONNS; i++)
uip_conns[i].appstate.file = NULL;
#if UIP_UDP
for(i = 0; i < UIP_UDP_CONNS; i++)
uip_udp_conns[i].appstate.file = NULL;
#endif /* UIP_UDP */
netInterfaceInit();
uip_init();
#if NETSTACK_CONF_WITH_IPV6 == 0
uip_arp_init();
#endif
t = posTaskCreate(netMainThread, NULL, NETCFG_TASK_PRIORITY, NETCFG_STACK_SIZE);
P_ASSERT("netInit2", t != NULL);
POS_SETTASKNAME(t, "uip:main");
}
UosFile* netSockAlloc(NetSockState initialState)
{
int slot;
UosFile* file = uosFileAlloc();
if (file == NULL)
return NULL;
slot = UOS_BITTAB_ALLOC(netSocketTable);
if (slot == -1) {
uosFileFree(file);
nosPrintf("netSockAlloc: table full\n");
return NULL;
}
NetSock* sock = UOS_BITTAB_ELEM(netSocketTable, slot);
sock->state = initialState;
sock->mutex = posMutexCreate();
sock->sockChange = posFlagCreate();
sock->uipChange = posFlagCreate();
sock->timeout = INFINITE;
sock->buf = NULL;
sock->len = 0;
sock->max = 0;
P_ASSERT("netSockAlloc", sock->mutex != NULL && sock->sockChange != NULL && sock->uipChange != NULL);
POS_SETEVENTNAME(sock->mutex, "sock:mutex");
POS_SETEVENTNAME(sock->sockChange, "sock:api");
POS_SETEVENTNAME(sock->uipChange, "sock:uip");
file->fs = &netFS.base;
file->cf = &netSockConf;
file->fsPriv = sock;
return file;
}
/* This is the first function that is called in the multitasking context.
* (See file ex_init4.c for how to setup pico]OS).
*/
void firsttask(void *arg)
{
POSTASK_t t;
/* Note: You may uncomment the source below by setting the #if to
* zero and then observe the output of this program.
* This is a nice example of how synchronization works.
*/
#if 1
/* create a mutex */
mutex = posMutexCreate();
if (mutex == NULL)
{
nosPrint("Failed to create a mutex!\n");
return;
}
#endif
/* start a second task */
t = nosTaskCreate(task2, /* pointer to new task-function */
NULL, /* optional argument for the task-function */
2, /* priority level of the new task */
0, /* stack size (0 = default size) */
"task2"); /* optional name of the second task */
if (t == NULL)
{
nosPrint("Failed to start second task!\n");
}
/* continue execution in function task1 */
task1(arg);
}
NOSMUTEX_t POSCALL nosMutexCreate(UVAR_t options, const char *name)
{
POSMUTEX_t mtx;
REGELEM_t re;
re = nos_regNewSysKey(REGTYPE_MUTEX,
name == NULL ? (const char*)"m*" : name);
if (re == NULL)
return NULL;
(void) options;
mtx = posMutexCreate();
if (mtx == NULL)
{
nos_regDelSysKey(REGTYPE_MUTEX, NULL, re);
}
else
{
nos_regEnableSysKey(re, mtx);
POS_SETEVENTNAME(mtx, re->name);
}
return (NOSMUTEX_t) mtx;
}
static void task1(void *arg)
{
POSTASK_t self;
POSTIMER_t timer;
VAR_t curprio;
(void) arg;
/* get handle and priority of current task */
self = posTaskGetCurrent();
curprio = posTaskGetPriority(self);
/* try to increase current priority */
posTaskSetPriority(self, curprio + 1);
curprio = posTaskGetPriority(self);
/* start the printer task */
printertask_g = startTask(task_printer, NULL, curprio + 1);
/* print first message */
print("HELLO WORLD!\n");
/* start three tasks that do busy waiting */
startTask(task_poll, " P1 ", curprio - 1);
posTaskSleep(HZ/8);
startTask(task_poll, " P2 ", curprio - 1);
posTaskSleep(HZ/8);
startTask(task_poll, " P3 ", curprio - 1);
/* register software interrupt handler */
posSoftIntSetHandler(4, softint_handler);
/* start a task that rises software interrupts */
startTask(task_softint, (void*) 4, curprio - 1);
/* allocate a flag object */
flags_g = posFlagCreate();
if (flags_g == NULL)
print("\nCan not allocate a flag object\n");
/* start flag task */
startTask(task_flag, NULL, curprio + 2);
/* allocate a semaphore object */
timersem_g = posSemaCreate(0);
if (timersem_g == NULL)
print("\nCan not allocate a semaphore\n");
/* start timer task */
startTask(task_timer, NULL, curprio + 2);
/* allocate a timer object and set the timer up */
timer = posTimerCreate();
if (timer == NULL)
print("\nCan not allocate a timer\n");
posTimerSet(timer, timersem_g, 2*HZ, 2*HZ);
/* Start the timer. The timer triggers every 2 seconds. */
posTimerStart(timer);
/* allocate a mutex object for mutex test */
mutex_g = posMutexCreate();
if (mutex_g == NULL)
print("\nCan not allocate a mutex\n");
/* start three mutex tasks */
startTask(task_mutex, ":M1 ", curprio+1);
startTask(task_mutex, ":M2 ", curprio+1);
startTask(task_mutex, ":M3 ", curprio+1);
/* allocate semaphore object for semaphore test,
allow 2 tasks to get the semaphore */
sema_g = posSemaCreate(2);
if (sema_g == NULL)
print("\nCan not allocate a semaphore\n");
/* start three semaphore tasks */
posTaskSleep(HZ/6);
startTask(task_semas, (void*) (int) '1', curprio+2);
posTaskSleep(HZ/6);
startTask(task_semas, (void*) (int) '2', curprio+2);
posTaskSleep(HZ/6);
startTask(task_semas, (void*) (int) '3', curprio+2);
/* Our main loop. We will set the flag number 2 every 3 seconds. */
for (;;)
{
/* suspend this task for 3 seconds */
posTaskSleep(3*HZ);
/* set flag number 2 */
posFlagSet(flags_g, 2);
}
}