visus
/
framework-arduinoteensy-cxx20
Прати 1
Волим 0
Креирај огранак 0
Код Дискусије 0 Захтеви за спајање 0 Издања 0 Вики Activity
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
5 Комити
1 Грана
Дрво: a7a66c2f14
framework-arduinoteensy-cxx20/libraries/FreqMeasure/util/FreqMeasureCapture.h

570 lines
13KB
Датотека Blame Историја 

  1. /* FreqMeasure Library, for measuring relatively low frequencies

  2.  * http://www.pjrc.com/teensy/td_libs_FreqMeasure.html

  3.  * Copyright (c) 2011 PJRC.COM, LLC - Paul Stoffregen <paul@pjrc.com>

  4.  *

  5.  * Permission is hereby granted, free of charge, to any person obtaining a copy

  6.  * of this software and associated documentation files (the "Software"), to deal

  7.  * in the Software without restriction, including without limitation the rights

  8.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  9.  * copies of the Software, and to permit persons to whom the Software is

  10.  * furnished to do so, subject to the following conditions:

  11.  * 

  12.  * The above copyright notice and this permission notice shall be included in

  13.  * all copies or substantial portions of the Software.

  14.  * 

  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  18.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  20.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  21.  * THE SOFTWARE.

  22.  */

  23. 

  24. #ifndef FreqMeasure_capture_h_

  25. #define FreqMeasure_capture_h_

  26. 

  27. // Arduino Uno, Duemilanove, LilyPad, Mini, Fio, etc

  28. #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)

  29.   #define CAPTURE_USE_TIMER1       // ICP1 is pin 8

  30. 

  31. // Teensy 3.1, 3.2, 3.5, 3.6

  32. #elif defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  33.   #define CAPTURE_USE_FTM1_CH0 3    // FTM1 CH0 is pin 3

  34.   //#define CAPTURE_USE_FTM1_CH1 4  // FTM1 CH1 is pin 4

  35.   //#define CAPTURE_USE_FTM2_CH0 32 // FTM2 CH0 is pin 32 (Teensy 3.1 and 3.2)

  36.   //#define CAPTURE_USE_FTM2_CH1 25 // FTM2 CH1 is pin 25 (Teensy 3.1 and 3.2)

  37.   //#define CAPTURE_USE_FTM2_CH0 29 // FTM2 CH0 is pin 29 (Teensy 3.5 and 3.6)

  38.   //#define CAPTURE_USE_FTM2_CH1 30 // FTM2 CH1 is pin 30 (Teensy 3.5 and 3.6)

  39. 

  40. // Teensy 3.0

  41. #elif defined(__MK20DX128__)

  42.   #define CAPTURE_USE_FTM1_CH0 3    // FTM1 CH0 is pin 3

  43.   //#define CAPTURE_USE_FTM1_CH1 4  // FTM1 CH1 is pin 4

  44. 

  45. // Teensy-LC

  46. #elif defined(__MKL26Z64__)

  47.   #define CAPTURE_USE_FTM1_CH0 16   // FTM1 CH0 is pin 16

  48.   //#define CAPTURE_USE_FTM1_CH1 17 // FTM1 CH1 is pin 17

  49.   //#define CAPTURE_USE_FTM2_CH0 3  // FTM2 CH0 is pin 3

  50.   //#define CAPTURE_USE_FTM2_CH1 4  // FTM2 CH1 is pin 4

  51. 

  52. #elif defined(__IMXRT1052__) || defined(__IMXRT1062__)

  53.   #define CAPTURE_USE_FLEXPWM4_CH0A 22 // FlexPWM CH0-A is pin 22

  54. 

  55. // Teensy 2.0

  56. #elif defined(__AVR_ATmega32U4__)

  57.   // #define CAPTURE_USE_TIMER1    // ICP1 is pin 22

  58.   #define CAPTURE_USE_TIMER3       // ICP3 is pin 10

  59. 

  60. // Teensy++ 1.0 & 2.0

  61. #elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)

  62.   // #define CAPTURE_USE_TIMER1    // ICP1 is pin 4

  63.   #define CAPTURE_USE_TIMER3       // ICP3 is pin 17

  64. 

  65. // Teensy 1.0

  66. #elif defined(__AVR_AT90USB162__)

  67.   #define CAPTURE_USE_TIMER1       // ICP1 is pin 16

  68. 

  69. // Sanguino

  70. #elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)

  71.   #define CAPTURE_USE_TIMER1       // ICP1 is pin 14

  72. 

  73. // Arduino Mega

  74. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)

  75.   // #define CAPTURE_USE_TIMER1    // ICP1 is not connected

  76.   // #define CAPTURE_USE_TIMER3    // ICP3 is not connected

  77.   #define CAPTURE_USE_TIMER4       // ICP4 is pin 49

  78.   // #define CAPTURE_USE_TIMER5    // ICP5 is pin 48

  79. 

  80. #else

  81.   #error "Unknown chip, please edit me with timer+counter definitions"

  82. 

  83. #endif

  84. 

  85. 

  86. 

  87. #if defined(CAPTURE_USE_FTM1_CH0)

  88. 

  89. #define FTM_SC_VALUE (FTM_SC_TOIE | FTM_SC_CLKS(1) | FTM_SC_PS(0))

  90. #define FTM_ISR_NAME ftm1_isr

  91. 

  92. static inline void capture_init(void)

  93. {

  94. 	if (FTM1_MOD != 0xFFFF || (FTM1_SC & 0x7F) != FTM_SC_VALUE) {

  95. 		FTM1_SC = 0;

  96. 		FTM1_CNT = 0;

  97. 		FTM1_MOD = 0xFFFF;

  98. 		FTM1_SC = FTM_SC_VALUE;

  99. 		#ifdef KINETISK

  100. 		FTM1_MODE = 0;

  101. 		#endif

  102. 	}

  103. 	NVIC_SET_PRIORITY(IRQ_FTM1, 48);

  104. }

  105. static inline void capture_start(void)

  106. {

  107. 	#if defined(KINETISL)

  108. 	FTM1_C0SC = 0;

  109. 	delayMicroseconds(1);

  110. 	#endif

  111. 	FTM1_C0SC = 0b01000100;

  112. 	*portConfigRegister(CAPTURE_USE_FTM1_CH0) = PORT_PCR_MUX(3);

  113. 	NVIC_ENABLE_IRQ(IRQ_FTM1);

  114. }

  115. static inline uint16_t capture_event(void)

  116. {

  117. 	return (FTM1_C0SC & 0x80) ? 1 : 0;

  118. }

  119. static inline uint32_t capture_read(void)

  120. {

  121. 	uint32_t val = FTM1_C0V;

  122. 	#if defined(KINETISK)

  123. 	FTM1_C0SC = 0b01000100;

  124. 	#elif defined(KINETISL)

  125. 	FTM1_C0SC = 0b01000100 | FTM_CSC_CHF;

  126. 	#endif

  127. 	return val;

  128. }

  129. static inline uint8_t capture_overflow(void)

  130. {

  131. 	return (FTM1_SC & FTM_SC_TOF) ? 1 : 0;

  132. }

  133. static inline void capture_overflow_reset(void)

  134. {

  135. 	#if defined(KINETISK)

  136. 	FTM1_SC = FTM_SC_VALUE;

  137. 	#elif defined(KINETISL)

  138. 	FTM1_SC = FTM_SC_VALUE | FTM_SC_TOF;

  139. 	#endif

  140. }

  141. static inline void capture_shutdown(void)

  142. {

  143. 	FTM1_C0SC = 0;

  144. 	*portConfigRegister(CAPTURE_USE_FTM1_CH0) = 0;

  145. 	NVIC_DISABLE_IRQ(IRQ_FTM1);

  146. }

  147. 

  148. 

  149. #elif defined(CAPTURE_USE_FTM1_CH1)

  150. 

  151. #define FTM_SC_VALUE (FTM_SC_TOIE | FTM_SC_CLKS(1) | FTM_SC_PS(0))

  152. #define FTM_ISR_NAME ftm1_isr

  153. 

  154. static inline void capture_init(void)

  155. {

  156. 	if (FTM1_MOD != 0xFFFF || (FTM1_SC & 0x7F) != FTM_SC_VALUE) {

  157. 		FTM1_SC = 0;

  158. 		FTM1_CNT = 0;

  159. 		FTM1_MOD = 0xFFFF;

  160. 		FTM1_SC = FTM_SC_VALUE;

  161. 		#ifdef KINETISK

  162. 		FTM1_MODE = 0;

  163. 		#endif

  164. 	}

  165. 	NVIC_SET_PRIORITY(IRQ_FTM1, 48);

  166. }

  167. static inline void capture_start(void)

  168. {

  169. 	#if defined(KINETISL)

  170. 	FTM1_C1SC = 0;

  171. 	delayMicroseconds(1);

  172. 	#endif

  173. 	FTM1_C1SC = 0b01000100;

  174. 	*portConfigRegister(CAPTURE_USE_FTM1_CH1) = PORT_PCR_MUX(3);

  175. 	NVIC_ENABLE_IRQ(IRQ_FTM1);

  176. }

  177. static inline uint16_t capture_event(void)

  178. {

  179. 	return (FTM1_C1SC & 0x80) ? 1 : 0;

  180. }

  181. static inline uint32_t capture_read(void)

  182. {

  183. 	uint32_t val = FTM1_C1V;

  184. 	#if defined(KINETISK)

  185. 	FTM1_C1SC = 0b01000100;

  186. 	#elif defined(KINETISL)

  187. 	FTM1_C1SC = 0b01000100 | FTM_CSC_CHF;

  188. 	#endif

  189. 	return val;

  190. }

  191. static inline uint8_t capture_overflow(void)

  192. {

  193. 	return (FTM1_SC & FTM_SC_TOF) ? 1 : 0;

  194. }

  195. static inline void capture_overflow_reset(void)

  196. {

  197. 	FTM1_SC = FTM_SC_VALUE;

  198. 	#if defined(KINETISK)

  199. 	FTM1_SC = FTM_SC_VALUE;

  200. 	#elif defined(KINETISL)

  201. 	FTM1_SC = FTM_SC_VALUE | FTM_SC_TOF;

  202. 	#endif

  203. }

  204. static inline void capture_shutdown(void)

  205. {

  206. 	FTM1_C1SC = 0;

  207. 	*portConfigRegister(CAPTURE_USE_FTM1_CH1) = 0;

  208. 	NVIC_DISABLE_IRQ(IRQ_FTM1);

  209. }

  210. 

  211. 

  212. #elif defined(CAPTURE_USE_FTM2_CH0)

  213. 

  214. #define FTM_SC_VALUE (FTM_SC_TOIE | FTM_SC_CLKS(1) | FTM_SC_PS(0))

  215. #define FTM_ISR_NAME ftm2_isr

  216. 

  217. static inline void capture_init(void)

  218. {

  219. 	if (FTM2_MOD != 0xFFFF || (FTM2_SC & 0x7F) != FTM_SC_VALUE) {

  220. 		FTM2_SC = 0;

  221. 		FTM2_CNT = 0;

  222. 		FTM2_MOD = 0xFFFF;

  223. 		FTM2_SC = FTM_SC_VALUE;

  224. 		#ifdef KINETISK

  225. 		FTM2_MODE = 0;

  226. 		#endif

  227. 	}

  228. 	NVIC_SET_PRIORITY(IRQ_FTM2, 48);

  229. }

  230. static inline void capture_start(void)

  231. {

  232. 	#if defined(KINETISL)

  233. 	FTM2_C0SC = 0;

  234. 	delayMicroseconds(1);

  235. 	#endif

  236. 	FTM2_C0SC = 0b01000100;

  237. 	*portConfigRegister(CAPTURE_USE_FTM2_CH0) = PORT_PCR_MUX(3);

  238. 	NVIC_ENABLE_IRQ(IRQ_FTM2);

  239. }

  240. static inline uint16_t capture_event(void)

  241. {

  242. 	return (FTM2_C0SC & 0x80) ? 1 : 0;

  243. }

  244. static inline uint32_t capture_read(void)

  245. {

  246. 	uint32_t val = FTM2_C0V;

  247. 	#if defined(KINETISK)

  248. 	FTM2_C0SC = 0b01000100;

  249. 	#elif defined(KINETISL)

  250. 	FTM2_C0SC = 0b01000100 | FTM_CSC_CHF;

  251. 	#endif

  252. 	return val;

  253. }

  254. static inline uint8_t capture_overflow(void)

  255. {

  256. 	return (FTM2_SC & FTM_SC_TOF) ? 1 : 0;

  257. }

  258. static inline void capture_overflow_reset(void)

  259. {

  260. 	#if defined(KINETISK)

  261. 	FTM2_SC = FTM_SC_VALUE;

  262. 	#elif defined(KINETISL)

  263. 	FTM2_SC = FTM_SC_VALUE | FTM_SC_TOF;

  264. 	#endif

  265. }

  266. static inline void capture_shutdown(void)

  267. {

  268. 	FTM2_C0SC = 0;

  269. 	*portConfigRegister(CAPTURE_USE_FTM2_CH0) = 0;

  270. 	NVIC_DISABLE_IRQ(IRQ_FTM2);

  271. }

  272. 

  273. 

  274. #elif defined(CAPTURE_USE_FTM2_CH1)

  275. 

  276. #define FTM_SC_VALUE (FTM_SC_TOIE | FTM_SC_CLKS(1) | FTM_SC_PS(0))

  277. #define FTM_ISR_NAME ftm2_isr

  278. 

  279. static inline void capture_init(void)

  280. {

  281. 	if (FTM2_MOD != 0xFFFF || (FTM2_SC & 0x7F) != FTM_SC_VALUE) {

  282. 		FTM2_SC = 0;

  283. 		FTM2_CNT = 0;

  284. 		FTM2_MOD = 0xFFFF;

  285. 		FTM2_SC = FTM_SC_VALUE;

  286. 		#ifdef KINETISK

  287. 		FTM2_MODE = 0;

  288. 		#endif

  289. 	}

  290. 	NVIC_SET_PRIORITY(IRQ_FTM2, 48);

  291. }

  292. static inline void capture_start(void)

  293. {

  294. 	#if defined(KINETISL)

  295. 	FTM2_C1SC = 0;

  296. 	delayMicroseconds(1);

  297. 	#endif

  298. 	FTM2_C1SC = 0b01000100;

  299. 	*portConfigRegister(CAPTURE_USE_FTM2_CH1) = PORT_PCR_MUX(3);

  300. 	NVIC_ENABLE_IRQ(IRQ_FTM2);

  301. }

  302. static inline uint16_t capture_event(void)

  303. {

  304. 	return (FTM2_C1SC & 0x80) ? 1 : 0;

  305. }

  306. static inline uint32_t capture_read(void)

  307. {

  308. 	uint32_t val = FTM2_C1V;

  309. 	#if defined(KINETISK)

  310. 	FTM2_C1SC = 0b01000100;

  311. 	#elif defined(KINETISL)

  312. 	FTM2_C1SC = 0b01000100 | FTM_CSC_CHF;

  313. 	#endif

  314. 	return val;

  315. }

  316. static inline uint8_t capture_overflow(void)

  317. {

  318. 	return (FTM2_SC & FTM_SC_TOF) ? 1 : 0;

  319. }

  320. static inline void capture_overflow_reset(void)

  321. {

  322. 	#if defined(KINETISK)

  323. 	FTM2_SC = FTM_SC_VALUE;

  324. 	#elif defined(KINETISL)

  325. 	FTM2_SC = FTM_SC_VALUE | FTM_SC_TOF;

  326. 	#endif

  327. }

  328. static inline void capture_shutdown(void)

  329. {

  330. 	FTM2_C1SC = 0;

  331. 	*portConfigRegister(CAPTURE_USE_FTM2_CH1) = 0;

  332. 	NVIC_DISABLE_IRQ(IRQ_FTM2);

  333. }

  334. 

  335. #elif defined(CAPTURE_USE_FLEXPWM4_CH0A)

  336. 

  337. #define FTM_ISR_NAME flexpwm_4_0_isr

  338. void flexpwm_4_0_isr(void);

  339. 

  340. static inline void capture_init(void)

  341. {

  342. 	FLEXPWM4_FCTRL0 |= FLEXPWM_FCTRL0_FLVL(1);

  343. 	FLEXPWM4_FSTS0 = 0x0001;

  344. 	FLEXPWM4_MCTRL |= FLEXPWM_MCTRL_CLDOK(1);

  345. 	FLEXPWM4_SM0CTRL2 = FLEXPWM_SMCTRL2_INDEP;

  346. 	FLEXPWM4_SM0CTRL = FLEXPWM_SMCTRL_HALF;

  347. 	FLEXPWM4_SM0INIT = 0;

  348. 	FLEXPWM4_SM0VAL0 = 0;

  349. 	FLEXPWM4_SM0VAL1 = 65535;

  350. 	FLEXPWM4_SM0VAL2 = 0;

  351. 	FLEXPWM4_SM0VAL3 = 0;

  352. 	FLEXPWM4_SM0VAL4 = 0;

  353. 	FLEXPWM4_SM0VAL5 = 0;

  354. 	FLEXPWM4_MCTRL |= FLEXPWM_MCTRL_LDOK(1) | FLEXPWM_MCTRL_RUN(1);

  355. 	attachInterruptVector(IRQ_FLEXPWM4_0, flexpwm_4_0_isr);

  356. 	NVIC_SET_PRIORITY(IRQ_FLEXPWM4_0, 48);

  357. 	FLEXPWM4_SM0INTEN = FLEXPWM_SMINTEN_CA0IE | FLEXPWM_SMINTEN_RIE;

  358. }

  359. static inline void capture_start(void)

  360. {

  361. 	FLEXPWM4_SM0CAPTCTRLA = FLEXPWM_SMCAPTCTRLA_EDGA0(2) | FLEXPWM_SMCAPTCTRLA_ARMA;

  362. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_AD_B1_08 = 1 | 0x10; // pin 22, AD_B1_08, FLEXPWM4_PWM0_A

  363. 	IOMUXC_FLEXPWM4_PWMA0_SELECT_INPUT = 1;

  364. 	FLEXPWM4_SM0STS = FLEXPWM_SMSTS_CFA0 | FLEXPWM_SMSTS_RF;

  365. 	NVIC_ENABLE_IRQ(IRQ_FLEXPWM4_0);

  366. }

  367. static inline uint16_t capture_event(void)

  368. {

  369. 	return (FLEXPWM4_SM0STS & FLEXPWM_SMSTS_CFA0) ? 1 : 0;

  370. }

  371. static inline uint32_t capture_read(void)

  372. {

  373. 	uint32_t val = FLEXPWM4_SM0CVAL2;

  374. 	FLEXPWM4_SM0STS = FLEXPWM_SMSTS_CFA0;

  375. 	return val;

  376. }

  377. static inline uint8_t capture_overflow(void)

  378. {

  379. 	return (FLEXPWM4_SM0STS & FLEXPWM_SMSTS_RF) ? 1 : 0;

  380. }

  381. static inline void capture_overflow_reset(void)

  382. {

  383. 	FLEXPWM4_SM0STS = FLEXPWM_SMSTS_RF;

  384. }

  385. static inline void capture_shutdown(void)

  386. {

  387. 	FLEXPWM4_SM0INTEN = 0;

  388. 	FLEXPWM4_SM0CAPTCTRLA = 0;

  389. 	IOMUXC_SW_MUX_CTL_PAD_GPIO_AD_B1_08 = 5 | 0x10;

  390. 	NVIC_DISABLE_IRQ(IRQ_FLEXPWM4_0);

  391. }

  392. 

  393. #elif defined(CAPTURE_USE_TIMER1)

  394. 

  395. static uint8_t saveTCCR1A, saveTCCR1B;

  396. 

  397. static inline void capture_init(void)

  398. {

  399. 	saveTCCR1A = TCCR1A;

  400. 	saveTCCR1B = TCCR1B;

  401. 	TCCR1B = 0;

  402. 	TCCR1A = 0;

  403. 	TCNT1 = 0;

  404. 	TIFR1 = (1<<ICF1) | (1<<TOV1);

  405. 	TIMSK1 = (1<<ICIE1) | (1<<TOIE1);

  406. }

  407. static inline void capture_start(void)

  408. {

  409. 	TCCR1B = (1<<ICNC1) | (1<<ICES1) | (1<<CS10);

  410. }

  411. static inline uint16_t capture_read(void)

  412. {

  413. 	return ICR1;

  414. }

  415. static inline uint8_t capture_overflow(void)

  416. {

  417. 	return TIFR1 & (1<<TOV1);

  418. }

  419. static inline void capture_overflow_reset(void)

  420. {

  421. 	TIFR1 = (1<<TOV1);

  422. }

  423. static inline void capture_shutdown(void)

  424. {

  425. 	TCCR1B = 0;

  426. 	TIMSK1 = 0;

  427. 	TCCR1A = saveTCCR1A;

  428. 	TCCR1B = saveTCCR1B;

  429. }

  430. 

  431. 

  432. #define TIMER_OVERFLOW_VECTOR  TIMER1_OVF_vect

  433. #define TIMER_CAPTURE_VECTOR   TIMER1_CAPT_vect 

  434. 

  435. 

  436. #elif defined(CAPTURE_USE_TIMER3)

  437. 

  438. static uint8_t saveTCCR3A, saveTCCR3B;

  439. 

  440. static inline void capture_init(void)

  441. {

  442. 	saveTCCR3A = TCCR3A;

  443. 	saveTCCR3B = TCCR3B;

  444. 	TCCR3B = 0;

  445. 	TCCR3A = 0;

  446. 	TCNT3 = 0;

  447. 	TIFR3 = (1<<ICF3) | (1<<TOV3);

  448. 	TIMSK3 = (1<<ICIE3) | (1<<TOIE3);

  449. }

  450. static inline void capture_start(void)

  451. {

  452. 	TCCR3B = (1<<ICNC3) | (1<<ICES3) | (1<<CS30);

  453. }

  454. static inline uint16_t capture_read(void)

  455. {

  456. 	return ICR3;

  457. }

  458. static inline uint8_t capture_overflow(void)

  459. {

  460. 	return TIFR3 & (1<<TOV3);

  461. }

  462. static inline void capture_overflow_reset(void)

  463. {

  464. 	TIFR3 = (1<<TOV3);

  465. }

  466. static inline void capture_shutdown(void)

  467. {

  468. 	TCCR3B = 0;

  469. 	TIMSK3 = 0;

  470. 	TCCR3A = saveTCCR3A;

  471. 	TCCR3B = saveTCCR3B;

  472. }

  473. 

  474. #define TIMER_OVERFLOW_VECTOR  TIMER3_OVF_vect

  475. #define TIMER_CAPTURE_VECTOR   TIMER3_CAPT_vect 

  476. 

  477. 

  478. 

  479. #elif defined(CAPTURE_USE_TIMER4)

  480. 

  481. static uint8_t saveTCCR4A, saveTCCR4B;

  482. 

  483. static inline void capture_init(void)

  484. {

  485. 	saveTCCR4A = TCCR4A;

  486. 	saveTCCR4B = TCCR4B;

  487. 	TCCR4B = 0;

  488. 	TCCR4A = 0;

  489. 	TCNT4 = 0;

  490. 	TIFR4 = (1<<ICF4) | (1<<TOV4);

  491. 	TIMSK4 = (1<<ICIE4) | (1<<TOIE4);

  492. }

  493. static inline void capture_start(void)

  494. {

  495. 	TCCR4B = (1<<ICNC4) | (1<<ICES4) | (1<<CS40);

  496. }

  497. static inline uint16_t capture_read(void)

  498. {

  499. 	return ICR4;

  500. }

  501. static inline uint8_t capture_overflow(void)

  502. {

  503. 	return TIFR4 & (1<<TOV4);

  504. }

  505. static inline void capture_overflow_reset(void)

  506. {

  507. 	TIFR4 = (1<<TOV4);

  508. }

  509. static inline void capture_shutdown(void)

  510. {

  511. 	TCCR4B = 0;

  512. 	TIMSK4 = 0;

  513. 	TCCR4A = saveTCCR4A;

  514. 	TCCR4B = saveTCCR4B;

  515. }

  516. 

  517. #define TIMER_OVERFLOW_VECTOR  TIMER4_OVF_vect

  518. #define TIMER_CAPTURE_VECTOR   TIMER4_CAPT_vect 

  519. 

  520. 

  521. 

  522. #elif defined(CAPTURE_USE_TIMER5)

  523. 

  524. static uint8_t saveTCCR5A, saveTCCR5B;

  525. 

  526. static inline void capture_init(void)

  527. {

  528. 	saveTCCR5A = TCCR5A;

  529. 	saveTCCR5B = TCCR5B;

  530. 	TCCR5B = 0;

  531. 	TCCR5A = 0;

  532. 	TCNT5 = 0;

  533. 	TIFR5 = (1<<ICF5) | (1<<TOV5);

  534. 	TIMSK5 = (1<<ICIE5) | (1<<TOIE5);

  535. }

  536. static inline void capture_start(void)

  537. {

  538. 	TCCR5B = (1<<ICNC5) | (1<<ICES5) | (1<<CS50);

  539. }

  540. static inline uint16_t capture_read(void)

  541. {

  542. 	return ICR5;

  543. }

  544. static inline uint8_t capture_overflow(void)

  545. {

  546. 	return TIFR5 & (1<<TOV5);

  547. }

  548. static inline void capture_overflow_reset(void)

  549. {

  550. 	TIFR5 = (1<<TOV5);

  551. }

  552. static inline void capture_shutdown(void)

  553. {

  554. 	TCCR5B = 0;

  555. 	TIMSK5 = 0;

  556. 	TCCR5A = saveTCCR5A;

  557. 	TCCR5B = saveTCCR5B;

  558. }

  559. 

  560. #define TIMER_OVERFLOW_VECTOR  TIMER5_OVF_vect

  561. #define TIMER_CAPTURE_VECTOR   TIMER5_CAPT_vect 

  562. 

  563. 

  564. 

  565. 

  566. #endif // CAPTURE_USE_***

  567. 

  568. 

  569. #endif