/* This function is executed by the first task.
*/
void task1(void *arg)
{
VAR_t f;
/* avoid compiler warning */
(void) arg;
for(;;) {
f = posFlagGet(flagset, POSFLAG_MODE_GETSINGLE);
nosPrintf("\nfirsttask: going to signal flag %i\n", f);
if(f==1){
incrementCounter(1);
posFlagSet(flagset, 2);
nosPrintf("flag value = %i\n",f);
task2(arg);
}
/* do something here and waste some time */
posTaskSleep(MS(500));
}
posSemaSignal(semaphore);
}
void task2(void *arg)
{
VAR_t f; // flag definition variable
(void) arg;
for(;;) {
// get the flag status
f = posFlagGet(flagset, POSFLAG_MODE_GETSINGLE);
if(f==2){
incrementCounter(2);
}
/* flag status update */
posFlagSet(flagset, 3);
nosPrintf("flag value = %i\n",f);
/* do something here and waste some time */
posTaskSleep(MS(500));
}
// next the task
posSemaSignal(semaphore);
}
UosFile* netSockAccept(UosFile* listenSockFile, uip_ipaddr_t* peer)
{
UosFile* file;
P_ASSERT("netSockAccept", listenSockFile->fs->cf == &netFSConf);
NetSock* listenSock = (NetSock*)listenSockFile->fsPriv;
posMutexLock(listenSock->mutex);
P_ASSERT("sockAccept", listenSock->state == NET_SOCK_LISTENING);
listenSock->state = NET_SOCK_ACCEPTING;
posFlagSet(listenSock->sockChange, 0);
while (listenSock->state == NET_SOCK_ACCEPTING) {
posMutexUnlock(listenSock->mutex);
posFlagGet(listenSock->uipChange, POSFLAG_MODE_GETMASK);
posMutexLock(listenSock->mutex);
}
P_ASSERT("sockAccept", listenSock->state == NET_SOCK_ACCEPTED);
uip_ipaddr_copy(peer, &listenSock->newConnection->ripaddr);
file = listenSock->newConnection->appstate.file;
listenSock->newConnection = NULL;
listenSock->state = NET_SOCK_LISTENING;
posMutexUnlock(listenSock->mutex);
return file;
}
static void netUdpAppcallMutex(NetSock* sock)
{
if (uip_newdata()) {
bool timeout = false;
while (sock->state != NET_SOCK_READING && !timeout) {
posMutexUnlock(sock->mutex);
timeout = posFlagWait(sock->sockChange, MS(500)) == 0;
posMutexLock(sock->mutex);
}
if (!timeout) {
if (uip_datalen() > sock->max)
sock->len = sock->max;
else
sock->len = uip_datalen();
memcpy(sock->buf, uip_appdata, sock->len);
sock->state = NET_SOCK_READ_OK;
posFlagSet(sock->uipChange, 0);
}
}
if (uip_poll()) {
if (sock->state == NET_SOCK_CLOSE) {
uip_udp_remove(uip_udp_conn);
netAppcallClose(sock, NET_SOCK_CLOSE_OK);
}
else if (sock->state == NET_SOCK_WRITING) {
memcpy(uip_appdata, sock->buf, sock->len);
uip_udp_send(sock->len);
sock->state = NET_SOCK_WRITE_OK;
posFlagSet(sock->uipChange, 0);
}
}
}
static int sockReadInternal(NetSock* sock, NetSockState state, void* data, uint16_t max, uint16_t timeout)
{
int len;
bool timedOut = false;
posMutexLock(sock->mutex);
if (sock->state == NET_SOCK_PEER_CLOSED) {
posMutexUnlock(sock->mutex);
return NET_SOCK_EOF;
}
if (sock->state == NET_SOCK_PEER_ABORTED) {
posMutexUnlock(sock->mutex);
return NET_SOCK_ABORT;
}
P_ASSERT("sockRead", sock->state == NET_SOCK_BUSY);
sock->state = state;
sock->buf = data;
sock->max = max;
sock->len = 0;
posFlagSet(sock->sockChange, 0);
while (sock->state == state && !timedOut) {
posMutexUnlock(sock->mutex);
timedOut = posFlagWait(sock->uipChange, timeout) == 0;
posMutexLock(sock->mutex);
}
if (sock->state == NET_SOCK_PEER_CLOSED)
len = NET_SOCK_EOF;
else if (sock->state == NET_SOCK_PEER_ABORTED)
len = NET_SOCK_ABORT;
else {
P_ASSERT("sockRead", (timedOut && sock->state == state) || sock->state == NET_SOCK_READ_OK);
if (timedOut && sock->state == state)
len = NET_SOCK_TIMEOUT;
else
len = sock->len;
sock->state = NET_SOCK_BUSY;
}
posMutexUnlock(sock->mutex);
return len;
}
static void task_timer(void* arg)
{
(void) arg;
for (;;)
{
/* wait for semaphore to be signalled */
posSemaGet(timersem_g);
/* Set flag. The flag number will be printed out by the flag task. */
posFlagSet(flags_g, 3);
}
}
void firsttask(void *arg) {
POSTASK_t t;
UVAR_t i;
posAtomicSet(&counter, 0);
/* creating the flag */
flagset = posFlagCreate();
if (flagset == NULL)
{
nosPrint("Failed to create a set of flags!\n");
return;
}
/* creating semaphore object with set one default value */
semaphore = posSemaCreate(1);
if (semaphore == NULL){
nosPrint("Failed to create a semaphore!\n");
return;
}
t = nosTaskCreate(task2, /* ptr to function: task2 that is executed */
NULL, /* optional argument, not used here */
1, /* priority of the first task */
0, /* stack size for the first task, 0 = default */
"task2"); /* task name */
if (t == NULL) {
nosPrint("Failed to start second task!\n");
}
t = nosTaskCreate(task3, /* ptr to function: task3 that is executed */
NULL, /* optional argument, not used here */
1, /* priority of the first task */
0, /* stack size for the first task, 0 = default */
"task3"); /* task name */
if (t == NULL) {
nosPrint("Failed to start third task!\n");
}
/* first flag status change */
posFlagSet(flagset, 1);
/* task1 handled */
task1(arg);
}
void task3(void *arg)
{
VAR_t f;
(void) arg;
for(;;) {
f = posFlagGet(flagset, POSFLAG_MODE_GETSINGLE);
if(f==3){
incrementCounter(3);
}
posFlagSet(flagset, 1);
nosPrintf("flag value = %i\n",f);
posTaskSleep(MS(500));
}
posSemaSignal(semaphore);
}
/* This function is called from two tasks.
* It increments and prints a global counter variable.
* The function uses a semaphore to protect the shared variable,
* so only one task is allowed to modify the variable at the time.
*/
void incrementCounter(int tasknbr) {
/* temporary variable */
int c;
posSemaGet(semaphore);
/* get the variable value*/
c = counter;
/* increase the temporary variable*/
c++;
/* wait the 500ms */
posTaskSleep(MS(500));
/* swap the variables */
counter = c;
/* print the status */
nosPrintf("task%i: counter = %i\n", tasknbr, counter);
/* flag state change control */
if(tasknbr == taskCount){
tasknbr = 1;
}
int tempOfIndexValue = tasknbr;
tempOfIndexValue = tempOfIndexValue+1;
/* flag updated */
posFlagSet(flagset, tempOfIndexValue);
/* next the semaphore */
posSemaSignal(semaphore);
}
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);
}
}
static void softint_handler(UVAR_t param)
{
posFlagSet(flags_g, param);
}
static void netTcpAppcallMutex(NetSock* sock)
{
if (uip_aborted()) {
netAppcallClose(sock, NET_SOCK_PEER_ABORTED);
}
if (uip_timedout()) {
netAppcallClose(sock, NET_SOCK_PEER_ABORTED);
}
if(uip_acked()) {
if (sock->state == NET_SOCK_WRITING) {
if (sock->len <= uip_mss()) {
sock->len = 0;
sock->state = NET_SOCK_WRITE_OK;
posFlagSet(sock->uipChange, 0);
}
else {
sock->buf = sock->buf + uip_mss();
sock->len -= uip_mss();
uip_send(sock->buf, sock->len);
}
}
}
if (uip_newdata()) {
bool timeout = false;
uint16_t dataLeft = uip_datalen();
char* dataPtr = uip_appdata;
while (dataLeft > 0 && !timeout) {
while (sock->state != NET_SOCK_READING &&
sock->state != NET_SOCK_READING_LINE &&
!timeout) {
posMutexUnlock(sock->mutex);
timeout = posFlagWait(sock->sockChange, MS(500)) == 0;
posMutexLock(sock->mutex);
}
if (timeout) {
// Timeout or bad state
uip_abort();
netAppcallClose(sock, NET_SOCK_PEER_ABORTED);
}
else if (sock->state == NET_SOCK_READING_LINE) {
char ch;
while (dataLeft && sock->len < sock->max) {
ch = *dataPtr;
if (ch == '\r') {
++dataPtr;
--dataLeft;
continue;
}
sock->buf[sock->len] = ch;
++dataPtr;
--dataLeft;
++sock->len;
if (ch == '\n')
break;
}
if (sock->len && (sock->len == sock->max || sock->buf[sock->len - 1] == '\n')) {
sock->state = NET_SOCK_READ_OK;
posFlagSet(sock->uipChange, 0);
}
}
else if (sock->state == NET_SOCK_READING) {
if (dataLeft > sock->max)
sock->len = sock->max;
else
sock->len = dataLeft;
memcpy(sock->buf, dataPtr, sock->len);
dataLeft -= sock->len;
dataPtr += sock->len;
sock->state = NET_SOCK_READ_OK;
posFlagSet(sock->uipChange, 0);
}
}
}
if (uip_rexmit()) {
uip_send(sock->buf, sock->len);
}
if (uip_closed()) {
netAppcallClose(sock, NET_SOCK_PEER_CLOSED);
}
if (uip_poll()) {
if (sock->state == NET_SOCK_CLOSE) {
uip_close();
netAppcallClose(sock, NET_SOCK_CLOSE_OK);
}
else if (sock->state == NET_SOCK_WRITING) {
uip_send(sock->buf, sock->len);
}
}
}
static void netAppcallClose(NetSock* sock, NetSockState nextState)
{
uip_conn->appstate.file = NULL;
sock->state = nextState;
posFlagSet(sock->uipChange, 0);
}
void netTcpAppcall()
{
UosFile *file = NULL;
if (uip_connected()) {
if (uip_conn->appstate.file == NULL) {
if (acceptHook != NULL) {
file = netSockAlloc(NET_SOCK_BUSY);
if (file == NULL) {
uip_abort();
return;
}
uip_conn->appstate.file = file;
if ((*acceptHook)(file, uip_ntohs(uip_conn->lport)) == -1) {
netSockFree(file);
uip_conn->appstate.file = NULL;
uip_abort();
return;
}
}
else {
int i;
NetSock* listenSock;
for (i = 0; i < SOCK_TABSIZE; i++, listenSock++) {
if (UOS_BITTAB_IS_FREE(netSocketTable, i))
continue;
listenSock = UOS_BITTAB_ELEM(netSocketTable, i);
if ((listenSock->state == NET_SOCK_LISTENING ||
listenSock->state == NET_SOCK_ACCEPTING ||
listenSock->state == NET_SOCK_ACCEPTED) &&
listenSock->port == uip_conn->lport)
break;
}
if (i >= SOCK_TABSIZE) {
uip_abort();
return;
}
bool timeout = false;
posMutexLock(listenSock->mutex);
while (listenSock->state != NET_SOCK_ACCEPTING && !timeout) {
posMutexUnlock(listenSock->mutex);
timeout = posFlagWait(listenSock->sockChange, MS(200)) == 0;
posMutexLock(listenSock->mutex);
}
if (timeout) {
uip_abort();
posMutexUnlock(listenSock->mutex);
return;
}
file = netSockAlloc(NET_SOCK_BUSY);
if (file == NULL) {
uip_abort();
posMutexUnlock(listenSock->mutex);
return;
}
uip_conn->appstate.file = file;
listenSock->newConnection = uip_conn;
listenSock->state = NET_SOCK_ACCEPTED;
posFlagSet(listenSock->uipChange, 0);
posMutexUnlock(listenSock->mutex);
}
}
else {
file = uip_conn->appstate.file;
P_ASSERT("netTcpAppcall", file->fs->cf == &netFSConf);
NetSock* sock = (NetSock*)file->fsPriv;
if (sock->state == NET_SOCK_CONNECT) {
posMutexLock(sock->mutex);
sock->state = NET_SOCK_CONNECT_OK;
posFlagSet(sock->uipChange, 1);
posMutexUnlock(sock->mutex);
}
}
}
file = uip_conn->appstate.file;
// Check if connection is related to socket.
// If not, the socket has already been closed and
// there is nothing more to do.
if (file == NULL)
return;
P_ASSERT("netTcpAppcall", file->fs->cf == &netFSConf);
NetSock* sock = (NetSock*)file->fsPriv;
posMutexLock(sock->mutex);
netTcpAppcallMutex(sock);
if (sock->mutex != NULL)
posMutexUnlock(sock->mutex);
}
