error_t rreg_receive(OpenQueueEntry_t* msg, coap_header_iht* coap_header, coap_option_iht* coap_options) { error_t outcome; if (coap_header->Code==COAP_CODE_REQ_POST) { // request to register received // triggered: schedule task to execute timer function next scheduler_push_task(rreg_timer,TASKPRIO_COAP); //call timer here, but reset timer after // reset packet payload msg->payload = &(msg->packet[127]); msg->length = 0; // set the CoAP header coap_header->OC = 0; coap_header->Code = COAP_CODE_RESP_VALID; outcome = E_SUCCESS; } else if (coap_header->T==COAP_TYPE_ACK) { // it worked! } else { outcome = E_FAIL; } return outcome; }
__interrupt void PORT2_ISR (void) { #ifdef ISR_BUTTON //interrupt from button connected to P2.7 if ((P2IFG & 0x80)!=0) { P2IFG &= ~0x80; // clear interrupt flag scheduler_push_task(ID_ISR_BUTTON); // post task __bic_SR_register_on_exit(CPUOFF); // restart CPU } #endif }
__interrupt void PORT1_ISR (void) { #ifdef ISR_RADIO //interrupt from radio through IRQ_RF connected to P1.6 if ((P1IFG & 0x40)!=0) { P1IFG &= ~0x40; // clear interrupt flag scheduler_push_task(ID_ISR_RADIO); // post task __bic_SR_register_on_exit(CPUOFF); // restart CPU } #endif }
__interrupt void TIMERB0_ISR (void) { #ifdef ISR_TIMERS if (timers_continuous[0]==TRUE) { TBCCR0 += timers_period[0]; // continuous timer: schedule next instant } else { TBCCTL0 = 0; // stop the timer TBCCR0 = 0; } scheduler_push_task(ID_ISR_MAC_PERIODIC); // post the corresponding task __bic_SR_register_on_exit(CPUOFF); // restart CPU #endif }
/** \brief Called back from opentimers when a CoAP message is received for this resource. Timer fired, but we don't want to execute task in ISR mode. Instead, push task to scheduler with COAP priority, and let scheduler take care of it. \param[in] id The opentimer identifier used to resolve the csensor resource associated parsed. */ void csensors_timer_cb(opentimers_id_t id){ uint8_t i; for(i=0;i<csensors_vars.numCsensors;i++) { if (csensors_vars.csensors_resource[i].timerId == i) { csensors_vars.cb_list[csensors_vars.cb_put] = i; csensors_vars.cb_put = (csensors_vars.cb_put+1)%CSENSORSTASKLIST; opentimers_scheduleIn( csensors_vars.csensors_resource[i].timerId, csensors_vars.csensors_resource[i].period, TIME_MS, TIMER_ONESHOT, csensors_timer_cb ); break; } } scheduler_push_task(csensors_task_cb,TASKPRIO_COAP); }
void stupidmac_sendDone(OpenQueueEntry_t* pkt, error_t error) { openqueue_freePacketBuffer(pkt); scheduler_push_task(ID_TASK_APPLICATION); // ask the scheduler to do run task_application again }
//timer fired, but we don't want to execute task in ISR mode //instead, push task to scheduler with COAP priority, and let scheduler take care of it void bbk_timer_cb(){ scheduler_push_task(bbk_task_cb,TASKPRIO_COAP); }
void sixtop_timeout_timer_cb(opentimer_id_t id) { scheduler_push_task(timer_sixtop_six2six_timeout_fired,TASKPRIO_SIXTOP_TIMEOUT); }
//timer fired, but we don't want to execute task in ISR mode //instead, push task to scheduler with COAP priority, and let scheduler take care of it void rex_timer_cb(){ scheduler_push_task(rex_task_cb,TASKPRIO_COAP); }
void openserial_debugPrint_timer_cb(opentimers_id_t id){ //leds_radio_toggle(); scheduler_push_task(task_openserial_debugPrint,TASKPRIO_OPENSERIAL); }
void sixtop_maintenance_timer_cb(opentimer_id_t id) { scheduler_push_task(timer_sixtop_management_fired,TASKPRIO_SIXTOP); }
/** \note timer fired, but we don't want to execute task in ISR mode instead, push task to scheduler with CoAP priority, and let scheduler take care of it. */ void uinject_timer_cb(opentimer_id_t id){ scheduler_push_task(uinject_task_cb,TASKPRIO_COAP); }
uint8_t isr_openserial_rx(void) { uint8_t rxbyte; uint8_t returnVal; returnVal = 0; // read byte just received rxbyte = uart_readByte(); if ( openserial_vars.hdlcBusyReceiving==FALSE && openserial_vars.hdlcLastRxByte==HDLC_FLAG && rxbyte!=HDLC_FLAG ) { // start of frame // I'm now receiving openserial_vars.hdlcBusyReceiving = TRUE; // create the HDLC frame inputHdlcOpen(); // add the byte just received inputHdlcWrite(rxbyte); } else if ( openserial_vars.hdlcBusyReceiving==TRUE && rxbyte!=HDLC_FLAG ) { // middle of frame // add the byte just received inputHdlcWrite(rxbyte); if (openserial_vars.inputBufFillLevel+1>SERIAL_INPUT_BUFFER_SIZE){ // push task scheduler_push_task(task_printInputBufferOverflow,TASKPRIO_OPENSERIAL); openserial_vars.inputBufFillLevel = 0; openserial_vars.hdlcBusyReceiving = FALSE; } } else if ( openserial_vars.hdlcBusyReceiving==TRUE && rxbyte==HDLC_FLAG ) { // end of frame // finalize the HDLC frame inputHdlcClose(); openserial_vars.hdlcBusyReceiving = FALSE; if (openserial_vars.inputBufFillLevel==0){ // push task scheduler_push_task(task_printWrongCRCInput,TASKPRIO_OPENSERIAL); } else { openserial_handleRxFrame(); openserial_vars.inputBufFillLevel = 0; returnVal = 1; } } openserial_vars.hdlcLastRxByte = rxbyte; return returnVal; }
//timer fired, but we don't want to execute task in ISR mode //instead, push task to scheduler with COAP priority, and let scheduler take care of it void cexample_timer_cb(){ scheduler_push_task(cexample_task_cb,TASKPRIO_COAP); }
void udprand_timer() { scheduler_push_task(udprand_task,TASKPRIO_COAP); }
/** \brief DIO timer callback function. \note This function is executed in interrupt context, and should only push a task. */ void icmpv6rpl_timer_DIO_cb(opentimer_id_t id) { scheduler_push_task(icmpv6rpl_timer_DIO_task,TASKPRIO_RPL); }
__interrupt void TIMERB1through6_ISR (void) { #ifdef ISR_TIMERS uint16_t tbiv_temp = TBIV; // read only once because accessing TBIV resets it switch (tbiv_temp) { case 0x0002: if (timers_continuous[1]==TRUE) { TBCCR1 += timers_period[1]; // continuous timer: schedule next instant } else { TBCCTL1 = 0; // stop the timer TBCCR1 = 0; } scheduler_push_task(ID_ISR_MAC_BACKOFF);// post the corresponding task __bic_SR_register_on_exit(CPUOFF); // restart CPU break; case 0x0004: if (timers_continuous[2]==TRUE) { TBCCR2 += timers_period[2]; // continuous timer: schedule next instant } else { TBCCTL2 = 0; // stop the timer TBCCR2 = 0; } scheduler_push_task(ID_ISR_MAC_WATCHDOG);// post the corresponding task __bic_SR_register_on_exit(CPUOFF); // restart CPU break; case 0x0006: if (timers_continuous[3]==TRUE) { TBCCR3 += timers_period[3]; // continuous timer: schedule next instant } else { TBCCTL3 = 0; // stop the timer TBCCR3 = 0; } scheduler_push_task(ID_ISR_TCP_TIMEOUT);// post the corresponding task __bic_SR_register_on_exit(CPUOFF); // restart CPU break; case 0x0008: if (timers_continuous[4]==TRUE) { TBCCR4 += timers_period[4]; // continuous timer: schedule next instant } else { TBCCTL4 = 0; // stop the timer TBCCR4 = 0; } scheduler_push_task(ID_ISR_RPL); // post the corresponding task __bic_SR_register_on_exit(CPUOFF); // restart CPU break; case 0x000A: if (timers_continuous[5]==TRUE) { TBCCR5 += timers_period[5]; // continuous timer: schedule next instant } else { TBCCTL5 = 0; // stop the timer TBCCR5 = 0; } scheduler_push_task(ID_ISR_TIMERB5); // post the corresponding task __bic_SR_register_on_exit(CPUOFF); // restart CPU break; case 0x000C: if (timers_continuous[6]==TRUE) { TBCCR6 += timers_period[6]; // continuous timer: schedule next instant } else { TBCCTL6 = 0; // stop the timer TBCCR6 = 0; } #ifdef TASK_APPLICATION task_app_count++; scheduler_push_task(ID_TASK_APPLICATION);// post the corresponding task #else scheduler_push_task(ID_ISR_TIMERB6); // post the corresponding task #endif __bic_SR_register_on_exit(CPUOFF); // restart CPU break; default: while(1); // this should not happen } #endif }
void res_timer_cb() { scheduler_push_task(timers_res_fired,TASKPRIO_RES); }
//timer fired, but we don't want to execute task in ISR mode //instead, push task to scheduler with COAP priority, and let scheduler take care of it void cexample_timer_cb(OpenMote* self){ scheduler_push_task(self, cexample_task_cb,TASKPRIO_COAP); }
void otf_notif_removedCell(void) { scheduler_push_task(otf_removeCell_task,TASKPRIO_OTF); }
void udplatency_timer() { scheduler_push_task(udplatency_task,TASKPRIO_COAP); }
//timer fired, but we don't want to execute task in ISR mode //instead, push task to scheduler with COAP priority, and let scheduler take care of it void table_update_timer_cb(opentimer_id_t id){ scheduler_push_task(table_update_task_cb,TASKPRIO_COAP); }
/** \brief DAO timer callback function. \note This function is executed in interrupt context, and should only push a task. */ void icmpv6rpl_timer_DAO_cb() { scheduler_push_task(icmpv6rpl_timer_DAO_task,TASKPRIO_RPL); }
/** \note timer fired, but we don't want to execute task in ISR mode instead, push task to scheduler with CoAP priority, and let scheduler take care of it. */ void uinject_timer_cb(OpenMote* self, opentimer_id_t id){ scheduler_push_task(self, uinject_task_cb,TASKPRIO_COAP); }