visus
/
teensy-irremote
Suivre 1
Ajouter aux favoris 0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
2 Révisions
1 Branche
Aborescence: b233694e2d
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de 'b233694e2d'
${ noResults }
teensy-irremote/include/irr/boarddefs.h

662 lines
23KB
Brut Annotations Historique 

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

  2. // IRremote

  3. // Version 2.0.1 June, 2015

  4. // Copyright 2009 Ken Shirriff

  5. // For details, see http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.html

  6. 

  7. // This file contains all board specific information. It was previously contained within

  8. // IRremoteInt.h

  9. 

  10. // Modified by Paul Stoffregen <paul@pjrc.com> to support other boards and timers

  11. //

  12. // Interrupt code based on NECIRrcv by Joe Knapp

  13. // http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1210243556

  14. // Also influenced by http://zovirl.com/2008/11/12/building-a-universal-remote-with-an-arduino/

  15. //

  16. // JVC and Panasonic protocol added by Kristian Lauszus (Thanks to zenwheel and other people at the original blog post)

  17. // Whynter A/C ARC-110WD added by Francesco Meschia

  18. 

  19. // Sparkfun Pro Micro support by Alastair McCormack

  20. //******************************************************************************

  21. 

  22. #ifndef boarddefs_h

  23. #define boarddefs_h

  24. 

  25. //------------------------------------------------------------------------------

  26. // Defines for blinking the LED

  27. //

  28. 

  29. #if defined(CORE_LED0_PIN)

  30. #	define BLINKLED        CORE_LED0_PIN

  31. #	define BLINKLED_ON()   (digitalWrite(CORE_LED0_PIN, HIGH))

  32. #	define BLINKLED_OFF()  (digitalWrite(CORE_LED0_PIN, LOW))

  33. 

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

  35. #	define BLINKLED        13

  36. #	define BLINKLED_ON()   (PORTB |= B10000000)

  37. #	define BLINKLED_OFF()  (PORTB &= B01111111)

  38. 

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

  40. #	define BLINKLED        0

  41. #	define BLINKLED_ON()   (PORTD |= B00000001)

  42. #	define BLINKLED_OFF()  (PORTD &= B11111110)

  43. 

  44. // No system LED on ESP32, disable blinking

  45. #elif defined(ESP32)

  46. #	define BLINKLED        255

  47. #	define BLINKLED_ON()   1

  48. #	define BLINKLED_OFF()  1

  49. #else

  50. #	define BLINKLED        13

  51. #	define BLINKLED_ON()  (PORTB |= B00100000)

  52. #	define BLINKLED_OFF()  (PORTB &= B11011111)

  53. #endif

  54. 

  55. //------------------------------------------------------------------------------

  56. // CPU Frequency

  57. //

  58. #ifdef F_CPU

  59. #	define SYSCLOCK  F_CPU     // main Arduino clock

  60. #else

  61. #	define SYSCLOCK  16000000  // main Arduino clock

  62. #endif

  63. 

  64. // microseconds per clock interrupt tick

  65. #define USECPERTICK    50

  66. 

  67. //------------------------------------------------------------------------------

  68. // Define which timer to use

  69. //

  70. // Uncomment the timer you wish to use on your board.

  71. // If you are using another library which uses timer2, you have options to

  72. //   switch IRremote to use a different timer.

  73. //

  74. 

  75. // Sparkfun Pro Micro

  76. #if defined(ARDUINO_AVR_PROMICRO)

  77. 	//#define IR_USE_TIMER1     // tx = pin 9

  78. 	#define IR_USE_TIMER3       // tx = pin 5

  79. 	//#define IR_USE_TIMER4_HS  // tx = pin 5

  80. 

  81. // Arduino Mega

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

  83. 	//#define IR_USE_TIMER1   // tx = pin 11

  84. 	#define IR_USE_TIMER2     // tx = pin 9

  85. 	//#define IR_USE_TIMER3   // tx = pin 5

  86. 	//#define IR_USE_TIMER4   // tx = pin 6

  87. 	//#define IR_USE_TIMER5   // tx = pin 46

  88. 

  89. // Teensy 1.0

  90. #elif defined(__AVR_AT90USB162__)

  91. 	#define IR_USE_TIMER1     // tx = pin 17

  92. 

  93. // Teensy 2.0

  94. #elif defined(__AVR_ATmega32U4__)

  95. 	//#define IR_USE_TIMER1   // tx = pin 14

  96. 	//#define IR_USE_TIMER3   // tx = pin 9

  97. 	#define IR_USE_TIMER4_HS  // tx = pin 10

  98. 

  99. // Teensy 3.0 / Teensy 3.1

  100. #elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  101. 	#define IR_USE_TIMER_CMT  // tx = pin 5

  102. 

  103. // Teensy-LC

  104. #elif defined(__MKL26Z64__)

  105.   #define IR_USE_TIMER_TPM1 // tx = pin 16

  106. 

  107. // Teensy 4

  108. #elif defined(__IMXRT1062__)

  109.   #define IR_USE_TIMER_FLEXPWM1 // tx = pin 8

  110. 

  111. // Teensy++ 1.0 & 2.0

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

  113. 	//#define IR_USE_TIMER1   // tx = pin 25

  114. 	#define IR_USE_TIMER2     // tx = pin 1

  115. 	//#define IR_USE_TIMER3   // tx = pin 16

  116. 

  117. // MightyCore - ATmega1284

  118. #elif defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)

  119. 	//#define IR_USE_TIMER1   // tx = pin 13

  120. 	#define IR_USE_TIMER2     // tx = pin 14

  121. 	//#define IR_USE_TIMER3   // tx = pin 6

  122. 

  123. // MightyCore - ATmega164, ATmega324, ATmega644

  124. #elif defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) \

  125. || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega324A__) \

  126. || defined(__AVR_ATmega324PA__) || defined(__AVR_ATmega164A__) \

  127. || defined(__AVR_ATmega164P__)

  128. 	//#define IR_USE_TIMER1   // tx = pin 13

  129. 	#define IR_USE_TIMER2     // tx = pin 14

  130. 	

  131. //MegaCore - ATmega64, ATmega128

  132. #elif defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__)

  133.  	#define IR_USE_TIMER1     // tx = pin 13

  134. 

  135. // MightyCore - ATmega8535, ATmega16, ATmega32

  136. #elif defined(__AVR_ATmega8535__) || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__)

  137.  	#define IR_USE_TIMER1     // tx = pin 13

  138. 

  139. // Atmega8

  140. #elif defined(__AVR_ATmega8__)

  141. 	#define IR_USE_TIMER1     // tx = pin 9

  142. 

  143. // ATtiny84

  144. #elif defined(__AVR_ATtiny84__)

  145. 	#define IR_USE_TIMER1     // tx = pin 6

  146. 

  147. //ATtiny85

  148. #elif defined(__AVR_ATtiny85__)

  149. 	#define IR_USE_TIMER_TINY0   // tx = pin 1

  150. 

  151. #elif defined(ESP32)

  152. 	#define IR_TIMER_USE_ESP32

  153. #else

  154. // Arduino Duemilanove, Diecimila, LilyPad, Mini, Fio, Nano, etc

  155. // ATmega48, ATmega88, ATmega168, ATmega328

  156. 	//#define IR_USE_TIMER1   // tx = pin 9

  157. 	#define IR_USE_TIMER2     // tx = pin 3

  158. 

  159. #endif

  160. 

  161. //------------------------------------------------------------------------------

  162. // Defines for Timer

  163. 

  164. //---------------------------------------------------------

  165. // Timer2 (8 bits)

  166. //

  167. #if defined(IR_USE_TIMER2)

  168. 

  169. #define TIMER_RESET

  170. #define TIMER_ENABLE_PWM    (TCCR2A |= _BV(COM2B1))

  171. #define TIMER_DISABLE_PWM   (TCCR2A &= ~(_BV(COM2B1)))

  172. #define TIMER_ENABLE_INTR   (TIMSK2 = _BV(OCIE2A))

  173. #define TIMER_DISABLE_INTR  (TIMSK2 = 0)

  174. #define TIMER_INTR_NAME     TIMER2_COMPA_vect

  175. 

  176. #define TIMER_CONFIG_KHZ(val) ({ \

  177. 	const uint8_t pwmval = SYSCLOCK / 2000 / (val); \

  178. 	TCCR2A               = _BV(WGM20); \

  179. 	TCCR2B               = _BV(WGM22) | _BV(CS20); \

  180. 	OCR2A                = pwmval; \

  181. 	OCR2B                = pwmval / 3; \

  182. })

  183. 

  184. #define TIMER_COUNT_TOP  (SYSCLOCK * USECPERTICK / 1000000)

  185. 

  186. //-----------------

  187. #if (TIMER_COUNT_TOP < 256)

  188. #	define TIMER_CONFIG_NORMAL() ({ \

  189. 		TCCR2A = _BV(WGM21); \

  190. 		TCCR2B = _BV(CS20); \

  191. 		OCR2A  = TIMER_COUNT_TOP; \

  192. 		TCNT2  = 0; \

  193. 	})

  194. #else

  195. #	define TIMER_CONFIG_NORMAL() ({ \

  196. 		TCCR2A = _BV(WGM21); \

  197. 		TCCR2B = _BV(CS21); \

  198. 		OCR2A  = TIMER_COUNT_TOP / 8; \

  199. 		TCNT2  = 0; \

  200. 	})

  201. #endif

  202. 

  203. //-----------------

  204. #if defined(CORE_OC2B_PIN)

  205. #	define TIMER_PWM_PIN  CORE_OC2B_PIN  // Teensy

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

  207. #	define TIMER_PWM_PIN  9              // Arduino Mega

  208. #elif defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__) \

  209. || defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) \

  210. || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega324A__) \

  211. || defined(__AVR_ATmega324PA__) || defined(__AVR_ATmega164A__) \

  212. || defined(__AVR_ATmega164P__)

  213. #	define TIMER_PWM_PIN  14             // MightyCore

  214. #else

  215. #	define TIMER_PWM_PIN  3              // Arduino Duemilanove, Diecimila, LilyPad, etc

  216. #endif					     // ATmega48, ATmega88, ATmega168, ATmega328

  217. 

  218. //---------------------------------------------------------

  219. // Timer1 (16 bits)

  220. //

  221. #elif defined(IR_USE_TIMER1)

  222. 

  223. #define TIMER_RESET

  224. #define TIMER_ENABLE_PWM   (TCCR1A |= _BV(COM1A1))

  225. #define TIMER_DISABLE_PWM  (TCCR1A &= ~(_BV(COM1A1)))

  226. 

  227. //-----------------

  228. #if defined(__AVR_ATmega8__) || defined(__AVR_ATmega8535__) \

  229. || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \

  230. || defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__)

  231. #	define TIMER_ENABLE_INTR   (TIMSK |= _BV(OCIE1A))

  232. #	define TIMER_DISABLE_INTR  (TIMSK &= ~_BV(OCIE1A))

  233. #else

  234. #	define TIMER_ENABLE_INTR   (TIMSK1 = _BV(OCIE1A))

  235. #	define TIMER_DISABLE_INTR  (TIMSK1 = 0)

  236. #endif

  237. 

  238. //-----------------

  239. #define TIMER_INTR_NAME       TIMER1_COMPA_vect

  240. 

  241. #define TIMER_CONFIG_KHZ(val) ({ \

  242. 	const uint16_t pwmval = SYSCLOCK / 2000 / (val); \

  243. 	TCCR1A                = _BV(WGM11); \

  244. 	TCCR1B                = _BV(WGM13) | _BV(CS10); \

  245. 	ICR1                  = pwmval; \

  246. 	OCR1A                 = pwmval / 3; \

  247. })

  248. 

  249. #define TIMER_CONFIG_NORMAL() ({ \

  250. 	TCCR1A = 0; \

  251. 	TCCR1B = _BV(WGM12) | _BV(CS10); \

  252. 	OCR1A  = SYSCLOCK * USECPERTICK / 1000000; \

  253. 	TCNT1  = 0; \

  254. })

  255. 

  256. //-----------------

  257. #if defined(CORE_OC1A_PIN)

  258. #	define TIMER_PWM_PIN  CORE_OC1A_PIN  // Teensy

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

  260. #	define TIMER_PWM_PIN  11             // Arduino Mega

  261. #elif defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__) \

  262. || defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) \

  263. || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega324A__) \

  264. || defined(__AVR_ATmega324PA__) || defined(__AVR_ATmega164A__) \

  265. || defined(__AVR_ATmega164P__) || defined(__AVR_ATmega32__) \

  266. || defined(__AVR_ATmega16__) || defined(__AVR_ATmega8535__) \

  267. || defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__)

  268. #	define TIMER_PWM_PIN  13             // MightyCore, MegaCore

  269. #elif defined(__AVR_ATtiny84__)

  270. # 	define TIMER_PWM_PIN  6

  271. #else

  272. #	define TIMER_PWM_PIN  9              // Arduino Duemilanove, Diecimila, LilyPad, Sparkfun Pro Micro etc

  273. #endif					     // ATmega48, ATmega88, ATmega168, ATmega328

  274. 

  275. //---------------------------------------------------------

  276. // Timer3 (16 bits)

  277. //

  278. #elif defined(IR_USE_TIMER3)

  279. 

  280. #define TIMER_RESET

  281. #define TIMER_ENABLE_PWM     (TCCR3A |= _BV(COM3A1))

  282. #define TIMER_DISABLE_PWM    (TCCR3A &= ~(_BV(COM3A1)))

  283. #define TIMER_ENABLE_INTR    (TIMSK3 = _BV(OCIE3A))

  284. #define TIMER_DISABLE_INTR   (TIMSK3 = 0)

  285. #define TIMER_INTR_NAME      TIMER3_COMPA_vect

  286. 

  287. #define TIMER_CONFIG_KHZ(val) ({ \

  288.   const uint16_t pwmval = SYSCLOCK / 2000 / (val); \

  289.   TCCR3A = _BV(WGM31); \

  290.   TCCR3B = _BV(WGM33) | _BV(CS30); \

  291.   ICR3 = pwmval; \

  292.   OCR3A = pwmval / 3; \

  293. })

  294. 

  295. #define TIMER_CONFIG_NORMAL() ({ \

  296.   TCCR3A = 0; \

  297.   TCCR3B = _BV(WGM32) | _BV(CS30); \

  298.   OCR3A = SYSCLOCK * USECPERTICK / 1000000; \

  299.   TCNT3 = 0; \

  300. })

  301. 

  302. //-----------------

  303. #if defined(CORE_OC3A_PIN)

  304. #	define TIMER_PWM_PIN  CORE_OC3A_PIN  // Teensy

  305. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) || defined(ARDUINO_AVR_PROMICRO)

  306. #	define TIMER_PWM_PIN  5              // Arduino Mega, Sparkfun Pro Micro

  307. #elif defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)

  308. #	define TIMER_PWM_PIN  6              // MightyCore

  309. #else

  310. #	error "Please add OC3A pin number here\n"

  311. #endif

  312. 

  313. //---------------------------------------------------------

  314. // Timer4 (10 bits, high speed option)

  315. //

  316. #elif defined(IR_USE_TIMER4_HS)

  317. 

  318. #define TIMER_RESET

  319. 

  320. #if defined(ARDUINO_AVR_PROMICRO) // Sparkfun Pro Micro                         

  321. 	#define TIMER_ENABLE_PWM    (TCCR4A |= _BV(COM4A0))     // Use complimentary O̅C̅4̅A̅ output on pin 5

  322. 	#define TIMER_DISABLE_PWM   (TCCR4A &= ~(_BV(COM4A0)))  // (Pro Micro does not map PC7 (32/ICP3/CLK0/OC4A)

  323. 															// of ATmega32U4 )

  324. #else

  325. 	#define TIMER_ENABLE_PWM    (TCCR4A |= _BV(COM4A1))

  326. 	#define TIMER_DISABLE_PWM   (TCCR4A &= ~(_BV(COM4A1)))

  327. #endif

  328. 

  329. #define TIMER_ENABLE_INTR   (TIMSK4 = _BV(TOIE4))

  330. #define TIMER_DISABLE_INTR  (TIMSK4 = 0)

  331. #define TIMER_INTR_NAME     TIMER4_OVF_vect

  332. 

  333. 

  334. #define TIMER_CONFIG_KHZ(val) ({ \

  335. 	const uint16_t pwmval = SYSCLOCK / 2000 / (val); \

  336. 	TCCR4A                = (1<<PWM4A); \

  337. 	TCCR4B                = _BV(CS40); \

  338. 	TCCR4C                = 0; \

  339. 	TCCR4D                = (1<<WGM40); \

  340. 	TCCR4E                = 0; \

  341. 	TC4H                  = pwmval >> 8; \

  342. 	OCR4C                 = pwmval; \

  343. 	TC4H                  = (pwmval / 3) >> 8; \

  344. 	OCR4A                 = (pwmval / 3) & 255; \

  345. })

  346. 

  347. #define TIMER_CONFIG_NORMAL() ({ \

  348. 	TCCR4A = 0; \

  349. 	TCCR4B = _BV(CS40); \

  350. 	TCCR4C = 0; \

  351. 	TCCR4D = 0; \

  352. 	TCCR4E = 0; \

  353. 	TC4H   = (SYSCLOCK * USECPERTICK / 1000000) >> 8; \

  354. 	OCR4C  = (SYSCLOCK * USECPERTICK / 1000000) & 255; \

  355. 	TC4H   = 0; \

  356. 	TCNT4  = 0; \

  357. })

  358. 

  359. //-----------------

  360. #if defined(CORE_OC4A_PIN)

  361. #	define TIMER_PWM_PIN  CORE_OC4A_PIN  // Teensy

  362. #elif defined(ARDUINO_AVR_PROMICRO)

  363. #	define TIMER_PWM_PIN  5              // Sparkfun Pro Micro

  364. #elif defined(__AVR_ATmega32U4__)

  365. #	define TIMER_PWM_PIN  13             // Leonardo

  366. #else

  367. #	error "Please add OC4A pin number here\n"

  368. #endif

  369. 

  370. //---------------------------------------------------------

  371. // Timer4 (16 bits)

  372. //

  373. #elif defined(IR_USE_TIMER4)

  374. 

  375. #define TIMER_RESET

  376. #define TIMER_ENABLE_PWM    (TCCR4A |= _BV(COM4A1))

  377. #define TIMER_DISABLE_PWM   (TCCR4A &= ~(_BV(COM4A1)))

  378. #define TIMER_ENABLE_INTR   (TIMSK4 = _BV(OCIE4A))

  379. #define TIMER_DISABLE_INTR  (TIMSK4 = 0)

  380. #define TIMER_INTR_NAME     TIMER4_COMPA_vect

  381. 

  382. #define TIMER_CONFIG_KHZ(val) ({ \

  383.   const uint16_t pwmval = SYSCLOCK / 2000 / (val); \

  384.   TCCR4A = _BV(WGM41); \

  385.   TCCR4B = _BV(WGM43) | _BV(CS40); \

  386.   ICR4 = pwmval; \

  387.   OCR4A = pwmval / 3; \

  388. })

  389. 

  390. #define TIMER_CONFIG_NORMAL() ({ \

  391.   TCCR4A = 0; \

  392.   TCCR4B = _BV(WGM42) | _BV(CS40); \

  393.   OCR4A = SYSCLOCK * USECPERTICK / 1000000; \

  394.   TCNT4 = 0; \

  395. })

  396. 

  397. //-----------------

  398. #if defined(CORE_OC4A_PIN)

  399. #	define TIMER_PWM_PIN  CORE_OC4A_PIN

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

  401. #	define TIMER_PWM_PIN  6  // Arduino Mega

  402. #else

  403. #	error "Please add OC4A pin number here\n"

  404. #endif

  405. 

  406. //---------------------------------------------------------

  407. // Timer5 (16 bits)

  408. //

  409. #elif defined(IR_USE_TIMER5)

  410. 

  411. #define TIMER_RESET

  412. #define TIMER_ENABLE_PWM    (TCCR5A |= _BV(COM5A1))

  413. #define TIMER_DISABLE_PWM   (TCCR5A &= ~(_BV(COM5A1)))

  414. #define TIMER_ENABLE_INTR   (TIMSK5 = _BV(OCIE5A))

  415. #define TIMER_DISABLE_INTR  (TIMSK5 = 0)

  416. #define TIMER_INTR_NAME     TIMER5_COMPA_vect

  417. 

  418. #define TIMER_CONFIG_KHZ(val) ({ \

  419.   const uint16_t pwmval = SYSCLOCK / 2000 / (val); \

  420.   TCCR5A = _BV(WGM51); \

  421.   TCCR5B = _BV(WGM53) | _BV(CS50); \

  422.   ICR5 = pwmval; \

  423.   OCR5A = pwmval / 3; \

  424. })

  425. 

  426. #define TIMER_CONFIG_NORMAL() ({ \

  427.   TCCR5A = 0; \

  428.   TCCR5B = _BV(WGM52) | _BV(CS50); \

  429.   OCR5A = SYSCLOCK * USECPERTICK / 1000000; \

  430.   TCNT5 = 0; \

  431. })

  432. 

  433. //-----------------

  434. #if defined(CORE_OC5A_PIN)

  435. #	define TIMER_PWM_PIN  CORE_OC5A_PIN

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

  437. #	define TIMER_PWM_PIN  46  // Arduino Mega

  438. #else

  439. #	error "Please add OC5A pin number here\n"

  440. #endif

  441. 

  442. //---------------------------------------------------------

  443. // Special carrier modulator timer

  444. //

  445. #elif defined(IR_USE_TIMER_CMT)

  446. 

  447. #define TIMER_RESET ({     \

  448. 	uint8_t tmp __attribute__((unused)) = CMT_MSC; \

  449. 	CMT_CMD2 = 30;         \

  450. })

  451. 

  452. #define TIMER_ENABLE_PWM  do {                                         \

  453. 	CORE_PIN5_CONFIG = PORT_PCR_MUX(2) | PORT_PCR_DSE | PORT_PCR_SRE;  \

  454. } while(0)

  455. 

  456. #define TIMER_DISABLE_PWM  do {                                        \

  457. 	CORE_PIN5_CONFIG = PORT_PCR_MUX(1) | PORT_PCR_DSE | PORT_PCR_SRE;  \

  458. } while(0)

  459. 

  460. #define TIMER_ENABLE_INTR   NVIC_ENABLE_IRQ(IRQ_CMT)

  461. #define TIMER_DISABLE_INTR  NVIC_DISABLE_IRQ(IRQ_CMT)

  462. #define TIMER_INTR_NAME     cmt_isr

  463. 

  464. //-----------------

  465. #ifdef ISR

  466. #	undef ISR

  467. #endif

  468. #define  ISR(f)  void f(void)

  469. 

  470. //-----------------

  471. #define CMT_PPS_DIV  ((F_BUS + 7999999) / 8000000)

  472. #if F_BUS < 8000000

  473. #error IRremote requires at least 8 MHz on Teensy 3.x

  474. #endif

  475. 

  476. //-----------------

  477. #define TIMER_CONFIG_KHZ(val) ({ 	 \

  478. 	SIM_SCGC4 |= SIM_SCGC4_CMT;      \

  479. 	SIM_SOPT2 |= SIM_SOPT2_PTD7PAD;  \

  480. 	CMT_PPS    = CMT_PPS_DIV - 1;    \

  481. 	CMT_CGH1   = ((F_BUS / CMT_PPS_DIV / 3000) + ((val)/2)) / (val); \

  482. 	CMT_CGL1   = ((F_BUS / CMT_PPS_DIV / 1500) + ((val)/2)) / (val); \

  483. 	CMT_CMD1   = 0;                  \

  484. 	CMT_CMD2   = 30;                 \

  485. 	CMT_CMD3   = 0;                  \

  486. 	CMT_CMD4   = 0;                  \

  487. 	CMT_OC     = 0x60;               \

  488. 	CMT_MSC    = 0x01;               \

  489. })

  490. 

  491. #define TIMER_CONFIG_NORMAL() ({  \

  492. 	SIM_SCGC4 |= SIM_SCGC4_CMT;   \

  493. 	CMT_PPS    = CMT_PPS_DIV - 1; \

  494. 	CMT_CGH1   = 1;               \

  495. 	CMT_CGL1   = 1;               \

  496. 	CMT_CMD1   = 0;               \

  497. 	CMT_CMD2   = 30;              \

  498. 	CMT_CMD3   = 0;               \

  499. 	CMT_CMD4   = (F_BUS / 160000 + CMT_PPS_DIV / 2) / CMT_PPS_DIV - 31; \

  500. 	CMT_OC     = 0;               \

  501. 	CMT_MSC    = 0x03;            \

  502. })

  503. 

  504. #define TIMER_PWM_PIN  5

  505. 

  506. // defines for TPM1 timer on Teensy-LC

  507. #elif defined(IR_USE_TIMER_TPM1)

  508. #define TIMER_RESET          FTM1_SC |= FTM_SC_TOF;

  509. #define TIMER_ENABLE_PWM     CORE_PIN16_CONFIG = PORT_PCR_MUX(3)|PORT_PCR_DSE|PORT_PCR_SRE

  510. #define TIMER_DISABLE_PWM    CORE_PIN16_CONFIG = PORT_PCR_MUX(1)|PORT_PCR_SRE

  511. #define TIMER_ENABLE_INTR    NVIC_ENABLE_IRQ(IRQ_FTM1)

  512. #define TIMER_DISABLE_INTR   NVIC_DISABLE_IRQ(IRQ_FTM1)

  513. #define TIMER_INTR_NAME      ftm1_isr

  514. #ifdef ISR

  515. #undef ISR

  516. #endif

  517. #define ISR(f) void f(void)

  518. #define TIMER_CONFIG_KHZ(val) ({                     \

  519. 	SIM_SCGC6 |= SIM_SCGC6_TPM1;                 \

  520. 	FTM1_SC = 0;                                 \

  521. 	FTM1_CNT = 0;                                \

  522. 	FTM1_MOD = (F_PLL/2000) / val - 1;           \

  523. 	FTM1_C0V = (F_PLL/6000) / val - 1;           \

  524. 	FTM1_SC = FTM_SC_CLKS(1) | FTM_SC_PS(0);     \

  525. })

  526. #define TIMER_CONFIG_NORMAL() ({                     \

  527. 	SIM_SCGC6 |= SIM_SCGC6_TPM1;                 \

  528. 	FTM1_SC = 0;                                 \

  529. 	FTM1_CNT = 0;                                \

  530. 	FTM1_MOD = (F_PLL/40000) - 1;                \

  531. 	FTM1_C0V = 0;                                \

  532. 	FTM1_SC = FTM_SC_CLKS(1) | FTM_SC_PS(0) | FTM_SC_TOF | FTM_SC_TOIE; \

  533. })

  534. #define TIMER_PWM_PIN        16

  535. 

  536. // defines for FlexPWM1 timer on Teensy 4

  537. #elif defined(IR_USE_TIMER_FLEXPWM1)

  538. #define TIMER_RESET          FLEXPWM1_SM3STS = FLEXPWM_SMSTS_RF;

  539. #define TIMER_ENABLE_PWM     FLEXPWM1_OUTEN |= FLEXPWM_OUTEN_PWMA_EN(8), \

  540.                              IOMUXC_SW_MUX_CTL_PAD_GPIO_B1_00 = 6

  541. #define TIMER_DISABLE_PWM    IOMUXC_SW_MUX_CTL_PAD_GPIO_B1_00 = 5, \

  542.                              FLEXPWM1_OUTEN &= ~FLEXPWM_OUTEN_PWMA_EN(8)

  543. #define TIMER_ENABLE_INTR    attachInterruptVector(IRQ_FLEXPWM1_3, pwm1_3_isr),\

  544.                              FLEXPWM1_SM3STS = FLEXPWM_SMSTS_RF, \

  545.                              FLEXPWM1_SM3INTEN = FLEXPWM_SMINTEN_RIE, \

  546.                              NVIC_ENABLE_IRQ(IRQ_FLEXPWM1_3)

  547. #define TIMER_DISABLE_INTR   NVIC_DISABLE_IRQ(IRQ_FLEXPWM1_3)

  548. #define TIMER_INTR_NAME      pwm1_3_isr

  549. #define TIMER_INT_DECLARE    void pwm1_3_isr(void);

  550. #ifdef ISR

  551. #undef ISR

  552. #endif

  553. #define ISR(f) void f(void)

  554. #define TIMER_CONFIG_KHZ(val) ({                                             \

  555.   uint32_t period = (float)F_BUS_ACTUAL / (float)((val) * 2000);             \

  556.   uint32_t prescale = 0;                                                     \

  557.   while (period > 32767) {                                                   \

  558.     period = period >> 1;                                                    \

  559.     if (prescale < 7) prescale++;                                            \

  560.   }                                                                          \

  561.   FLEXPWM1_FCTRL0 |= FLEXPWM_FCTRL0_FLVL(8);                                 \

  562.   FLEXPWM1_FSTS0 = 0x0008;                                                   \

  563.   FLEXPWM1_MCTRL |= FLEXPWM_MCTRL_CLDOK(8);                                  \

  564.   FLEXPWM1_SM3CTRL2 = FLEXPWM_SMCTRL2_INDEP;                                 \

  565.   FLEXPWM1_SM3CTRL = FLEXPWM_SMCTRL_HALF | FLEXPWM_SMCTRL_PRSC(prescale);    \

  566.   FLEXPWM1_SM3INIT = -period;                                                \

  567.   FLEXPWM1_SM3VAL0 = 0;                                                      \

  568.   FLEXPWM1_SM3VAL1 = period;                                                 \

  569.   FLEXPWM1_SM3VAL2 = -(period / 3);                                          \

  570.   FLEXPWM1_SM3VAL3 = period / 3;                                             \

  571.   FLEXPWM1_SM3VAL4 = 0;                                                      \

  572.   FLEXPWM1_SM3VAL5 = 0;                                                      \

  573.   FLEXPWM1_MCTRL |= FLEXPWM_MCTRL_LDOK(8) | FLEXPWM_MCTRL_RUN(8);            \

  574. })

  575. #define TIMER_CONFIG_NORMAL() ({                                             \

  576.   uint32_t period = (float)F_BUS_ACTUAL * (float)USECPERTICK * 0.0000005f;   \

  577.   uint32_t prescale = 0;                                                     \

  578.   while (period > 32767) {                                                   \

  579.     period = period >> 1;                                                    \

  580.     if (prescale < 7) prescale++;                                            \

  581.   }                                                                          \

  582.   FLEXPWM1_FCTRL0 |= FLEXPWM_FCTRL0_FLVL(8);                                 \

  583.   FLEXPWM1_FSTS0 = 0x0008;                                                   \

  584.   FLEXPWM1_MCTRL |= FLEXPWM_MCTRL_CLDOK(8);                                  \

  585.   FLEXPWM1_SM3CTRL2 = FLEXPWM_SMCTRL2_INDEP;                                 \

  586.   FLEXPWM1_SM3CTRL = FLEXPWM_SMCTRL_HALF | FLEXPWM_SMCTRL_PRSC(prescale);    \

  587.   FLEXPWM1_SM3INIT = -period;                                                \

  588.   FLEXPWM1_SM3VAL0 = 0;                                                      \

  589.   FLEXPWM1_SM3VAL1 = period;                                                 \

  590.   FLEXPWM1_SM3VAL2 = 0;                                                      \

  591.   FLEXPWM1_SM3VAL3 = 0;                                                      \

  592.   FLEXPWM1_SM3VAL4 = 0;                                                      \

  593.   FLEXPWM1_SM3VAL5 = 0;                                                      \

  594.   FLEXPWM1_MCTRL |= FLEXPWM_MCTRL_LDOK(8) | FLEXPWM_MCTRL_RUN(8);            \

  595. })

  596. #define TIMER_PWM_PIN        7

  597. 

  598. // defines for timer_tiny0 (8 bits)

  599. #elif defined(IR_USE_TIMER_TINY0)

  600. #define TIMER_RESET

  601. #define TIMER_ENABLE_PWM     (TCCR0A |= _BV(COM0B1))

  602. #define TIMER_DISABLE_PWM    (TCCR0A &= ~(_BV(COM0B1)))

  603. #define TIMER_ENABLE_INTR    (TIMSK |= _BV(OCIE0A))

  604. #define TIMER_DISABLE_INTR   (TIMSK &= ~(_BV(OCIE0A)))

  605. #define TIMER_INTR_NAME      TIMER0_COMPA_vect

  606. #define TIMER_CONFIG_KHZ(val) ({ \

  607.   const uint8_t pwmval = SYSCLOCK / 2000 / (val); \

  608.   TCCR0A = _BV(WGM00); \

  609.   TCCR0B = _BV(WGM02) | _BV(CS00); \

  610.   OCR0A = pwmval; \

  611.   OCR0B = pwmval / 3; \

  612. })

  613. #define TIMER_COUNT_TOP      (SYSCLOCK * USECPERTICK / 1000000)

  614. #if (TIMER_COUNT_TOP < 256)

  615. #define TIMER_CONFIG_NORMAL() ({ \

  616.   TCCR0A = _BV(WGM01); \

  617.   TCCR0B = _BV(CS00); \

  618.   OCR0A = TIMER_COUNT_TOP; \

  619.   TCNT0 = 0; \

  620. })

  621. #else

  622. #define TIMER_CONFIG_NORMAL() ({ \

  623.   TCCR0A = _BV(WGM01); \

  624.   TCCR0B = _BV(CS01); \

  625.   OCR0A = TIMER_COUNT_TOP / 8; \

  626.   TCNT0 = 0; \

  627. })

  628. #endif

  629. 

  630. #define TIMER_PWM_PIN        1  /* ATtiny85 */

  631. 

  632. //---------------------------------------------------------

  633. // ESP32 (ESP8266 should likely be added here too)

  634. //

  635. 

  636. // ESP32 has it own timer API and does not use these macros, but to avoid ifdef'ing

  637. // them out in the common code, they are defined to no-op. This allows the code to compile

  638. // (which it wouldn't otherwise) but irsend will not work until ESP32 specific code is written

  639. // for that -- merlin

  640. // As a warning, sending timing specific code from an ESP32 can be challenging if you need 100%

  641. // reliability because the arduino code may be interrupted and cause your sent waveform to be the

  642. // wrong length. This is specifically an issue for neopixels which require 800Khz resolution.

  643. // IR may just work as is with the common code since it's lower frequency, but if not, the other

  644. // way to do this on ESP32 is using the RMT built in driver like in this incomplete library below

  645. // https://github.com/ExploreEmbedded/ESP32_RMT

  646. #elif defined(IR_TIMER_USE_ESP32)

  647. #define TIMER_RESET	     

  648. #define TIMER_ENABLE_PWM     

  649. #define TIMER_DISABLE_PWM   Serial.println("IRsend not implemented for ESP32 yet");

  650. #define TIMER_ENABLE_INTR    

  651. #define TIMER_DISABLE_INTR   

  652. #define TIMER_INTR_NAME      

  653. 

  654. //---------------------------------------------------------

  655. // Unknown Timer

  656. //

  657. #else

  658. #	error "Internal code configuration error, no known IR_USE_TIMER# defined\n"

  659. #endif

  660. 

  661. #endif // ! boarddefs_h