/************************************************************************* * Function Name: main * Parameters: none * * Return: none * * Description: main * *************************************************************************/ int main(void) { typedef Int32U ram_unit; // int cursor_x = (C_GLCD_H_SIZE - CURSOR_H_SIZE)/2, cursor_y = (C_GLCD_V_SIZE - CURSOR_V_SIZE)/2; // unsigned long int deltaT; static float freq_aveg; int LCD_updatecount; LCD_updatecount = 0; //From uip start unsigned int i; uip_ipaddr_t ipaddr; struct timer periodic_timer, arp_timer; //From uip end /*** COMPARE FIX POINT 523235 ***/ /*** COMPARE FIX POINT 523235 ***/ GLCD_Ctrl (FALSE); // Init GPIO GpioInit(); #ifndef SDRAM_DEBUG // MAM init MAMCR_bit.MODECTRL = 0; MAMTIM_bit.CYCLES = 3; // FCLK > 40 MHz MAMCR_bit.MODECTRL = 2; // MAM functions fully enabled // Init clock InitClock(); // SDRAM Init SDRAM_Init(); #endif // SDRAM_DEBUG // Init VIC VIC_Init(); // GLCD init // GLCD_Init (IarLogoPic.pPicStream, NULL); // Can be removed, remember to remove the h and c file as well // GLCD_Init (LogoPic.pPicStream, NULL); // Can be removed, remember to remove the h and c file as well GLCD_Init (what_is_a_blissPic.pPicStream, NULL); GLCD_Cursor_Dis(0); //From uip // GLCD_Cursor_Dis(0); // GLCD_Copy_Cursor ((Int32U *)Cursor, 0, sizeof(Cursor)/sizeof(Int32U)); /*** COMPARE FIX POINT 534252 ***/ /*** COMPARE FIX POINT 534252 ***/ GLCD_Cursor_Cfg(CRSR_FRAME_SYNC | CRSR_PIX_32); //From uip // GLCD_Cursor_Cfg(CRSR_FRAME_SYNC | CRSR_PIX_64); // GLCD_Move_Cursor(cursor_x, cursor_y); // GLCD_Cursor_En(0); //From uip start // Sys timer init 1/100 sec tick clock_init(2); timer_set(&periodic_timer, CLOCK_SECOND / 2); timer_set(&arp_timer, CLOCK_SECOND * 10); //From uip end // Init USB Link LED USB_D_LINK_LED_SEL = 0; // GPIO USB_D_LINK_LED_FSET = USB_D_LINK_LED_MASK; USB_D_LINK_LED_FDIR |= USB_D_LINK_LED_MASK; USB_H_LINK_LED_SEL = 0; // GPIO USB_H_LINK_LED_FSET = USB_H_LINK_LED_MASK; USB_H_LINK_LED_FDIR |= USB_H_LINK_LED_MASK; /*-----------------------------------------------------------------*/ // Init AD0[3] for current meassurement PINSEL1_bit.P0_26 = 1; // Assign P26 to AD0[3], page 180 PINMODE1_bit.P0_26 = 2; // //Neither pull-up or pull-down // PCONP_bit.PCAD = 1; // Note: Clear the PDN bit in the AD0CR before clearing this bit and set this before PDN // Other initial parameters are already set // AD0CR_bit.SEL = 8; // select Ch3 [1111] current_amp = 0; /*-----------------------------------------------------------------*/ // Init the DAC converter //Clock: In the PCLK_SEL0 register (Table 4�), select PCLK_DAC //PCLKSEL0_bit.PCLK_DAC = 3UL;// **HAS Desided for values yet!** // '11' at bit 23 and 22 (which is CCLK/8) //or use 0x3 for 3UL instead //Pins: Select the DAC pin and pin mode in registers PINSEL1 and PINMODE1 (see Section 9�. //PINSEL1 |= (2UL<<20); // PINSEL1_bit.P0_26 = 1; //?? //PINSEL1_bit.P0_26 = 2UL; //"PINMODE registers control the on-chip pull-up/pull-down resistor feature for all GPIO ports." - page 178 //PINMODE1 |= ________; // See table 128 for values. Write to bit 21:20 //PINMODE1_bit.P0_26 = 2UL; //P0.26MODE = 2UL; //Neither pull-up or pull-down /* ------------------------------------------------------------------*/ // Init ADC converter // Power the ADC converter PINSEL1_bit.P0_25 = 1; // Assign Pin 25 to ADO[2] PINMODE1_bit.P0_25 = 1; // Neither pull-up or pull-dow PCONP_bit.PCAD = 1; // Note: Clear the PDN bit in the AD0CR before clearing this bit and set this before PDN AD0CR_bit.PDN = 1; // A/D converter is operational AD0CR_bit.START = 0; // Conversion not started AD0CR_bit.BURST = 0; // disable burst // AD0CR_bit.SEL = 4; // select Ch2 [11] // Select number of clocks for each conversion AD0CR_bit.CLKS = 0; // [000] 11 clocks / 10 bits AD0CR_bit.CLKDIV = SYS_GetFpclk(ADC_PCLK_OFFSET)/ 10000; // 4500000; // Should be equal to 10K samplingrate ADINTEN_bit.ADGINTEN = 1; // Global A/D channels enabled by ADINTEN 7:0 // Since only on channel is used at the moment the global flag is enabled VIC_SetVectoredIRQ(AD0IntrHandler,1,VIC_AD0); // Set the interrupt call VICINTENABLE |= 1UL << VIC_AD0; // Setting parameters for the low-pass filter DACR_previous = 0; // Initialize DACR_temp which is y(i-1) deltaT = 1.0/TIMER0_TICK_PER_SEC; // Set the sample rate // Calculate the R*C for cut-off frequency of the low pass filter alpha = deltaT/(1./(2.*3.1416*100.) + deltaT); // Cut-off = 100 Hz done = 0; // Channel stage /* ------------------------------------------------------------------*/ // Setting the port to P0[11] and P0[19] PINSEL1_bit.P0_19 = 0; // GPIO to P0[19] PINSEL0_bit.P0_11 = 0; // GPIO to P0[11] PINMODE1_bit.P0_19 = 2; // Pin has neither pull up or down PINMODE0_bit.P0_11 = 2; // Pin has neither pull up or down FIO0DIR_bit.P0_19 = 1; FIO0CLR = (1UL<<19); FIO0DIR_bit.P0_11 = 1; FIO0CLR = (1UL<<11); FIO0PIN_bit.P0_19 = 1; FIO0PIN_bit.P0_11 = 1; /* ------------------------------------------------------------------*/ // Enable TIM0 clocks PCONP_bit.PCTIM0 = 1; // enable clock // Init Time0 T0TCR_bit.CE = 0; // counting disable T0TCR_bit.CR = 1; // set reset T0TCR_bit.CR = 0; // release reset T0CTCR_bit.CTM = 0; // Timer Mode: every rising PCLK edge T0MCR_bit.MR0I = 1; // Enable Interrupt on MR0 T0MCR_bit.MR0R = 1; // Enable reset on MR0 T0MCR_bit.MR0S = 0; // Disable stop on MR0 // set timer 0 period T0PR = 0; T0MR0 = SYS_GetFpclk(TIMER0_PCLK_OFFSET)/(TIMER0_TICK_PER_SEC); // init timer 0 interrupt T0IR_bit.MR0INT = 1; // clear pending interrupt VIC_SetVectoredIRQ(Timer0IntrHandler,0,VIC_TIMER0); VICINTENABLE |= 1UL << VIC_TIMER0; T0TCR_bit.CE = 1; // counting Enable __enable_interrupt(); GLCD_Ctrl (TRUE); #if 0 SDRAM_Test(); #endif /* // SMB380_Init(); SMB380_GetID(&Smb380Id, &Smb380Ver); SMB380_Data_t XYZT; */ /*** COMPARE FIX POINT 856364 ***/ /*** COMPARE FIX POINT 856364 ***/ /*** COMPARE FIX POINT 856364 ***/ /*** COMPARE FIX POINT 856364 ***/ //From uip start GLCD_SetFont(&Terminal_18_24_12,0x000000,0x000cd4ff); GLCD_SetWindow(85,10,255,33); GLCD_TextSetPos(0,0); GLCD_print("\f Room Station"); //From uip start /*** COMPARE FIX POINT 458923 ***/ /*** COMPARE FIX POINT 458923 ***/ // GLCD_SetWindow(5,200,319,239); // GLCD_SetFont(&Terminal_6_8_6,0x0000FF,0x000cd4ff); // Initialize the ethernet device driver do { GLCD_TextSetPos(0,0); } while(!tapdev_init()); GLCD_TextSetPos(0,0); // uIP web server // Initialize the uIP TCP/IP stack. uip_init(); uip_ipaddr(ipaddr, 192,168,0,100); uip_sethostaddr(ipaddr); uip_ipaddr(ipaddr, 192,168,0,1); uip_setdraddr(ipaddr); uip_ipaddr(ipaddr, 255,255,255,0); uip_setnetmask(ipaddr); // Initialize the HTTP server. httpd_init(); /*** COMPARE FIX POINT 4572742 ***/ /*** COMPARE FIX POINT 4572742 ***/ /*** COMPARE FIX POINT 4572742 ***/ /*** COMPARE FIX POINT 4572742 ***/ /*** WHILE LOOP START ***/ while(1) { /*** COMPARE FIX POINT 938194 ***/ /*** COMPARE FIX POINT 938194 ***/ /*** COMPARE FIX POINT 938194 ***/ /*** COMPARE FIX POINT 938194 ***/ /*** COMPARE FIX POINT 938194 ***/ uip_len = tapdev_read(uip_buf); if(uip_len > 0) { if(BUF->type == htons(UIP_ETHTYPE_IP)) { uip_arp_ipin(); uip_input(); /* If the above function invocation resulted in data that should be sent out on the network, the global variable uip_len is set to a value > 0. */ if(uip_len > 0) { uip_arp_out(); tapdev_send(uip_buf,uip_len); } } else if(BUF->type == htons(UIP_ETHTYPE_ARP)) { uip_arp_arpin(); /* If the above function invocation resulted in data that should be sent out on the network, the global variable uip_len is set to a value > 0. */ if(uip_len > 0) { tapdev_send(uip_buf,uip_len); } } } else if(timer_expired(&periodic_timer)) { timer_reset(&periodic_timer); for(i = 0; i < UIP_CONNS; i++) { uip_periodic(i); /* If the above function invocation resulted in data that should be sent out on the network, the global variable uip_len is set to a value > 0. */ if(uip_len > 0) { uip_arp_out(); tapdev_send(uip_buf,uip_len); } } #if UIP_UDP for(i = 0; i < UIP_UDP_CONNS; i++) { uip_udp_periodic(i); /* If the above function invocation resulted in data that should be sent out on the network, the global variable uip_len is set to a value > 0. */ if(uip_len > 0) { uip_arp_out(); tapdev_send(); } } #endif /* UIP_UDP */ /* Call the ARP timer function every 10 seconds. */ if(timer_expired(&arp_timer)) { timer_reset(&arp_timer); uip_arp_timer(); } } #define AVERAGECOUNT 100000 if(LCD_updatecount <= AVERAGECOUNT) { ++LCD_updatecount; freq_aveg += freq; } else { freq_aveg = freq_aveg/AVERAGECOUNT; updateFreqHistory(freq_aveg); //Must be kept together with freq calculation! GLCD_SetWindow(20,55,150,80); GLCD_SetFont(&Terminal_18_24_12,0x000000,0x009fee00); GLCD_TextSetPos(0,5); GLCD_print("\f Hz %3.3f", freq_aveg); freq_aveg = 0; GLCD_SetWindow(20,90,150,115); GLCD_SetFont(&Terminal_18_24_12,0x000000,0x009fee00); GLCD_TextSetPos(0,5); GLCD_print("\f V %3.3f", sqrtf(vol_rms_result)); updateVoltageHistory(sqrtf(vol_rms_result)); GLCD_SetWindow(20,125,150,150); GLCD_SetFont(&Terminal_18_24_12,0x000000,0x009fee00); GLCD_TextSetPos(0,5); GLCD_print("\f uA %3.3f", sqrtf(current_amp)); GLCD_SetWindow(20,160,150,185); GLCD_SetFont(&Terminal_18_24_12,0x000000,0x009fee00); GLCD_TextSetPos(0,5); GLCD_print("\f uP %3.3f", sqrtf(vol_rms_result)*sqrtf(current_amp)); LCD_updatecount = 0; } }//while(1) loop }//main function
__interrupt void PORT2_ISR(void) #endif { u8 int_flag, int_enable; u8 buzzer = 0; u8 simpliciti_button_event = 0; static u8 simpliciti_button_repeat = 0; // Clear button flags button.all_flags = 0; // Remember interrupt enable bits int_enable = BUTTONS_IE; // Store valid button interrupt flag int_flag = BUTTONS_IFG & int_enable; // --------------------------------------------------- // While SimpliciTI stack is active, buttons behave differently: // - Store button events in SimpliciTI packet data // - Exit SimpliciTI when button DOWN was pressed if (is_rf()) { // Erase previous button press after a number of resends (increase number if link quality is low) // This will create a series of packets containing the same button press // Necessary because we have no acknowledge // Filtering (edge detection) will be done by receiver software if (simpliciti_button_repeat++ > 6) { simpliciti_data[0] &= ~0xF0; simpliciti_button_repeat = 0; } if ((int_flag & BUTTON_STAR_PIN) == BUTTON_STAR_PIN) { simpliciti_data[0] |= SIMPLICITI_BUTTON_STAR; simpliciti_button_event = 1; } else if ((int_flag & BUTTON_NUM_PIN) == BUTTON_NUM_PIN) { simpliciti_data[0] |= SIMPLICITI_BUTTON_NUM; simpliciti_button_event = 1; } else if ((int_flag & BUTTON_UP_PIN) == BUTTON_UP_PIN) { simpliciti_data[0] |= SIMPLICITI_BUTTON_UP; simpliciti_button_event = 1; } else if ((int_flag & BUTTON_DOWN_PIN) == BUTTON_DOWN_PIN) { simpliciti_flag |= SIMPLICITI_TRIGGER_STOP; } // Trigger packet sending inside SimpliciTI stack if (simpliciti_button_event) simpliciti_flag |= SIMPLICITI_TRIGGER_SEND_DATA; } else // Normal operation { // Debounce buttons if ((int_flag & ALL_BUTTONS) != 0) { // Disable PORT2 IRQ __disable_interrupt(); BUTTONS_IE = 0x00; __enable_interrupt(); // Debounce delay 1 Timer0_A4_Delay(CONV_MS_TO_TICKS(BUTTONS_DEBOUNCE_TIME_IN)); // Reset inactivity detection sTime.last_activity = sTime.system_time; } // --------------------------------------------------- // STAR button IRQ if (IRQ_TRIGGERED(int_flag, BUTTON_STAR_PIN)) { // Filter bouncing noise if (BUTTON_STAR_IS_PRESSED) { button.flag.star = 1; // Generate button click buzzer = 1; } } // --------------------------------------------------- // NUM button IRQ else if (IRQ_TRIGGERED(int_flag, BUTTON_NUM_PIN)) { // Filter bouncing noise if (BUTTON_NUM_IS_PRESSED) { button.flag.num = 1; // Generate button click buzzer = 1; if( !sys.flag.lock_buttons) { #ifdef CONFIG_STOP_WATCH // Faster reaction for stopwatch split button press if (is_stopwatch_run()) { split_stopwatch(); button.flag.num = 0; } #endif } } } // --------------------------------------------------- // UP button IRQ else if (IRQ_TRIGGERED(int_flag, BUTTON_UP_PIN)) { // Filter bouncing noise if (BUTTON_UP_IS_PRESSED) { button.flag.up = 1; // Generate button click buzzer = 1; } } // --------------------------------------------------- // DOWN button IRQ else if (IRQ_TRIGGERED(int_flag, BUTTON_DOWN_PIN)) { // Filter bouncing noise if (BUTTON_DOWN_IS_PRESSED) { button.flag.down = 1; // Generate button click buzzer = 1; if( !sys.flag.lock_buttons) { #ifdef CONFIG_STOP_WATCH // Faster reaction for stopwatch stop button press if (is_stopwatch_run()) { stop_stopwatch(); button.flag.down = 0; } // Faster reaction for stopwatch start button press else if (is_stopwatch_stop()) { start_stopwatch(); button.flag.down = 0; } #endif } } } // --------------------------------------------------- // B/L button IRQ else if (IRQ_TRIGGERED(int_flag, BUTTON_BACKLIGHT_PIN)) { // Filter bouncing noise if (BUTTON_BACKLIGHT_IS_PRESSED) { sButton.backlight_status = 1; sButton.backlight_timeout = 0; P2OUT |= BUTTON_BACKLIGHT_PIN; P2DIR |= BUTTON_BACKLIGHT_PIN; button.flag.backlight = 1; } } } // Trying to lock/unlock buttons? if ((button.flag.num && button.flag.down) || (button.flag.star && button.flag.up)) { // No buzzer output buzzer = 0; button.all_flags = 0; } // Generate button click when button was activated if (buzzer) { // Any button event stops active alarm #ifdef CONFIG_ALARM if (sAlarm.state == ALARM_ON) { stop_alarm(); button.all_flags = 0; } else #endif #ifdef CONFIG_EGGTIMER if (sEggtimer.state == EGGTIMER_ALARM) { stop_eggtimer_alarm(); button.all_flags = 0; } else #endif if (!sys.flag.up_down_repeat_enabled && !sys.flag.no_beep) { start_buzzer(1, CONV_MS_TO_TICKS(20), CONV_MS_TO_TICKS(150)); } // Debounce delay 2 Timer0_A4_Delay(CONV_MS_TO_TICKS(BUTTONS_DEBOUNCE_TIME_OUT)); } #ifdef FEATURE_PROVIDE_ACCEL // --------------------------------------------------- // Acceleration sensor IRQ if (IRQ_TRIGGERED(int_flag, AS_INT_PIN)) { // Get data from sensor request.flag.acceleration_measurement = 1; } #endif // --------------------------------------------------- // Pressure sensor IRQ if (IRQ_TRIGGERED(int_flag, PS_INT_PIN)) { // Get data from sensor request.flag.altitude_measurement = 1; } // --------------------------------------------------- // Safe long button event detection if(button.flag.star || button.flag.num) { // Additional debounce delay to enable safe high detection Timer0_A4_Delay(CONV_MS_TO_TICKS(BUTTONS_DEBOUNCE_TIME_LEFT)); // Check if this button event is short enough if (BUTTON_STAR_IS_PRESSED) button.flag.star = 0; if (BUTTON_NUM_IS_PRESSED) button.flag.num = 0; } // Reenable PORT2 IRQ __disable_interrupt(); BUTTONS_IFG = 0x00; BUTTONS_IE = int_enable; __enable_interrupt(); // Exit from LPM3/LPM4 on RETI __bic_SR_register_on_exit(LPM4_bits); }
void main(void) { unsigned int uartUpdateTimer = UART_UPDATE_INTERVAL; unsigned char i; WDTCTL = WDTPW + WDTHOLD; // Stop WDT InitializeClocks(); InitializeButton(); InitializeLeds(); PreApplicationMode(); // Blinks LEDs, waits for button press /* Application Mode begins */ applicationMode = APP_APPLICATION_MODE; ConfigureAdcTempSensor(); ConfigureTimerPwm(); __enable_interrupt(); // Enable interrupts. /* Main Application Loop */ while(1) { ADC10CTL0 |= ENC + ADC10SC; // Sampling and conversion start __bis_SR_register(CPUOFF + GIE); // LPM0 with interrupts enabled /* Moving average filter out of 8 values to somewhat stabilize sampled ADC */ tempMeasured[tempMeasuredPosition++] = ADC10MEM; if (tempMeasuredPosition == 8) tempMeasuredPosition = 0; tempAverage = 0; for (i = 0; i < 8; i++) tempAverage += tempMeasured[i]; tempAverage >>= 3; // Divide by 8 to get average if ((--uartUpdateTimer == 0) || calibrateUpdate ) { ConfigureTimerUart(); if (calibrateUpdate) { TXByte = 248; // A character with high value, outside of temp range Transmit(); calibrateUpdate = 0; } TXByte = (unsigned char)( ((tempAverage - 630) * 761) / 1024 ); Transmit(); uartUpdateTimer = UART_UPDATE_INTERVAL; ConfigureTimerPwm(); } tempDifference = tempAverage - tempCalibrated; if (tempDifference < -TEMP_THRESHOLD) { tempDifference = -tempDifference; tempPolarity = TEMP_COLD; LED_OUT &= ~ LED1; } else if (tempDifference > TEMP_THRESHOLD) { tempPolarity = TEMP_HOT; LED_OUT &= ~ LED2; } else { tempPolarity = TEMP_SAME; TACCTL0 &= ~CCIE; TACCTL1 &= ~CCIE; LED_OUT &= ~(LED1 + LED2); } if (tempPolarity != TEMP_SAME) { tempDifference <<= 3; tempDifference += TIMER_PWM_OFFSET; TACCR1 = ( (tempDifference) < (TIMER_PWM_PERIOD-1) ? (tempDifference) : (TIMER_PWM_PERIOD-1) ); TACCTL0 |= CCIE; TACCTL1 |= CCIE; } } }
Void Timer_masterEnable(Void) { __enable_interrupt(); }
interrupt(WDT_VECTOR) isr_wdt(void) { __disable_interrupt(); (*isr_table[ISR_WDT])(); __enable_interrupt(); }
interrupt(TIMERA1_VECTOR) isr_timer_a1(void) { __disable_interrupt(); (*isr_table[ISR_TIMERA1])(); __enable_interrupt(); }
interrupt(ADC10_VECTOR) isr_adc(void) { __disable_interrupt(); (*isr_table[ISR_ADC])(); __enable_interrupt(); }
void EnableInterrupts() { __enable_interrupt(); }
__weak void vPortSuppressTicksAndSleep( portTickType xExpectedIdleTime ) { unsigned long ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickIncrements; portTickType xModifiableIdleTime; /* Make sure the SysTick reload value does not overflow the counter. */ if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks ) { xExpectedIdleTime = xMaximumPossibleSuppressedTicks; } /* Calculate the reload value required to wait xExpectedIdleTime tick periods. -1 is used because this code will execute part way through one of the tick periods, and the fraction of a tick period is accounted for later. */ ulReloadValue = ( ulTimerReloadValueForOneTick * ( xExpectedIdleTime - 1UL ) ); if( ulReloadValue > ulStoppedTimerCompensation ) { ulReloadValue -= ulStoppedTimerCompensation; } /* Stop the SysTick momentarily. The time the SysTick is stopped for is accounted for as best it can be, but using the tickless mode will inevitably result in some tiny drift of the time maintained by the kernel with respect to calendar time. */ portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT; /* Adjust the reload value to take into account that the current time slice is already partially complete. */ ulReloadValue += ( portNVIC_SYSTICK_LOAD_REG - ( portNVIC_SYSTICK_LOAD_REG - portNVIC_SYSTICK_CURRENT_VALUE_REG ) ); /* Enter a critical section but don't use the taskENTER_CRITICAL() method as that will mask interrupts that should exit sleep mode. */ __disable_interrupt(); /* If a context switch is pending or a task is waiting for the scheduler to be unsuspended then abandon the low power entry. */ if( eTaskConfirmSleepModeStatus() == eAbortSleep ) { /* Restart SysTick. */ portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT; /* Re-enable interrupts - see comments above __disable_interrupt() call above. */ __enable_interrupt(); } else { /* Set the new reload value. */ portNVIC_SYSTICK_LOAD_REG = ulReloadValue; /* Clear the SysTick count flag and set the count value back to zero. */ portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL; /* Restart SysTick. */ portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT; /* Sleep until something happens. configPRE_SLEEP_PROCESSING() can set its parameter to 0 to indicate that its implementation contains its own wait for interrupt or wait for event instruction, and so wfi should not be executed again. However, the original expected idle time variable must remain unmodified, so a copy is taken. */ xModifiableIdleTime = xExpectedIdleTime; configPRE_SLEEP_PROCESSING( xModifiableIdleTime ); if( xModifiableIdleTime > 0 ) { __WFI(); } configPOST_SLEEP_PROCESSING( xExpectedIdleTime ); /* Stop SysTick. Again, the time the SysTick is stopped for is accounted for as best it can be, but using the tickless mode will inevitably result in some tiny drift of the time maintained by the kernel with respect to calendar time. */ portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT; /* Re-enable interrupts - see comments above __disable_interrupt() call above. */ __enable_interrupt(); if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 ) { /* The tick interrupt has already executed, and the SysTick count reloaded with the portNVIC_SYSTICK_LOAD_REG value. Reset the portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick period. */ portNVIC_SYSTICK_LOAD_REG = ulTimerReloadValueForOneTick - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG ); /* The tick interrupt handler will already have pended the tick processing in the kernel. As the pending tick will be processed as soon as this function exits, the tick value maintained by the tick is stepped forward by one less than the time spent waiting. */ ulCompleteTickPeriods = xExpectedIdleTime - 1UL; } else { /* Something other than the tick interrupt ended the sleep. Work out how long the sleep lasted. */ ulCompletedSysTickIncrements = ( xExpectedIdleTime * ulTimerReloadValueForOneTick ) - portNVIC_SYSTICK_CURRENT_VALUE_REG; /* How many complete tick periods passed while the processor was waiting? */ ulCompleteTickPeriods = ulCompletedSysTickIncrements / ulTimerReloadValueForOneTick; /* The reload value is set to whatever fraction of a single tick period remains. */ portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1 ) * ulTimerReloadValueForOneTick ) - ulCompletedSysTickIncrements; } /* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG again, then set portNVIC_SYSTICK_LOAD_REG back to its standard value. */ portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL; portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT; vTaskStepTick( ulCompleteTickPeriods ); } }