自学教程：C++ ENABLE_INTERRUPTS函数代码示例

/**/brief Request a new (free) packet buffer.Component throughout the protocol stack can call this function is they want toget a new packet buffer to start creating a new packet./note Once a packet has been allocated, it is up to the creator of the packet      to free it using the openqueue_freePacketBuffer() function./returns A pointer to the queue entry when it could be allocated, or NULL when         it could not be allocated (buffer full or not synchronized).*/OpenQueueEntry_t* openqueue_getFreePacketBuffer(uint8_t creator) {   uint8_t i;   INTERRUPT_DECLARATION();   DISABLE_INTERRUPTS();      // refuse to allocate if we're not in sync   if (ieee154e_isSynch()==FALSE && creator > COMPONENT_IEEE802154E){     ENABLE_INTERRUPTS();     return NULL;   }      // if you get here, I will try to allocate a buffer for you      // walk through queue and find free entry   for (i=0;i<QUEUELENGTH;i++) {      if (openqueue_vars.queue[i].owner==COMPONENT_NULL) {         openqueue_vars.queue[i].creator=creator;         openqueue_vars.queue[i].owner=COMPONENT_OPENQUEUE;         ENABLE_INTERRUPTS();          return &openqueue_vars.queue[i];      }   }   ENABLE_INTERRUPTS();   return NULL;}

//Puts the thread with the ID tid to sleepvoid CALLING_CONVENTION CX86Scheduler::sleepThread(pid_t tid, size_t count){	if (count == 0)		return;	bool islocked = false;	bool isrunning = true;	DISABLE_INTERRUPTS();	//Turn off preemption	m_lock.acquireSpinlock();	iterator_t itr = m_runningList.findValue((PTHREAD)tid);	if (!m_runningList.isEntry(itr))	{		isrunning = false;		//Not on the running list, scan the blocked list		itr = m_blockedList.findValue((PTHREAD)tid);		if (!m_blockedList.isEntry(itr))		{			//Thread does not exist, release lock and return			m_lock.releaseSpinlock();			ENABLE_INTERRUPTS();			return;		}	}	//OK, we found the thread	PTHREAD thread = (PTHREAD)tid;	thread->waitcount += count;	if (isrunning)	{		m_runningList.removeAt(itr);		m_blockedList.insertToTail(thread);	}	m_lock.releaseSpinlock();	ENABLE_INTERRUPTS();}

// Threads return here and space is freedvoid mythread_cleanup(){	// Unblock thread blocked by join	DISABLE_INTERRUPTS();	int id = running_thread[1]->thread.blocking_id;	if (id > 0) {		Node * temp = 0xffffffff;		temp = lookup_node(running_thread[1]->thread.blocking_id, WAITING); //Blocking ID was not the expected value Camtendo 11/4		if (temp != 0xffffffff) // not found		{			Node * blocked_node = (Node *) malloc(sizeof(Node));			blocked_node->thread = temp->thread;			blocked_node->thread.scheduling_status = READY;			remove_node(temp, WAITING);			add_node(blocked_node, READY);		}	}	ENABLE_INTERRUPTS();	alt_printf("COMPLETED./n");	DISABLE_INTERRUPTS();	free(running_thread[1]->thread.context);	running_thread[1]->thread.scheduling_status = DONE;	ENABLE_INTERRUPTS();	while(TRUE);}

/* *	Record a usimple_lock just acquired on *	the current processor. * *	MACH_RT:  Preemption has been disabled by lock *	acquisition, so it's safe to use the cpu number *	specified by the caller. */voidusl_stack_push(	usimple_lock_t	l,	int		mycpu){	spl_t		s;	if (uslock_stack_enabled == FALSE)		return;	DISABLE_INTERRUPTS(s);	assert(uslock_stack_index[mycpu] >= 0);	assert(uslock_stack_index[mycpu] < USLOCK_STACK_DEPTH);	if (uslock_stack_index[mycpu] >= USLOCK_STACK_DEPTH) {		printf("usl_stack_push (cpu 0x%x):  too many locks (%d)",		       mycpu, uslock_stack_index[mycpu]);		printf(" disabling stacks/n");		uslock_stack_enabled = FALSE;		ENABLE_INTERRUPTS(s);		return;	}	uslock_stack[mycpu][uslock_stack_index[mycpu]] = l;	uslock_stack_index[mycpu]++;	ENABLE_INTERRUPTS(s);}

void main(){	OUTPUT_LOW(LCD_RW); //Che do ghi 	LCD_Init();        //Khoi tao LCD	LCD_PutCmd(0x01);  //Xoa man hinh	ENABLE_INTERRUPTS(INT_TIMER0); //Kich hoat ngat ngoai	SETUP_TIMER_0(RTCC_INTERNAL|RTCC_DIV_32); //Xung kich noi va chia truoc 32	ENABLE_INTERRUPTS(GLOBAL); //Cho phep ngat toan cuc	SET_TIMER0(100); //Bat dau dem tu 100, khi tran Timer0 duoc 1ms	while (True){ //Duy tri hoat dong cua vi dieu khien		if (dem > N_max){			dem = 0;			LCD_PutCmd(0x01);		}		LCD_SetPosition(0x00); //Cot 1 dong 1		LCD_PutChar("Dem so:");		LCD_SetPosition(0x07); //Cot 8 dong 1		printf(LCD_PutChar,"%lu",dem);	}}

 OpenQueueEntry_t* openqueue_macGetDataPacket(open_addr_t* toNeighbor) {   uint8_t i;   INTERRUPT_DECLARATION();   DISABLE_INTERRUPTS();   if (toNeighbor->type==ADDR_64B) {      // a neighbor is specified, look for a packet unicast to that neigbhbor      for (i=0;i<QUEUELENGTH;i++) {         if (openqueue_vars.queue[i].owner==COMPONENT_RES_TO_IEEE802154E &&            packetfunctions_sameAddress(toNeighbor,&openqueue_vars.queue[i].l2_nextORpreviousHop)) {            ENABLE_INTERRUPTS();            return &openqueue_vars.queue[i];         }      }   } else if (toNeighbor->type==ADDR_ANYCAST) {      // anycast case: look for a packet which is either not created by RES      // or an KA (created by RES, but not broadcast)      for (i=0;i<QUEUELENGTH;i++) {         if (openqueue_vars.queue[i].owner==COMPONENT_RES_TO_IEEE802154E &&             ( openqueue_vars.queue[i].creator!=COMPONENT_RES ||                (                   openqueue_vars.queue[i].creator==COMPONENT_RES &&                   packetfunctions_isBroadcastMulticast(&(openqueue_vars.queue[i].l2_nextORpreviousHop))==FALSE                )             )            ) {            ENABLE_INTERRUPTS();            return &openqueue_vars.queue[i];         }      }   }   ENABLE_INTERRUPTS();   return NULL;}

void process_reorg_encrypt_restart(void){	intrpt_state_t	prev_intrpt_state;	enc_info_t	*encr_ptr;	int		gtmcrypt_errno;	gd_segment	*seg;	sgmnt_addrs	*csa;	csa = reorg_encrypt_restart_csa;	assert(NULL != csa);	/* caller should have ensured this */	/* Opening handles for encryption is a heavyweight operation. Caller should have ensured we are not in crit for	 * any region when the new key handles are opened for any one region. Assert that.	 */	assert(0 == have_crit(CRIT_HAVE_ANY_REG));	DEFER_INTERRUPTS(INTRPT_IN_CRYPT_RECONFIG, prev_intrpt_state);	encr_ptr = csa->encr_ptr;	assert(NULL != encr_ptr);	DBG_RECORD_CRYPT_RECEIVE(csa->hdr, csa, csa->nl, process_id, encr_ptr);	seg = csa->region->dyn.addr;	INIT_DB_OR_JNL_ENCRYPTION(csa, encr_ptr, seg->fname_len, seg->fname, gtmcrypt_errno);	if (0 != gtmcrypt_errno)	{		ENABLE_INTERRUPTS(INTRPT_IN_CRYPT_RECONFIG, prev_intrpt_state);		GTMCRYPT_REPORT_ERROR(gtmcrypt_errno, rts_error, seg->fname_len, seg->fname);	}	reorg_encrypt_restart_csa = NULL;	ENABLE_INTERRUPTS(INTRPT_IN_CRYPT_RECONFIG, prev_intrpt_state);}

/* *	Eliminate the entry for a usimple_lock *	that had been active on the current processor. * *	MACH_RT:  Preemption has been disabled by lock *	acquisition, and we haven't yet actually *	released the hardware lock associated with *	this usimple_lock, so it's safe to use the *	cpu number supplied by the caller. */voidusl_stack_pop(	usimple_lock_t	l,	int		mycpu){	unsigned int	i, index;	spl_t		s;	if (uslock_stack_enabled == FALSE)		return;	DISABLE_INTERRUPTS(s);	assert(uslock_stack_index[mycpu] > 0);	assert(uslock_stack_index[mycpu] <= USLOCK_STACK_DEPTH);	if (uslock_stack_index[mycpu] == 0) {		printf("usl_stack_pop (cpu 0x%x):  not enough locks (%d)",		       mycpu, uslock_stack_index[mycpu]);		printf(" disabling stacks/n");		uslock_stack_enabled = FALSE;		ENABLE_INTERRUPTS(s);		return;	}	index = --uslock_stack_index[mycpu];	for (i = 0; i <= index; ++i) {		if (uslock_stack[mycpu][i] == l) {			if (i != index)				uslock_stack[mycpu][i] =					uslock_stack[mycpu][index];			ENABLE_INTERRUPTS(s);			return;		}	}	ENABLE_INTERRUPTS(s);	panic("usl_stack_pop:  can't find usimple_lock 0x%x", l);}

void openserial_startInput() {   INTERRUPT_DECLARATION();      if (openserial_vars.inputBufFill>0) {      openserial_printError(COMPONENT_OPENSERIAL,ERR_INPUTBUFFER_LENGTH,                            (errorparameter_t)openserial_vars.inputBufFill,                            (errorparameter_t)0);      DISABLE_INTERRUPTS();      openserial_vars.inputBufFill=0;      ENABLE_INTERRUPTS();   }      uart_clearTxInterrupts();   uart_clearRxInterrupts();      // clear possible pending interrupts   uart_enableInterrupts();       // Enable USCI_A1 TX & RX interrupt      DISABLE_INTERRUPTS();   openserial_vars.busyReceiving  = FALSE;   openserial_vars.mode           = MODE_INPUT;   openserial_vars.reqFrameIdx    = 0;#ifdef FASTSIM   uart_writeBufferByLen_FASTSIM(      openserial_vars.reqFrame,      sizeof(openserial_vars.reqFrame)   );   openserial_vars.reqFrameIdx = sizeof(openserial_vars.reqFrame);#else   uart_writeByte(openserial_vars.reqFrame[openserial_vars.reqFrameIdx]);#endif   ENABLE_INTERRUPTS();}

owerror_t idmanager_setMyID(open_addr_t* newID) {   INTERRUPT_DECLARATION();   DISABLE_INTERRUPTS();   switch (newID->type) {     case ADDR_16B:        memcpy(&idmanager_vars.my16bID,newID,sizeof(open_addr_t));        break;     case ADDR_64B:        memcpy(&idmanager_vars.my64bID,newID,sizeof(open_addr_t));        break;     case ADDR_PANID:        memcpy(&idmanager_vars.myPANID,newID,sizeof(open_addr_t));        break;     case ADDR_PREFIX:        memcpy(&idmanager_vars.myPrefix,newID,sizeof(open_addr_t));        break;     case ADDR_128B:        //don't set 128b, but rather prefix and 64b     default:        openserial_printCritical(COMPONENT_IDMANAGER,ERR_WRONG_ADDR_TYPE,              (errorparameter_t)newID->type,              (errorparameter_t)1);        ENABLE_INTERRUPTS();        return E_FAIL;   }   ENABLE_INTERRUPTS();   return E_SUCCESS;}

void main(){    float distance = 0;        OUTPUT_LOW(LCD_RW);    LCD_Init();    LCD_PutCmd(0x01);        SETUP_TIMER_1(T1_INTERNAL|T1_DIV_BY_4);    SETUP_CCP1(CCP_CAPTURE_RE);        ENABLE_INTERRUPTS(INT_CCP1);    ENABLE_INTERRUPTS(GLOBAL);            while (True){        Trigger();                while (echo == 0){            ;        }                distance = value*0.8/58;        LCD_PutCmd(0x01);        LCD_SetPosition(0x00);        LCD_PutChar("Distance:");        LCD_SetPosition(0x40);        printf(LCD_PutChar,"%.2fcm",distance);        delay_ms(1000);    }}

uint8_t openserial_getInputBuffer(uint8_t* bufferToWrite, uint8_t maxNumBytes) {    uint8_t numBytesWritten;    uint8_t inputBufFillLevel;    INTERRUPT_DECLARATION();    //<<<<<<<<<<<<<<<<<<<<<<<    DISABLE_INTERRUPTS();    inputBufFillLevel = openserial_vars.inputBufFillLevel;    ENABLE_INTERRUPTS();    //>>>>>>>>>>>>>>>>>>>>>>>    if (maxNumBytes<inputBufFillLevel-1) {        openserial_printError(            COMPONENT_OPENSERIAL,            ERR_GETDATA_ASKS_TOO_FEW_BYTES,            (errorparameter_t)maxNumBytes,            (errorparameter_t)inputBufFillLevel-1        );        numBytesWritten = 0;    } else {        numBytesWritten = inputBufFillLevel-1;        //<<<<<<<<<<<<<<<<<<<<<<<        DISABLE_INTERRUPTS();        memcpy(bufferToWrite,&(openserial_vars.inputBuf[1]),numBytesWritten);        ENABLE_INTERRUPTS();        //>>>>>>>>>>>>>>>>>>>>>>>    }    return numBytesWritten;}

/** * Send the given byte to the USART. It is added to the transmit buffer, and asynchronously * transmitted. * * @param c     Byte to write out on the serial port */void serPutByte(BYTE c) {    //Check if buffer is full.    #ifdef SER_WAIT_FOR_TXBUF    //Wait until a byte is transmitted by the interrupt routine and buffer has place again.    while (busIsTxBufFull(BUSID)) {        FAST_USER_PROCESS();    }    #else    if (busIsTxBufFull(BUSID)) {        serStat |= SER1_TXBUF_OVERRUN;        return;    }    #endif    //Enter critical section    DISBALE_INTERRUPTS();    //If we are not currently TXing, the TX buffer will be empty. No need to transmit via buffer,    //just write direct to TXREG    if ( !PIE1_TXIE)    {        TXREG = c;      //Send byte        PIE1_TXIE = 1;  //Indicate that we are currently TXing        ENABLE_INTERRUPTS();    }    //We are currently TXing. This means that the TXIF will soon be set after the current byte    //has been transmitted, and the TX buffer will be checked for any unsent data. Add current    //byte to TX buffer.    else {        //Add byte to TX buffer, and update buffer pointers        busPutByteTxBuf(BUFID, c);                ENABLE_INTERRUPTS();    }}

void main(){   TRISE = 0x00; //Chan OUTPUT   ENABLE_INTERRUPTS(INT_TIMER0); //Kich hoat ngat tran Timer0   SETUP_TIMER_0(RTCC_INTERNAL|RTCC_DIV_32); //Xung kich noi va chia truoc 32   ENABLE_INTERRUPTS(GLOBAL); //Cho phep ngat toan cuc   SET_TIMER0(100); //Bat dau dem tu 100, khi tran Timer0 duoc 1ms   while (True){ //Duy tri hoat dong cua vi dieu khien      ;       }}

 bool neighbors_isPreferredParent(open_addr_t* address) {   uint8_t i;   INTERRUPT_DECLARATION();   DISABLE_INTERRUPTS();   for (i=0;i<MAXNUMNEIGHBORS;i++) {      if (isThisRowMatching(address,i) && neighbors_vars.neighbors[i].parentPreference==MAXPREFERENCE) {    	  ENABLE_INTERRUPTS();         return TRUE;      }   }   ENABLE_INTERRUPTS();   return FALSE;}

void openserial_stop() {    uint16_t temp_openserial_input_buffer_fill_level;    INTERRUPT_DECLARATION();    DISABLE_INTERRUPTS();    temp_openserial_input_buffer_fill_level = openserial_vars.input_buffer_fill_level;    ENABLE_INTERRUPTS();    uart_disableInterrupts();              // disable USCI_A1 TX & RX interrupt    DISABLE_INTERRUPTS();    openserial_vars.mode=MODE_OFF;    ENABLE_INTERRUPTS();    if (temp_openserial_input_buffer_fill_level>0) {        uint8_t temp_openserial_received_command;        DISABLE_INTERRUPTS();        temp_openserial_received_command = openserial_vars.received_command;        ENABLE_INTERRUPTS();        switch (temp_openserial_received_command) {        case 'R': //Trigger IDManager about isRoot            idmanager_triggerAboutRoot();            break;        case 'B': //Trigger IDManager about isBridge            idmanager_triggerAboutBridge();            break;        case 'T': //Trigger TCPInject            tcpinject_trigger();            break;        case 'U': //Trigger UDPInject            udpinject_trigger();            break;        case 'E': //Trigger ICMPv6Echo            icmpv6echo_trigger();            break;        case 'O': //Trigger ICMPv6Router            icmpv6router_trigger();            break;        case 'P': //Trigger ICMPv6RPL            icmpv6rpl_trigger();            break;        case 'D': //Trigger OpenBridge (called only by moteProbe)            openbridge_trigger();            break;        default:            openserial_printError(COMPONENT_OPENSERIAL,ERR_UNSUPPORTED_COMMAND,                                  (errorparameter_t)temp_openserial_received_command,                                  (errorparameter_t)0);            DISABLE_INTERRUPTS();            openserial_vars.input_buffer_fill_level = 0;            ENABLE_INTERRUPTS();            break;        }    }}

/* Unwind a trigger level, pop all the associated mv_stents and dispense with the base frame. * Note that this unwind restores the condition handler stack pointer and correct gtm_trigger_depth value in * order to maintain these values properly in the event of a major unwind. This routine is THE routine to use to unwind * trigger base frames in all cases due to the cleanups it takes care of. */void gtm_trigger_fini(boolean_t forced_unwind, boolean_t fromzgoto){	if (0 == (frame_pointer->type & SFT_TRIGR))		GTMASSERT;		/* Would normally be an assert but potential frame stack damage so severe					   and resulting debug difficulty that we GTMASSERT instead. */	/* Unwind the trigger base frame */	op_unwind();	/* restore frame_pointer stored at msp (see base_frame.c) */	frame_pointer = *(stack_frame**)msp;	msp += SIZEOF(stack_frame *);		/* Remove frame save pointer from stack */	if (!forced_unwind)	{	/* Remove the "do not return to me" flag only on non-error unwinds. Note this flag may have already been		 * turned off by an earlier tp_restart if this is not an implicit_tstart situation.		 */		assert(!tp_pointer->implicit_tstart || (SFF_TRIGR_CALLD & frame_pointer->flags));		frame_pointer->flags &= SFF_TRIGR_CALLD_OFF;		DBGTRIGR((stderr, "gtm_trigger_fini: turning off SFF_TRIGR_CALLD (2) in frame 0x"lvaddr"/n", frame_pointer));	} else	{	/* Error unwind, make sure certain cleanups are done */#		ifdef DEBUG		assert(!dollar_tlevel || (tstart_trigger_depth <= gtm_trigger_depth));		if (tstart_trigger_depth == gtm_trigger_depth) /* Unwinding gvcst_put() so get rid of flag it potentially set */			donot_INVOKE_MUMTSTART = FALSE;#		endif		if (tp_pointer)		{	/* This TP transaction can never be allowed to commit if this is the first trigger			 * (see comment in tp_frame.h against "cannot_commit" field for details).			 */			if ((0 == gtm_trigger_depth) && !fromzgoto)			{				DBGTRIGR((stderr, "gtm_trigger: cannot_commit flag set to TRUE/n"))				tp_pointer->cannot_commit = TRUE;			}			if ((tp_pointer->fp == frame_pointer) && tp_pointer->implicit_tstart)				OP_TROLLBACK(-1); /* We just unrolled the implicitly started TSTART so unroll what it did */		}	}	DBGTRIGR((stderr, "gtm_trigger: POP: frame_pointer 0x%016lx  ctxt value: 0x%016lx/n", frame_pointer, ctxt));	/* Re-allow interruptions now that our base frame is gone */	if (forced_unwind)	{	/* Since we are being force-unwound, we don't know the state of things except that it it should be either		 * the state we set it to or the ok-to-interrupt state. Assert that and if we are changing the state,		 * be sure to run the deferred handler.		 */		assert((INTRPT_IN_TRIGGER_NOMANS_LAND == intrpt_ok_state) || (INTRPT_OK_TO_INTERRUPT == intrpt_ok_state));		ENABLE_INTERRUPTS(intrpt_ok_state);	} else	{	/* Normal unwind should be ok with this macro */		ENABLE_INTERRUPTS(INTRPT_IN_TRIGGER_NOMANS_LAND);	}}

 OpenQueueEntry_t* openqueue_resGetReceivedPacket() {   uint8_t i;   INTERRUPT_DECLARATION();   DISABLE_INTERRUPTS();   for (i=0;i<QUEUELENGTH;i++) {      if (openqueue_vars.queue[i].owner==COMPONENT_IEEE802154E_TO_RES &&          openqueue_vars.queue[i].creator==COMPONENT_IEEE802154E) {    	  ENABLE_INTERRUPTS();    	  return &openqueue_vars.queue[i];      }   }   ENABLE_INTERRUPTS();   return NULL;}

OpenQueueEntry_t* openqueue_macGetEBPacket() {   uint8_t i;   INTERRUPT_DECLARATION();   DISABLE_INTERRUPTS();   for (i=0;i<QUEUELENGTH;i++) {      if (openqueue_vars.queue[i].owner==COMPONENT_SIXTOP_TO_IEEE802154E &&          openqueue_vars.queue[i].creator==COMPONENT_SIXTOP) {         ENABLE_INTERRUPTS();         return &openqueue_vars.queue[i];      }   }   ENABLE_INTERRUPTS();   return NULL;}

void main(){    TRISB = 0XFF; //Chan INPUT    TRISE = 0x00; //Chan OUTPUT    PORT_B_PULLUPS(0x01); //Noi dien tro len nguon    PORTE = 0x00; //Set gia tri ban dau la muc 0    ENABLE_INTERRUPTS(INT_EXT); //Kich hoat ngat ngoai    EXT_INT_EDGE(H_TO_L); //Chon canh ngat, cao xuong thap    ENABLE_INTERRUPTS(GLOBAL); //Cho phep ngat toan cuc    while (True){ //Duy tri hoat dong cua vi dieu khien        ;    }}

 OpenQueueEntry_t* openqueue_macGetAdvPacket() {   uint8_t i;   INTERRUPT_DECLARATION();   DISABLE_INTERRUPTS();   for (i=0;i<QUEUELENGTH;i++) {      if (openqueue_vars.queue[i].owner==COMPONENT_RES_TO_IEEE802154E &&          openqueue_vars.queue[i].creator==COMPONENT_RES              &&          packetfunctions_isBroadcastMulticast(&(openqueue_vars.queue[i].l2_nextORpreviousHop))) {    	  ENABLE_INTERRUPTS();          return &openqueue_vars.queue[i];      }   }   ENABLE_INTERRUPTS();   return NULL;}

   /* received from the UART and placed in the receive buffer.          */static void RxProcess(void){   unsigned int MaxWrite;   unsigned int Count;   /* Determine the number of characters that can be delivered.         */   Count = (UartContext.RxBufferSize - UartContext.RxBytesFree);   if(Count)   {      /* Determine the maximum number of characters that we can send    */      /* before we reach the end of the buffer.  We need to process     */      /* the smaller of the max characters of the number of             */      /* characters that are in the buffer.                             */      MaxWrite = (UartContext.RxBufferSize-UartContext.RxOutIndex);      Count    = (MaxWrite < Count)?MaxWrite:Count;      /* Call the upper layer back with the data.                       */      if((Count) && (_COMDataCallback))         (*_COMDataCallback)(TRANSPORT_ID, Count, &UartContext.RxBuffer[UartContext.RxOutIndex], _COMCallbackParameter);      /* Adjust the Out Index and handle any looping.                   */      UartContext.RxOutIndex += Count;      if(UartContext.RxOutIndex >= UartContext.RxBufferSize)         UartContext.RxOutIndex = 0;      /* Enter a critical region to update counts and also create       */      /* new Rx records if needed.                                      */      DISABLE_INTERRUPTS();      /* Credit the amount that was sent to the upper layer.            */      UartContext.RxBytesFree += Count;      ENABLE_INTERRUPTS();      if((!(UartContext.Flags & UART_CONTEXT_FLAG_FLOW_ENABLED)) && (UartContext.RxBytesFree >= UartContext.XOnLimit) && (UartContext.SuspendState == hssNormal))      {         DISABLE_INTERRUPTS();         /* Flag that flow is re-enabled.                               */         UartContext.Flags |= UART_CONTEXT_FLAG_FLOW_ENABLED;         ENABLE_INTERRUPTS();         /* Re-enable flow                                              */         FLOW_ON();      }   }}

/**/brief Check whether I can send on this slot.This function is called at the beginning of every TX slot.If the slot is *not* a shared slot, it always return TRUE.If the slot is a shared slot, it decrements the backoff counter and returns TRUE only if it hits 0.Note that the backoff counter is global, not per slot./returns TRUE if it is OK to send on this slot, FALSE otherwise. */bool schedule_getOkToSend() {   bool returnVal;      INTERRUPT_DECLARATION();   DISABLE_INTERRUPTS();      if (schedule_vars.currentScheduleEntry->shared==FALSE) {      // non-shared slot: backoff does not apply            returnVal = TRUE;   } else {      // non-shared slot: check backoff before answering            // decrement backoff      if (schedule_vars.backoff>0) {         schedule_vars.backoff--;      }            // only return TRUE if backoff hit 0      if (schedule_vars.backoff==0) {         returnVal = TRUE;      } else {         returnVal = FALSE;      }   }      ENABLE_INTERRUPTS();   return returnVal;}

void schedule_advanceSlot() {   INTERRUPT_DECLARATION();   DISABLE_INTERRUPTS();   // advance to next active slot   schedule_vars.currentScheduleEntry = schedule_vars.currentScheduleEntry->next;   ENABLE_INTERRUPTS();}

error_t openserial_printData(uint8_t* buffer, uint8_t length) {    uint8_t counter;    uint8_t asn[5];    INTERRUPT_DECLARATION();    DISABLE_INTERRUPTS();    openserial_vars.somethingInOutputBuffer=TRUE;    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'^';                  //preamble    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'^';    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'^';    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'D';                  //this is data    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)((idmanager_getMyID(ADDR_16B))->addr_16b[1]);    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)((idmanager_getMyID(ADDR_16B))->addr_16b[0]);    //asn to serial ..    asnWriteToSerial(asn);// byte01,byte23,byte4    openserial_vars.output_buffer[output_buffer_index_write_increment()]=asn[0];    openserial_vars.output_buffer[output_buffer_index_write_increment()]=asn[1];    openserial_vars.output_buffer[output_buffer_index_write_increment()]=asn[2];    openserial_vars.output_buffer[output_buffer_index_write_increment()]=asn[3];    openserial_vars.output_buffer[output_buffer_index_write_increment()]=asn[4];    for (counter=0; counter<length; counter++) {        openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)buffer[counter];    }    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'$';                  //postamble    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'$';    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'$';    ENABLE_INTERRUPTS();    return E_SUCCESS;}

uint16_t output_buffer_index_write_increment() {    INTERRUPT_DECLARATION();    DISABLE_INTERRUPTS();    openserial_vars.output_buffer_index_write=(openserial_vars.output_buffer_index_write+1)%SERIAL_OUTPUT_BUFFER_SIZE;    ENABLE_INTERRUPTS();    return openserial_vars.output_buffer_index_write;}

void sys_arch_unprotect(sys_prot_t pval){    if(pval == 1)    {        ENABLE_INTERRUPTS();    }}

bool RITQueue_Free(uint8_t elementpos){	bool ret = false;	uint8_t  i;	//EnterCriticalSection	INTERRUPT_DECLARATION();	DISABLE_INTERRUPTS();	if (elementpos < maxElements)	{		RITQueue_ClearAddress(&pvObjList[elementpos].destaddr);		pvObjList[elementpos].timestamp   = 0;		pvObjList[elementpos].msglength   = 0;		pvObjList[elementpos].frameType   = 0;		pvObjList[elementpos].pending     = 0;		pvObjList[elementpos].numTargetParents     = 0;		pvObjList[elementpos].countretry  = 0;		pvObjList[elementpos].lasttxduration  = 0;		pvObjList[elementpos].isBroadcastMulticast = 0;		if (numAvailableElements > 0)			numAvailableElements--;		ret = true;	}	//LeaveCriticalSection	ENABLE_INTERRUPTS();	return ret;}

error_t openserial_printError(uint8_t calling_component, uint8_t error_code,                              errorparameter_t arg1,                              errorparameter_t arg2) {    leds_error_toggle();    INTERRUPT_DECLARATION();    DISABLE_INTERRUPTS();    openserial_vars.somethingInOutputBuffer=TRUE;    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'^';                  //preamble    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'^';    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'^';    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'E';                  //this is an error    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)((idmanager_getMyID(ADDR_16B))->addr_16b[1]);    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)((idmanager_getMyID(ADDR_16B))->addr_16b[0]);    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)calling_component;    //component generating error    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)error_code;           //error_code    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)((arg1 & 0xff00)>>8); //arg1    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t) (arg1 & 0x00ff);    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)((arg2 & 0xff00)>>8); //arg2    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t) (arg2 & 0x00ff);    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'$';                  //postamble    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'$';    openserial_vars.output_buffer[output_buffer_index_write_increment()]=(uint8_t)'$';    ENABLE_INTERRUPTS();    return E_SUCCESS;}