/* 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 int sockWrite(UosFile* file, const char* data, int len)
{
P_ASSERT("sockWrite", file->fs->cf == &netFSConf);
NetSock* sock = (NetSock*)file->fsPriv;
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("sockWrite", sock->state == NET_SOCK_BUSY);
sock->state = NET_SOCK_WRITING;
sock->buf = (void*)data;
sock->len = len;
dataToSend = 1;
posSemaSignal(uipGiant);
while (sock->state == NET_SOCK_WRITING) {
posMutexUnlock(sock->mutex);
posFlagGet(sock->uipChange, POSFLAG_MODE_GETMASK);
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("sockWrite", sock->state == NET_SOCK_WRITE_OK);
sock->state = NET_SOCK_BUSY;
}
posMutexUnlock(sock->mutex);
return len;
}
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);
}
static void task_flag(void *arg)
{
char buf[5];
VAR_t f;
(void) arg;
buf[0] = '>';
buf[1] = 'F';
buf[3] = ' ';
buf[4] = '\0';
for (;;)
{
/* wait for flag event and get flag number */
f = posFlagGet(flags_g, POSFLAG_MODE_GETSINGLE);
/* print flag number */
buf[2] = '0' + (char) f;
print(buf);
}
}
static int sockClose(UosFile* file)
{
P_ASSERT("sockWrite", file->fs->cf == &netFSConf);
NetSock* sock = (NetSock*)file->fsPriv;
posMutexLock(sock->mutex);
if (sock->state == NET_SOCK_BUSY) {
sock->state = NET_SOCK_CLOSE;
dataToSend = 1;
posSemaSignal(uipGiant);
while (sock->state == NET_SOCK_CLOSE) {
posMutexUnlock(sock->mutex);
posFlagGet(sock->uipChange, POSFLAG_MODE_GETMASK);
posMutexLock(sock->mutex);
}
}
if (sock->state == NET_SOCK_LISTENING) {
posMutexLock(uipMutex);
uip_unlisten(sock->port);
posMutexUnlock(uipMutex);
sock->port = 0;
sock->state = NET_SOCK_CLOSE_OK;
}
P_ASSERT("CloseState", (sock->state == NET_SOCK_PEER_CLOSED ||
sock->state == NET_SOCK_PEER_ABORTED ||
sock->state == NET_SOCK_CLOSE_OK));
netSockFree(file);
return 0;
}
int netSockConnect(UosFile* file, uip_ipaddr_t* ip, int port)
{
struct uip_conn* tcp;
struct uip_udp_conn* udp;
P_ASSERT("netSockConnect", file->fs->cf == &netFSConf);
NetSock* sock = (NetSock*)file->fsPriv;
#if UIP_ACTIVE_OPEN == 1
P_ASSERT("sockConnect", (sock->state == NET_SOCK_UNDEF_TCP || sock->state == NET_SOCK_UNDEF_UDP ||
sock->state == NET_SOCK_BOUND || sock->state == NET_SOCK_BOUND_UDP));
#else
P_ASSERT("sockConnect", (sock->state == NET_SOCK_UNDEF_UDP || NET_SOCK_BOUND_UDP));
#endif
if (sock->state == NET_SOCK_UNDEF_TCP) {
#if UIP_ACTIVE_OPEN == 1
posMutexLock(uipMutex);
tcp = uip_connect(ip, uip_htons(port));
if (tcp == NULL) {
posMutexUnlock(uipMutex);
return -1;
}
tcp->appstate.file = file;
posMutexLock(sock->mutex);
sock->state = NET_SOCK_CONNECT;
posMutexUnlock(uipMutex);
while (sock->state == NET_SOCK_CONNECT) {
posMutexUnlock(sock->mutex);
posFlagGet(sock->uipChange, POSFLAG_MODE_GETMASK);
posMutexLock(sock->mutex);
}
if (sock->state == NET_SOCK_PEER_CLOSED || sock->state == NET_SOCK_PEER_ABORTED) {
posMutexUnlock(sock->mutex);
uosFileClose(file);
return -1;
}
P_ASSERT("sockConnect", sock->state == NET_SOCK_CONNECT_OK);
sock->state = NET_SOCK_BUSY;
#endif
}
else {
#if UIP_CONF_UDP == 1
posMutexLock(uipMutex);
udp = uip_udp_new(ip, uip_htons(port));
if (udp == NULL) {
posMutexUnlock(uipMutex);
return -1;
}
udp->appstate.file = file;
if (sock->state == NET_SOCK_BOUND_UDP)
uip_udp_bind(udp, sock->port);
sock->state = NET_SOCK_BUSY;
posMutexUnlock(uipMutex);
#endif
}
return 0;
}
