VAR_t POSCALL nosRegDel(const char *keyname) { REGELEM_t re, rl; VAR_t i; posSemaGet(reglist_sema_g); for (re = reglist_syselem_g[REGTYPE_USER], rl = NULL; re != NULL; rl = re, re = re->next) { if (!IS_DELETED(re)) { for (i=0; i<NOS_MAX_REGKEYLEN; ++i) { if (re->name[i] != keyname[i]) break; if ((keyname[i] == 0) || (i == NOS_MAX_REGKEYLEN-1)) { MARK_DELETED(re); n_remove(re, rl, REGTYPE_USER); posSemaSignal(reglist_sema_g); return E_OK; } } } } posSemaSignal(reglist_sema_g); return -E_FAIL; }
VAR_t POSCALL nosRegQueryElem(NOSREGQHANDLE_t qh, NOSGENERICHANDLE_t *genh, char* namebuf, VAR_t bufsize) { REGQUERY_t rq = (REGQUERY_t) qh; REGELEM_t re; VAR_t i; if ((rq == NULL) || (genh == NULL) || (namebuf == NULL)) return -E_ARG; posSemaGet(reglist_sema_g); if (rq->queryElem == NULL) { re = reglist_syselem_g[rq->type]; } else { re = rq->queryElem->next; DEC_REFCOUNT(rq->queryElem, rq->type); } for(;;) { rq->queryElem = re; if (re == NULL) { posSemaSignal(reglist_sema_g); return -E_NOMORE; } if (IS_VISIBLE(re)) break; re = re->next; } INC_REFCOUNT(re); *genh = re->handle.generic; for (i=0; (i < NOS_MAX_REGKEYLEN) && (i < (bufsize-1)) && (re->name[i] != 0); ++i) { namebuf[i] = re->name[i]; } namebuf[i] = 0; posSemaSignal(reglist_sema_g); return E_OK; }
void POSCALL nos_regDelSysKey(NOSREGTYPE_t type, NOSGENERICHANDLE_t handle, REGELEM_t re) { REGELEM_t rl = REEUNKNOWN; posSemaGet(reglist_sema_g); if (re == NULL) { for (re = reglist_syselem_g[type], rl = NULL; re != NULL; rl = re, re = re->next) { if (!IS_DELETED(re) && (re->handle.generic == handle)) break; } } if (re != NULL) { if (!IS_DELETED(re)) { MARK_DELETED(re); n_remove(re, rl, type); } } posSemaSignal(reglist_sema_g); }
/* This function is called from up to three tasks. * The function contains a section of code that is protected * by a semphore, so that only a maximum number of tasks is allowed * to execute the code simultanously. In this example program * the semaphore is initialized to 2, the counter variable will * count between 1 and 2, and the output is printed by all three * tasks. Example printout: * task2: counter = 2 * task3: counter = 1 * task1: counter = 2 * task3: counter = 2 */ void sharedResource(int tasknbr) { INT_t c; /* wait for shared resource */ posSemaGet(semaphore); /* --------------------------------------------------- */ /* increment global counter */ posAtomicAdd(&counter, 1); /* waste some time (this allows other tasks to enter this section of code, too) */ posTaskSleep(MS(800)); /* Get and print current counter value. * The counter value shows the number of tasks * that are currently executing this section of code. */ c = posAtomicGet(&counter); nosPrintf2("task%i: counter = %i\n", tasknbr, c); /* decrement global counter */ posAtomicSub(&counter, 1); /* --------------------------------------------------- */ /* quit access to shared resource */ 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) { int c; /* wait for exclusive access to counter variable */ posSemaGet(semaphore); /* load variable */ c = counter; /* change copy of variable */ c++; /* waste some time */ posTaskSleep(MS(800)); /* store changed variable */ counter = c; /* print some text */ nosPrintf2("task%i: counter = %i\n", tasknbr, counter); /* quit exclusive access to the counter variable */ posSemaSignal(semaphore); }
/* 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); }
/** * UART transmit interrupt service routine **/ static void usart_txrdy(void) { UDR = tx->buf[tx->tail]; tx->tail = (tx->tail + 1) & (UART_BUF_SIZE - 1); if (tx->tail == tx->head) DISABLE_TXE_INTERRUPT; posSemaSignal(tx->lock); }
/* This is an example of an interrupt service routine. */ void softisr(UVAR_t arg) { /* Avoid compiler warining. arg is the value * that was given to the call to posSoftInt. */ (void) arg; /* Do something useful here. * Note that this function is running at interrupt level, * that means the ISR is not allowed to block, and it is not * allowed to call operating system functions that may block. * The only useful functions that may be called by this * routine are posSemaSignal, posFlagSet, posSoftInt and * posMessageAlloc/posMessageSend. * * An interrupt service routine must be as short as possible! * (Please see the bottom halfs as a variant of this example) * */ /* increment interrupt counter */ isrCounter++; /* signal an event */ posSemaSignal(event); }
REGELEM_t POSCALL nos_regNewSysKey(NOSREGTYPE_t type, const char* name) { REGELEM_t re = NULL; posSemaGet(reglist_sema_g); (void) n_newKey(type, name, &re); posSemaSignal(reglist_sema_g); return re; }
VAR_t POSCALL nosGetNameByHandle(NOSGENERICHANDLE_t handle, char *buffer, VAR_t bufsize, NOSREGTYPE_t what) { NOSREGTYPE_t rt; REGELEM_t re = NULL; VAR_t status = -E_NOTFOUND; VAR_t i; char c; posSemaGet(reglist_sema_g); if (what != REGTYPE_SEARCHALL) { if (what <= MAX_REGTYPE) { re = n_findKeyByHandle(what, handle); } else { status = -E_ARG; } } else for (rt = MIN_REGTYPE; rt <= MAX_REGTYPE; ++rt) { #if NOSCFG_FEATURE_USERREG if (rt != REGTYPE_USER) #endif { re = n_findKeyByHandle(rt, handle); if (re != NULL) break; } } if (re != NULL) { if (IS_VISIBLE(re)) { status = E_OK; if ((buffer != NULL) && (bufsize > 0)) { for (i=0; (i<bufsize-1) && (i<NOS_MAX_REGKEYLEN); ++i) { c = re->name[i]; if (c == 0) break; buffer[i] = c; } buffer[i] = 0; } } } posSemaSignal(reglist_sema_g); return status; }
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 POSCALL nosRegQueryEnd(NOSREGQHANDLE_t qh) { REGQUERY_t rq = (REGQUERY_t) qh; if (rq != NULL) { if (rq->queryElem != NULL) { posSemaGet(reglist_sema_g); DEC_REFCOUNT(rq->queryElem, rq->type); posSemaSignal(reglist_sema_g); } nosMemFree(rq); } }
static void uart_rx(void) { uint8_t ch; ch = UDR; if (rx->full) { /* TODO: Handle Serious buffer * Overflow problem. Currently * discarding rx data */ return ; } rx->buf[rx->head] = ch; rx->head = (rx->head + 1) & (UART_BUF_SIZE - 1); posSemaSignal(rx->lock); if (rx->head == rx->tail) rx->full = 1; }
NOSGENERICHANDLE_t POSCALL nosGetHandleByName(NOSREGTYPE_t objtype, const char *objname) { REGELEM_t re; if ((objtype > MAX_REGTYPE) || (objname ==NULL)) return NULL; if (n_strlen(objname) > NOS_MAX_REGKEYLEN) return NULL; posSemaGet(reglist_sema_g); re = n_findKeyByName(objtype, objname); posSemaSignal(reglist_sema_g); if (re == NULL) return NULL; return IS_VISIBLE(re) ? re->handle.generic : NULL; }
VAR_t POSCALL nosRegGet(const char *keyname, KEYVALUE_t *keyvalue) { REGELEM_t re; if ((keyname == NULL) || (keyvalue == NULL)) return -E_ARG; posSemaGet(reglist_sema_g); re = n_findKeyByName(REGTYPE_USER, keyname); if (re != NULL) { if (IS_VISIBLE(re)) { *keyvalue = re->handle.ukv; } else { re = NULL; } } posSemaSignal(reglist_sema_g); return (re == NULL) ? -E_FAIL : E_OK; }
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; }
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); }
VAR_t POSCALL nosRegSet(const char *keyname, KEYVALUE_t keyvalue) { REGELEM_t re; VAR_t status = E_OK; if (keyname == NULL) return -E_ARG; posSemaGet(reglist_sema_g); re = n_findKeyByName(REGTYPE_USER, keyname); if (re == NULL) { status = n_newKey(REGTYPE_USER, keyname, &re); } if (status == E_OK) { re->handle.ukv = keyvalue; MARK_VISIBLE(re); } posSemaSignal(reglist_sema_g); return status; }
static void task_semas(void *arg) { static INT_t cntr = 0; char buf[5]; buf[1] = 'S'; buf[2] = (char) ((int)arg); buf[3] = ' '; buf[4] = '\0'; (void) arg; for (;;) { /* try to get semaphore */ posSemaGet(sema_g); cntr++; /* sleep one second */ posTaskSleep(HZ); /* print information, how many tasks are in this function */ buf[0] = '0' + (char) cntr; print(buf); if ((cntr < 1) || (cntr > 2)) { print("SEMAPHORE-ERROR"); } cntr--; /* release semaphore again */ posSemaSignal(sema_g); } }
/* * Set a semaphore. */ wwd_result_t host_rtos_set_semaphore(host_semaphore_type_t* semaphore, wiced_bool_t fromISR) { P_ASSERT("fromISR / posInInterrupt_g mismatch.", (fromISR == 0) == (posInInterrupt_g == 0)); posSemaSignal(*semaphore); return WWD_SUCCESS; }
void netInterrupt() { posSemaSignal(uipGiant); }
void netEnableDevicePolling(UINT_t ticks) { pollTicks = ticks; posSemaSignal(uipGiant); }