visus
/
framework-arduinoteensy-cxx20
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
Tree: 8b2d08b377
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8b2d08b377'
${ noResults }
framework-arduinoteensy-cxx20/libraries/LowPower/LowPower.cpp

542 lines
17KB
Raw Blame History 

  1. /*******************************************************************************

  2. * LowPower Library

  3. * Version: 1.20

  4. * Date: 16-12-2011

  5. * Company: Rocket Scream Electronics

  6. * Website: www.rocketscream.com

  7. *

  8. * This is a lightweight low power library for Arduino. Please check our wiki 

  9. * (www.rocketscream.com/wiki) for more information on using this piece of 

  10. * library.

  11. *

  12. * This library is licensed under Creative Commons Attribution-ShareAlike 3.0 

  13. * Unported License.

  14. *

  15. * Revision  Description

  16. * ========  ===========

  17. * 1.20			Remove typo error in idle method for checking whether Timer 0 was 

  18. *						turned off.

  19. *						Remove dependecy on WProgram.h which is not required.

  20. *						Tested to work with Arduino IDE 1.0.

  21. * 1.10			Added #ifndef for sleep_bod_disable() for compatibility with future

  22. *						Arduino IDE release.

  23. * 1.00      Initial public release.

  24. *******************************************************************************/

  25. #include <avr/sleep.h>

  26. #include <avr/wdt.h>

  27. #include <avr/power.h>

  28. #include <avr/interrupt.h>

  29. #include "LowPower.h"

  30. 

  31. #ifndef sleep_bod_disable

  32. #define sleep_bod_disable() 										\

  33. do { 																\

  34.   unsigned char tempreg; 													\

  35.   __asm__ __volatile__("in %[tempreg], %[mcucr]" "\n\t" 			\

  36.                        "ori %[tempreg], %[bods_bodse]" "\n\t" 		\

  37.                        "out %[mcucr], %[tempreg]" "\n\t" 			\

  38.                        "andi %[tempreg], %[not_bodse]" "\n\t" 		\

  39.                        "out %[mcucr], %[tempreg]" 					\

  40.                        : [tempreg] "=&d" (tempreg) 					\

  41.                        : [mcucr] "I" _SFR_IO_ADDR(MCUCR), 			\

  42.                          [bods_bodse] "i" (_BV(BODS) | _BV(BODSE)), \

  43.                          [not_bodse] "i" (~_BV(BODSE))); 			\

  44. } while (0)

  45. #endif

  46. 

  47. #define	lowPowerBodOn(mode)	\

  48. do { 						\

  49.       set_sleep_mode(mode); \

  50.       cli();				\

  51.       sleep_enable();		\

  52.       sei();				\

  53.       sleep_cpu();			\

  54.       sleep_disable();		\

  55.       sei();				\

  56. } while (0);

  57. 

  58. #define	lowPowerBodOff(mode)\

  59. do { 						\

  60.       set_sleep_mode(mode); \

  61.       cli();				\

  62.       sleep_enable();		\

  63.       sleep_bod_disable();	\

  64.       sei();				\

  65.       sleep_cpu();			\

  66.       sleep_disable();		\

  67.       sei();				\

  68. } while (0);

  69. 

  70. /*******************************************************************************

  71. * Name: idle

  72. * Description: Putting microcontroller into idle state. Please make sure you 

  73. *			   understand the implication and result of disabling module.

  74. *

  75. * Argument  	Description

  76. * =========  	===========

  77. * 1. period     Duration of low power mode. Use SLEEP_FOREVER to use other wake

  78. *				up resource:

  79. *				(a) SLEEP_15MS - 15 ms sleep

  80. *				(b) SLEEP_30MS - 30 ms sleep

  81. *				(c) SLEEP_60MS - 60 ms sleep

  82. *				(d) SLEEP_120MS - 120 ms sleep

  83. *				(e) SLEEP_250MS - 250 ms sleep

  84. *				(f) SLEEP_500MS - 500 ms sleep

  85. *				(g) SLEEP_1S - 1 s sleep

  86. *				(h) SLEEP_2S - 2 s sleep

  87. *				(i) SLEEP_4S - 4 s sleep

  88. *				(j) SLEEP_1S - 8 s sleep

  89. *				(k) SLEEP_FOREVER - Sleep without waking up through WDT

  90. *

  91. * 2. adc		ADC module disable control:

  92. *				(a) ADC_OFF - Turn off ADC module

  93. *				(b) ADC_ON - Leave ADC module in its default state

  94. *

  95. * 3. timer2		Timer 2 module disable control:

  96. *				(a) TIMER2_OFF - Turn off Timer 2 module

  97. *				(b) TIMER2_ON - Leave Timer 2 module in its default state

  98. *

  99. * 4. timer1		Timer 1 module disable control:

  100. *				(a) TIMER1_OFF - Turn off Timer 1 module

  101. *				(b) TIMER1_ON - Leave Timer 1 module in its default state

  102. *

  103. * 5. timer0		Timer 0 module disable control:

  104. *				(a) TIMER0_OFF - Turn off Timer 0 module

  105. *				(b) TIMER0_ON - Leave Timer 0 module in its default state

  106. *

  107. * 6. spi		SPI module disable control:

  108. *				(a) ADC_OFF - Turn off ADC module

  109. *				(b) ADC_ON - Leave ADC module in its default state

  110. *

  111. * 7. usart0		USART0 module disable control:

  112. *				(a) USART0_OFF - Turn off USART0  module

  113. *				(b) USART0_ON - Leave USART0 module in its default state

  114. *

  115. * 8. twi		TWI module disable control:

  116. *				(a) TWI_OFF - Turn off TWI module

  117. *				(b) TWI_ON - Leave TWI module in its default state

  118. *

  119. *******************************************************************************/

  120. void	LowPowerClass::idle(period_t period, adc_t adc, timer2_t timer2, 

  121. 							timer1_t timer1, timer0_t timer0,

  122. 							spi_t spi, usart0_t usart0,	twi_t twi)

  123. {

  124. 	// Temporary clock source variable 

  125. 	unsigned char clockSource = 0;

  126. 	

  127. 	if (timer2 == TIMER2_OFF)

  128. 	{

  129. 		if (TCCR2B & CS22) clockSource |= (1 << CS22);

  130. 		if (TCCR2B & CS21) clockSource |= (1 << CS21);

  131. 		if (TCCR2B & CS20) clockSource |= (1 << CS20);

  132. 	

  133. 		// Remove the clock source to shutdown Timer2

  134. 		TCCR2B &= ~(1 << CS22);

  135. 		TCCR2B &= ~(1 << CS21);

  136. 		TCCR2B &= ~(1 << CS20);

  137. 		

  138. 		power_timer2_disable();

  139. 	}

  140. 	

  141. 	if (adc == ADC_OFF)	

  142. 	{

  143. 		ADCSRA &= ~(1 << ADEN);

  144. 		power_adc_disable();

  145. 	}

  146. 	

  147. 	if (timer1 == TIMER1_OFF)	power_timer1_disable();	

  148. 	if (timer0 == TIMER0_OFF)	power_timer0_disable();	

  149. 	if (spi == SPI_OFF)			power_spi_disable();

  150. 	if (usart0 == USART0_OFF)	power_usart0_disable();

  151. 	if (twi == TWI_OFF)			power_twi_disable();

  152. 	

  153. 	if (period != SLEEP_FOREVER)

  154. 	{

  155. 		wdt_enable(period);

  156. 		WDTCSR |= (1 << WDIE);	

  157. 	}

  158. 	

  159. 	lowPowerBodOn(SLEEP_MODE_IDLE);

  160. 	

  161. 	if (adc == ADC_OFF)

  162. 	{

  163. 		power_adc_enable();

  164. 		ADCSRA |= (1 << ADEN);

  165. 	}

  166. 	

  167. 	if (timer2 == TIMER2_OFF)

  168. 	{

  169. 		if (clockSource & CS22) TCCR2B |= (1 << CS22);

  170. 		if (clockSource & CS21) TCCR2B |= (1 << CS21);

  171. 		if (clockSource & CS20) TCCR2B |= (1 << CS20);

  172. 		

  173. 		power_timer2_enable();

  174. 	}

  175. 	

  176. 	if (timer1 == TIMER1_OFF)	power_timer1_enable();	

  177. 	if (timer0 == TIMER0_OFF)	power_timer0_enable();	

  178. 	if (spi == SPI_OFF)			power_spi_enable();

  179. 	if (usart0 == USART0_OFF)	power_usart0_enable();

  180. 	if (twi == TWI_OFF)			power_twi_enable();

  181. }

  182. 

  183. /*******************************************************************************

  184. * Name: adcNoiseReduction

  185. * Description: Putting microcontroller into ADC noise reduction state. This is

  186. *			   a very useful state when using the ADC to achieve best and low 

  187. *              noise signal.

  188. *

  189. * Argument  	Description

  190. * =========  	===========

  191. * 1. period     Duration of low power mode. Use SLEEP_FOREVER to use other wake

  192. *				up resource:

  193. *				(a) SLEEP_15MS - 15 ms sleep

  194. *				(b) SLEEP_30MS - 30 ms sleep

  195. *				(c) SLEEP_60MS - 60 ms sleep

  196. *				(d) SLEEP_120MS - 120 ms sleep

  197. *				(e) SLEEP_250MS - 250 ms sleep

  198. *				(f) SLEEP_500MS - 500 ms sleep

  199. *				(g) SLEEP_1S - 1 s sleep

  200. *				(h) SLEEP_2S - 2 s sleep

  201. *				(i) SLEEP_4S - 4 s sleep

  202. *				(j) SLEEP_1S - 8 s sleep

  203. *				(k) SLEEP_FOREVER - Sleep without waking up through WDT

  204. *

  205. * 2. adc		ADC module disable control. Turning off the ADC module is

  206. *				basically removing the purpose of this low power mode.

  207. *				(a) ADC_OFF - Turn off ADC module

  208. *				(b) ADC_ON - Leave ADC module in its default state

  209. *

  210. * 3. timer2		Timer 2 module disable control:

  211. *				(a) TIMER2_OFF - Turn off Timer 2 module

  212. *				(b) TIMER2_ON - Leave Timer 2 module in its default state

  213. *

  214. *******************************************************************************/

  215. void	LowPowerClass::adcNoiseReduction(period_t period, adc_t adc, 

  216. 										 timer2_t timer2)

  217. {

  218. 	// Temporary clock source variable 

  219. 	unsigned char clockSource = 0;

  220. 	

  221. 	if (timer2 == TIMER2_OFF)

  222. 	{

  223. 		if (TCCR2B & CS22) clockSource |= (1 << CS22);

  224. 		if (TCCR2B & CS21) clockSource |= (1 << CS21);

  225. 		if (TCCR2B & CS20) clockSource |= (1 << CS20);

  226. 	

  227. 		// Remove the clock source to shutdown Timer2

  228. 		TCCR2B &= ~(1 << CS22);

  229. 		TCCR2B &= ~(1 << CS21);

  230. 		TCCR2B &= ~(1 << CS20);

  231. 	}

  232. 	

  233. 	if (adc == ADC_OFF)	ADCSRA &= ~(1 << ADEN);

  234. 	

  235. 	if (period != SLEEP_FOREVER)

  236. 	{

  237. 		wdt_enable(period);

  238. 		WDTCSR |= (1 << WDIE);	

  239. 	}

  240. 	

  241. 	lowPowerBodOn(SLEEP_MODE_ADC);

  242. 	

  243. 	if (adc == ADC_OFF) ADCSRA |= (1 << ADEN);

  244. 	

  245. 	if (timer2 == TIMER2_OFF)

  246. 	{

  247. 		if (clockSource & CS22) TCCR2B |= (1 << CS22);

  248. 		if (clockSource & CS21) TCCR2B |= (1 << CS21);

  249. 		if (clockSource & CS20) TCCR2B |= (1 << CS20);

  250. 		

  251. 	}

  252. }

  253. 

  254. /*******************************************************************************

  255. * Name: powerDown

  256. * Description: Putting microcontroller into power down state. This is

  257. *			   the lowest current consumption state. Use this together with 

  258. *			   external pin interrupt to wake up through external event 

  259. *			   triggering (example: RTC clockout pin, SD card detect pin).

  260. *

  261. * Argument  	Description

  262. * =========  	===========

  263. * 1. period     Duration of low power mode. Use SLEEP_FOREVER to use other wake

  264. *				up resource:

  265. *				(a) SLEEP_15MS - 15 ms sleep

  266. *				(b) SLEEP_30MS - 30 ms sleep

  267. *				(c) SLEEP_60MS - 60 ms sleep

  268. *				(d) SLEEP_120MS - 120 ms sleep

  269. *				(e) SLEEP_250MS - 250 ms sleep

  270. *				(f) SLEEP_500MS - 500 ms sleep

  271. *				(g) SLEEP_1S - 1 s sleep

  272. *				(h) SLEEP_2S - 2 s sleep

  273. *				(i) SLEEP_4S - 4 s sleep

  274. *				(j) SLEEP_1S - 8 s sleep

  275. *				(k) SLEEP_FOREVER - Sleep without waking up through WDT

  276. *

  277. * 2. adc		ADC module disable control. Turning off the ADC module is

  278. *				basically removing the purpose of this low power mode.

  279. *				(a) ADC_OFF - Turn off ADC module

  280. *				(b) ADC_ON - Leave ADC module in its default state

  281. *

  282. * 3. bod		Brown Out Detector (BOD) module disable control:

  283. *				(a) BOD_OFF - Turn off BOD module

  284. *				(b) BOD_ON - Leave BOD module in its default state

  285. *

  286. *******************************************************************************/

  287. void	LowPowerClass::powerDown(period_t period, adc_t adc, bod_t bod)

  288. {

  289. 	if (adc == ADC_OFF)	ADCSRA &= ~(1 << ADEN);

  290. 	

  291. 	if (period != SLEEP_FOREVER)

  292. 	{

  293. 		wdt_enable(period);

  294. 		WDTCSR |= (1 << WDIE);	

  295. 	}

  296. 	if (bod == BOD_OFF)	

  297. 	{

  298. 		lowPowerBodOff(SLEEP_MODE_PWR_DOWN);

  299. 	}

  300. 	else	

  301. 	{

  302. 		lowPowerBodOn(SLEEP_MODE_PWR_DOWN);

  303. 	}

  304. 	

  305. 	if (adc == ADC_OFF) ADCSRA |= (1 << ADEN);

  306. }

  307. 

  308. /*******************************************************************************

  309. * Name: powerSave

  310. * Description: Putting microcontroller into power save state. This is

  311. *			   the lowest current consumption state after power down. 

  312. *			   Use this state together with an external 32.768 kHz crystal (but

  313. *			   8/16 MHz crystal/resonator need to be removed) to provide an

  314. *			   asynchronous clock source to Timer 2. Please take note that 

  315. *			   Timer 2 is also used by the Arduino core for PWM operation. 

  316. *			   Please refer to wiring.c for explanation. Removal of the external

  317. *			   8/16 MHz crystal/resonator requires the microcontroller to run

  318. *			   on its internal RC oscillator which is not so accurate for time

  319. *			   critical operation.

  320. *

  321. * Argument  	Description

  322. * =========  	===========

  323. * 1. period     Duration of low power mode. Use SLEEP_FOREVER to use other wake

  324. *				up resource:

  325. *				(a) SLEEP_15MS - 15 ms sleep

  326. *				(b) SLEEP_30MS - 30 ms sleep

  327. *				(c) SLEEP_60MS - 60 ms sleep

  328. *				(d) SLEEP_120MS - 120 ms sleep

  329. *				(e) SLEEP_250MS - 250 ms sleep

  330. *				(f) SLEEP_500MS - 500 ms sleep

  331. *				(g) SLEEP_1S - 1 s sleep

  332. *				(h) SLEEP_2S - 2 s sleep

  333. *				(i) SLEEP_4S - 4 s sleep

  334. *				(j) SLEEP_1S - 8 s sleep

  335. *				(k) SLEEP_FOREVER - Sleep without waking up through WDT

  336. *

  337. * 2. adc		ADC module disable control. Turning off the ADC module is

  338. *				basically removing the purpose of this low power mode.

  339. *				(a) ADC_OFF - Turn off ADC module

  340. *				(b) ADC_ON - Leave ADC module in its default state

  341. *

  342. * 3. bod		Brown Out Detector (BOD) module disable control:

  343. *				(a) BOD_OFF - Turn off BOD module

  344. *				(b) BOD_ON - Leave BOD module in its default state

  345. *

  346. * 4. timer2		Timer 2 module disable control:

  347. *				(a) TIMER2_OFF - Turn off Timer 2 module

  348. *				(b) TIMER2_ON - Leave Timer 2 module in its default state

  349. *

  350. *******************************************************************************/

  351. void	LowPowerClass::powerSave(period_t period, adc_t adc, bod_t bod, 

  352. 							     timer2_t timer2)

  353. {

  354. 	// Temporary clock source variable 

  355. 	unsigned char clockSource = 0;

  356. 	

  357. 	if (timer2 == TIMER2_OFF)

  358. 	{

  359. 		if (TCCR2B & CS22) clockSource |= (1 << CS22);

  360. 		if (TCCR2B & CS21) clockSource |= (1 << CS21);

  361. 		if (TCCR2B & CS20) clockSource |= (1 << CS20);

  362. 	

  363. 		// Remove the clock source to shutdown Timer2

  364. 		TCCR2B &= ~(1 << CS22);

  365. 		TCCR2B &= ~(1 << CS21);

  366. 		TCCR2B &= ~(1 << CS20);

  367. 	}

  368. 	

  369. 	if (adc == ADC_OFF)	ADCSRA &= ~(1 << ADEN);

  370. 	

  371. 	if (period != SLEEP_FOREVER)

  372. 	{

  373. 		wdt_enable(period);

  374. 		WDTCSR |= (1 << WDIE);	

  375. 	}

  376. 	

  377. 	if (bod == BOD_OFF)	

  378. 	{

  379. 		lowPowerBodOff(SLEEP_MODE_PWR_SAVE);

  380. 	}

  381. 	else

  382. 	{

  383. 		lowPowerBodOn(SLEEP_MODE_PWR_SAVE);

  384. 	}

  385. 	

  386. 	if (adc == ADC_OFF) ADCSRA |= (1 << ADEN);

  387. 	

  388. 	if (timer2 == TIMER2_OFF)

  389. 	{

  390. 		if (clockSource & CS22) TCCR2B |= (1 << CS22);

  391. 		if (clockSource & CS21) TCCR2B |= (1 << CS21);

  392. 		if (clockSource & CS20) TCCR2B |= (1 << CS20);

  393. 		

  394. 	}

  395. }

  396. 

  397. /*******************************************************************************

  398. * Name: powerStandby

  399. * Description: Putting microcontroller into power standby state. 

  400. *

  401. * Argument  	Description

  402. * =========  	===========

  403. * 1. period     Duration of low power mode. Use SLEEP_FOREVER to use other wake

  404. *				up resource:

  405. *				(a) SLEEP_15MS - 15 ms sleep

  406. *				(b) SLEEP_30MS - 30 ms sleep

  407. *				(c) SLEEP_60MS - 60 ms sleep

  408. *				(d) SLEEP_120MS - 120 ms sleep

  409. *				(e) SLEEP_250MS - 250 ms sleep

  410. *				(f) SLEEP_500MS - 500 ms sleep

  411. *				(g) SLEEP_1S - 1 s sleep

  412. *				(h) SLEEP_2S - 2 s sleep

  413. *				(i) SLEEP_4S - 4 s sleep

  414. *				(j) SLEEP_1S - 8 s sleep

  415. *				(k) SLEEP_FOREVER - Sleep without waking up through WDT

  416. *

  417. * 2. adc		ADC module disable control. Turning off the ADC module is

  418. *				basically removing the purpose of this low power mode.

  419. *				(a) ADC_OFF - Turn off ADC module

  420. *				(b) ADC_ON - Leave ADC module in its default state

  421. *

  422. * 3. bod		Brown Out Detector (BOD) module disable control:

  423. *				(a) BOD_OFF - Turn off BOD module

  424. *				(b) BOD_ON - Leave BOD module in its default state

  425. *

  426. *******************************************************************************/

  427. void	LowPowerClass::powerStandby(period_t period, adc_t adc, bod_t bod)

  428. {

  429. 	if (adc == ADC_OFF)	ADCSRA &= ~(1 << ADEN);

  430. 	

  431. 	if (period != SLEEP_FOREVER)

  432. 	{

  433. 		wdt_enable(period);

  434. 		WDTCSR |= (1 << WDIE);	

  435. 	}

  436. 	

  437. 	if (bod == BOD_OFF)	

  438. 	{

  439. 		lowPowerBodOff(SLEEP_MODE_STANDBY);

  440. 	}

  441. 	else

  442. 	{

  443. 		lowPowerBodOn(SLEEP_MODE_STANDBY);

  444. 	}

  445. 	

  446. 	if (adc == ADC_OFF) ADCSRA |= (1 << ADEN);

  447. }

  448. 

  449. /*******************************************************************************

  450. * Name: powerExtStandby

  451. * Description: Putting microcontroller into power extended standby state. This 

  452. *			   is different from the power standby state as it has the 

  453. *			   capability to run Timer 2 asynchronously.

  454. *

  455. * Argument  	Description

  456. * =========  	===========

  457. * 1. period     Duration of low power mode. Use SLEEP_FOREVER to use other wake

  458. *				up resource:

  459. *				(a) SLEEP_15MS - 15 ms sleep

  460. *				(b) SLEEP_30MS - 30 ms sleep

  461. *				(c) SLEEP_60MS - 60 ms sleep

  462. *				(d) SLEEP_120MS - 120 ms sleep

  463. *				(e) SLEEP_250MS - 250 ms sleep

  464. *				(f) SLEEP_500MS - 500 ms sleep

  465. *				(g) SLEEP_1S - 1 s sleep

  466. *				(h) SLEEP_2S - 2 s sleep

  467. *				(i) SLEEP_4S - 4 s sleep

  468. *				(j) SLEEP_1S - 8 s sleep

  469. *				(k) SLEEP_FOREVER - Sleep without waking up through WDT

  470. *

  471. * 2. adc		ADC module disable control. Turning off the ADC module is

  472. *				basically removing the purpose of this low power mode.

  473. *				(a) ADC_OFF - Turn off ADC module

  474. *				(b) ADC_ON - Leave ADC module in its default state

  475. *

  476. * 3. bod		Brown Out Detector (BOD) module disable control:

  477. *				(a) BOD_OFF - Turn off BOD module

  478. *				(b) BOD_ON - Leave BOD module in its default state

  479. *

  480. * 4. timer2		Timer 2 module disable control:

  481. *				(a) TIMER2_OFF - Turn off Timer 2 module

  482. *				(b) TIMER2_ON - Leave Timer 2 module in its default state

  483. *

  484. *******************************************************************************/

  485. void	LowPowerClass::powerExtStandby(period_t period, adc_t adc, bod_t bod, 

  486. 									   timer2_t timer2)

  487. {

  488. 	// Temporary clock source variable 

  489. 	unsigned char clockSource = 0;

  490. 	

  491. 	if (timer2 == TIMER2_OFF)

  492. 	{

  493. 		if (TCCR2B & CS22) clockSource |= (1 << CS22);

  494. 		if (TCCR2B & CS21) clockSource |= (1 << CS21);

  495. 		if (TCCR2B & CS20) clockSource |= (1 << CS20);

  496. 	

  497. 		// Remove the clock source to shutdown Timer2

  498. 		TCCR2B &= ~(1 << CS22);

  499. 		TCCR2B &= ~(1 << CS21);

  500. 		TCCR2B &= ~(1 << CS20);

  501. 	}

  502. 	

  503. 	if (adc == ADC_OFF)	ADCSRA &= ~(1 << ADEN);

  504. 	

  505. 	if (period != SLEEP_FOREVER)

  506. 	{

  507. 		wdt_enable(period);

  508. 		WDTCSR |= (1 << WDIE);	

  509. 	}

  510. 	if (bod == BOD_OFF)	

  511. 	{

  512. 		lowPowerBodOff(SLEEP_MODE_EXT_STANDBY);

  513. 	}

  514. 	else	

  515. 	{

  516. 		lowPowerBodOn(SLEEP_MODE_EXT_STANDBY);

  517. 	}

  518. 		

  519. 	if (adc == ADC_OFF) ADCSRA |= (1 << ADEN);

  520. 	

  521. 	if (timer2 == TIMER2_OFF)

  522. 	{

  523. 		if (clockSource & CS22) TCCR2B |= (1 << CS22);

  524. 		if (clockSource & CS21) TCCR2B |= (1 << CS21);

  525. 		if (clockSource & CS20) TCCR2B |= (1 << CS20);	

  526. 	}

  527. }

  528. 

  529. /*******************************************************************************

  530. * Name: ISR (WDT_vect)

  531. * Description: Watchdog Timer interrupt service routine. This routine is 

  532. *		       required to allow automatic WDIF and WDIE bit clearance in 

  533. *			   hardware.

  534. *

  535. *******************************************************************************/

  536. ISR (WDT_vect)

  537. {

  538. 	// WDIE & WDIF is cleared in hardware upon entering this ISR

  539. 	wdt_disable();

  540. }

  541. 

  542. LowPowerClass LowPower;