visus
/
teensy-core-4.1
Observar 1
Favorito 0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
Teensy 4.1 core updated for C++20
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
1312 Commits
2 Branches
Tag: 6de57f23e8
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 6de57f23e8
${ noResults }
teensy-core-4.1/teensy4/pwm.c

382 linhas
12KB
Original Anotar Histórico 

  1. #include "imxrt.h"

  2. #include "core_pins.h"

  3. #include "debug/printf.h"

  4. 

  5. 

  6. struct pwm_pin_info_struct {

  7. 	uint8_t type;    // 0=no pwm, 1=flexpwm, 2=quad

  8. 	uint8_t module;  // 0-3, 0-3

  9. 	uint8_t channel; // 0=X, 1=A, 2=B

  10. 	uint8_t muxval;  //

  11. };

  12. 

  13. uint8_t analog_write_res = 8;

  14. 

  15. #define M(a, b) ((((a) - 1) << 4) | (b))

  16. 

  17. #if defined(__IMXRT1062__)

  18. 

  19. const struct pwm_pin_info_struct pwm_pin_info[] = {

  20. 	{1, M(1, 1), 0, 4},  // FlexPWM1_1_X   0  // AD_B0_03

  21. 	{1, M(1, 0), 0, 4},  // FlexPWM1_0_X   1  // AD_B0_02

  22. 	{1, M(4, 2), 1, 1},  // FlexPWM4_2_A   2  // EMC_04

  23. 	{1, M(4, 2), 2, 1},  // FlexPWM4_2_B   3  // EMC_05

  24. 	{1, M(2, 0), 1, 1},  // FlexPWM2_0_A   4  // EMC_06

  25. 	{1, M(2, 1), 1, 1},  // FlexPWM2_1_A   5  // EMC_08

  26. 	{1, M(2, 2), 1, 2},  // FlexPWM2_2_A   6  // B0_10

  27. 	{1, M(1, 3), 2, 6},  // FlexPWM1_3_B   7  // B1_01

  28. 	{1, M(1, 3), 1, 6},  // FlexPWM1_3_A   8  // B1_00

  29. 	{1, M(2, 2), 2, 2},  // FlexPWM2_2_B   9  // B0_11

  30. 	{2, M(1, 0), 0, 1},  // QuadTimer1_0  10  // B0_00

  31. 	{2, M(1, 2), 0, 1},  // QuadTimer1_2  11  // B0_02

  32. 	{2, M(1, 1), 0, 1},  // QuadTimer1_1  12  // B0_01

  33. 	{2, M(2, 0), 0, 1},  // QuadTimer2_0  13  // B0_03

  34. 	{2, M(3, 2), 0, 1},  // QuadTimer3_2  14  // AD_B1_02

  35. 	{2, M(3, 3), 0, 1},  // QuadTimer3_3  15  // AD_B1_03

  36. 	{0, M(1, 0), 0, 0},

  37. 	{0, M(1, 0), 0, 0},

  38. 	{2, M(3, 1), 0, 1},  // QuadTimer3_1  18  // AD_B1_01

  39. 	{2, M(3, 0), 0, 1},  // QuadTimer3_0  19  // AD_B1_00

  40. 	{0, M(1, 0), 0, 0},

  41. 	{0, M(1, 0), 0, 0},

  42. 	{1, M(4, 0), 1, 1},  // FlexPWM4_0_A  22  // AD_B1_08

  43. 	{1, M(4, 1), 1, 1},  // FlexPWM4_1_A  23  // AD_B1_09

  44. 	{1, M(1, 2), 0, 4},  // FlexPWM1_2_X  24  // AD_B0_12

  45. 	{1, M(1, 3), 0, 4},  // FlexPWM1_3_X  25  // AD_B0_13

  46. 	{0, M(1, 0), 0, 0},

  47. 	{0, M(1, 0), 0, 0},

  48. 	{1, M(3, 1), 2, 1},  // FlexPWM3_1_B  28  // EMC_32

  49. 	{1, M(3, 1), 1, 1},  // FlexPWM3_1_A  29  // EMC_31

  50. 	{0, M(1, 0), 0, 0},

  51. 	{0, M(1, 0), 0, 0},

  52. 	{0, M(1, 0), 0, 0},

  53. 	{1, M(2, 0), 2, 1},  // FlexPWM2_0_B  33  // EMC_07

  54. #ifdef ARDUINO_TEENSY40

  55. 	{1, M(1, 1), 2, 1},  // FlexPWM1_1_B  34  // SD_B0_03

  56. 	{1, M(1, 1), 1, 1},  // FlexPWM1_1_A  35  // SD_B0_02

  57. 	{1, M(1, 0), 2, 1},  // FlexPWM1_0_B  36  // SD_B0_01

  58. 	{1, M(1, 0), 1, 1},  // FlexPWM1_0_A  37  // SD_B0_00

  59. 	{1, M(1, 2), 2, 1},  // FlexPWM1_2_B  38  // SD_B0_05

  60. 	{1, M(1, 2), 1, 1},  // FlexPWM1_2_A  39  // SD_B0_04

  61. #endif

  62. #ifdef ARDUINO_TEENSY41

  63. 	{0, M(1, 0), 0, 0},

  64. 	{0, M(1, 0), 0, 0},

  65. 	{1, M(2, 3), 1, 6},  // FlexPWM2_3_A  36  // B1_00

  66. 	{1, M(2, 3), 2, 6},  // FlexPWM2_3_B  37  // B1_01

  67. 	{0, M(1, 0), 0, 0},

  68. 	{0, M(1, 0), 0, 0},

  69. 	{0, M(1, 0), 0, 0},

  70. 	{0, M(1, 0), 0, 0},

  71. 	{1, M(1, 1), 2, 1},  // FlexPWM1_1_B  42  // SD_B0_03

  72. 	{1, M(1, 1), 1, 1},  // FlexPWM1_1_A  43  // SD_B0_02

  73. 	{1, M(1, 0), 2, 1},  // FlexPWM1_0_B  44  // SD_B0_01

  74. 	{1, M(1, 0), 1, 1},  // FlexPWM1_0_A  45  // SD_B0_00

  75. 	{1, M(1, 2), 2, 1},  // FlexPWM1_2_B  46  // SD_B0_05

  76. 	{1, M(1, 2), 1, 1},  // FlexPWM1_2_A  47  // SD_B0_04

  77. 	{0, M(1, 0), 0, 0},  // duplicate FlexPWM1_0_B

  78. 	{0, M(1, 0), 0, 0},  // duplicate FlexPWM1_2_A

  79. 	{0, M(1, 0), 0, 0},  // duplicate FlexPWM1_2_B

  80. 	{1, M(3, 3), 2, 1},  // FlexPWM3_3_B  51  // EMC_22

  81. 	{0, M(1, 0), 0, 0},  // duplicate FlexPWM1_1_B

  82. 	{0, M(1, 0), 0, 0},  // duplicate FlexPWM1_1_A

  83. 	{1, M(3, 0), 1, 1},  // FlexPWM3_0_A  53  // EMC_29

  84. #endif

  85. };

  86. 

  87. // Known usage of FlexPWM and QuadTimers

  88. // -------------------------------------

  89. //   FlexPWM1_0    PWM pin 1, 36(T4.0), 37(T4.0), 44(T4.1), 45(T4.1)

  90. //   FlexPWM1_1    PWM pin 0, 34(T4.0), 35(T4.0), 42(T4.1), 43(T4.1)

  91. //   FlexPWM1_2    PWM pin 24, 38(T4.0), 39(T4.0), 46(T4.1), 47(T4.1)

  92. //   FlexPWM1_3    PWM pin 7, 8, 25

  93. //   FlexPWM2_0    PWM pin 4, 33

  94. //   FlexPWM2_1    PWM pin 5

  95. //   FlexPWM2_2    PWM pin 6, 9

  96. //   FlexPWM2_3    PWM pin 36(T4.1), 37(T4.1)

  97. //   FlexPWM3_0    PWM pin 53(T4.1)

  98. //   FlexPWM3_1    PWM pin 28, 29

  99. //   FlexPWM3_2

  100. //   FlexPWM3_3    PWM pin 41(T4.1)

  101. //   FlexPWM4_0    PWM pin 22

  102. //   FlexPWM4_1    PWM pin 23

  103. //   FlexPWM4_2    PWM pin 2, 3

  104. //   FlexPWM4_3

  105. //   QuadTimer1_0  PWM pin 10

  106. //   QuadTimer1_1  PWM pin 12

  107. //   QuadTimer1_2  PWM pin 11

  108. //   QuadTimer1_3

  109. //   QuadTimer2_0  PWM pin 13

  110. //   QuadTimer2_1

  111. //   QuadTimer2_2

  112. //   QuadTimer2_3

  113. //   QuadTimer3_0  PWM pin 19

  114. //   QuadTimer3_1  PWM pin 18

  115. //   QuadTimer3_2  PWM pin 14

  116. //   QuadTimer3_3  PWM pin 15

  117. //   QuadTimer4_0  OctoWS2811

  118. //   QuadTimer4_1  OctoWS2811

  119. //   QuadTimer4_2  OctoWS2811

  120. //   QuadTimer4_3  AudioInputAnalog

  121. 

  122. 

  123. #endif // __IMXRT1062__

  124. 

  125. void flexpwmWrite(IMXRT_FLEXPWM_t *p, unsigned int submodule, uint8_t channel, uint16_t val)

  126. {

  127. 	uint16_t mask = 1 << submodule;

  128. 	uint32_t modulo = p->SM[submodule].VAL1;

  129. 	uint32_t cval = ((uint32_t)val * (modulo + 1)) >> analog_write_res;

  130. 	if (cval > modulo) cval = modulo; // TODO: is this check correct?

  131. 

  132. 	//printf("flexpwmWrite, p=%08lX, sm=%d, ch=%c, cval=%ld\n",

  133. 		//(uint32_t)p, submodule, channel == 0 ? 'X' : (channel == 1 ? 'A' : 'B'), cval);

  134. 	p->MCTRL |= FLEXPWM_MCTRL_CLDOK(mask);

  135. 	switch (channel) {

  136. 	  case 0: // X

  137. 		p->SM[submodule].VAL0 = modulo - cval;

  138. 		p->OUTEN |= FLEXPWM_OUTEN_PWMX_EN(mask);

  139. 		//printf(" write channel X\n");

  140. 		break;

  141. 	  case 1: // A

  142. 		p->SM[submodule].VAL3 = cval;

  143. 		p->OUTEN |= FLEXPWM_OUTEN_PWMA_EN(mask);

  144. 		//printf(" write channel A\n");

  145. 		break;

  146. 	  case 2: // B

  147. 		p->SM[submodule].VAL5 = cval;

  148. 		p->OUTEN |= FLEXPWM_OUTEN_PWMB_EN(mask);

  149. 		//printf(" write channel B\n");

  150. 	}

  151. 	p->MCTRL |= FLEXPWM_MCTRL_LDOK(mask);

  152. }

  153. 

  154. void flexpwmFrequency(IMXRT_FLEXPWM_t *p, unsigned int submodule, uint8_t channel, float frequency)

  155. {

  156. 	uint16_t mask = 1 << submodule;

  157. 	uint32_t olddiv = p->SM[submodule].VAL1;

  158. 	uint32_t newdiv = (uint32_t)((float)F_BUS_ACTUAL / frequency + 0.5f);

  159. 	uint32_t prescale = 0;

  160. 	//printf(" div=%lu\n", newdiv);

  161. 	while (newdiv > 65535 && prescale < 7) {

  162. 		newdiv = newdiv >> 1;

  163. 		prescale = prescale + 1;

  164. 	}

  165. 	if (newdiv > 65535) {

  166. 		newdiv = 65535;

  167. 	} else if (newdiv < 2) {

  168. 		newdiv = 2;

  169. 	}

  170. 	//printf(" div=%lu, scale=%lu\n", newdiv, prescale);

  171. 	p->MCTRL |= FLEXPWM_MCTRL_CLDOK(mask);

  172. 	p->SM[submodule].CTRL = FLEXPWM_SMCTRL_FULL | FLEXPWM_SMCTRL_PRSC(prescale);

  173. 	p->SM[submodule].VAL1 = newdiv - 1;

  174. 	p->SM[submodule].VAL0 = (p->SM[submodule].VAL0 * newdiv) / olddiv;

  175. 	p->SM[submodule].VAL3 = (p->SM[submodule].VAL3 * newdiv) / olddiv;

  176. 	p->SM[submodule].VAL5 = (p->SM[submodule].VAL5 * newdiv) / olddiv;

  177. 	p->MCTRL |= FLEXPWM_MCTRL_LDOK(mask);

  178. }

  179. 

  180. void quadtimerWrite(IMXRT_TMR_t *p, unsigned int submodule, uint16_t val)

  181. {

  182. 	uint32_t modulo = 65537 - p->CH[submodule].LOAD + p->CH[submodule].CMPLD1;

  183. 	uint32_t high = ((uint32_t)val * (modulo - 1)) >> analog_write_res;

  184. 	if (high >= modulo - 1) high = modulo - 2;

  185. 

  186. 	//printf(" modulo=%lu\n", modulo);

  187. 	//printf(" high=%lu\n", high);

  188. 	uint32_t low = modulo - high; // low must 2 or higher

  189. 	//printf(" low=%lu\n", low);

  190. 

  191. 	p->CH[submodule].LOAD = 65537 - low;

  192. 	p->CH[submodule].CMPLD1 = high;

  193. }

  194. 

  195. void quadtimerFrequency(IMXRT_TMR_t *p, unsigned int submodule, float frequency)

  196. {

  197. 	uint32_t newdiv = (uint32_t)((float)F_BUS_ACTUAL / frequency + 0.5f);

  198. 	uint32_t prescale = 0;

  199. 	//printf(" div=%lu\n", newdiv);

  200. 	while (newdiv > 65534 && prescale < 7) {

  201. 		newdiv = newdiv >> 1; 

  202. 		prescale = prescale + 1;

  203. 	}

  204. 	if (newdiv > 65534) {

  205. 		newdiv = 65534;

  206. 	} else if (newdiv < 2) {

  207. 		newdiv = 2;

  208. 	}

  209. 	//printf(" div=%lu, scale=%lu\n", newdiv, prescale);

  210. 	uint32_t oldhigh = p->CH[submodule].CMPLD1;

  211. 	uint32_t oldlow = 65537 - p->CH[submodule].LOAD;

  212. 	uint32_t high = (oldhigh * newdiv) / (oldhigh + oldlow);

  213. 	// TODO: low must never be less than 2 - can it happen with this?

  214. 	uint32_t low = newdiv - high;

  215. 	//printf(" high=%lu, low=%lu\n", high, low);

  216. 	p->CH[submodule].LOAD = 65537 - low;

  217. 	p->CH[submodule].CMPLD1 = high;

  218. 	p->CH[submodule].CTRL = TMR_CTRL_CM(1) | TMR_CTRL_PCS(8 + prescale) |

  219. 		TMR_CTRL_LENGTH | TMR_CTRL_OUTMODE(6);

  220. }

  221. 

  222. void analogWrite(uint8_t pin, int val)

  223. {

  224. 	const struct pwm_pin_info_struct *info;

  225. 

  226. 	if (pin >= CORE_NUM_DIGITAL) return;

  227. 	//printf("analogWrite, pin %d, val %d\n", pin, val);

  228. 	info = pwm_pin_info + pin;

  229. 	if (info->type == 1) {

  230. 		// FlexPWM pin

  231. 		IMXRT_FLEXPWM_t *flexpwm;

  232. 		switch ((info->module >> 4) & 3) {

  233. 		  case 0: flexpwm = &IMXRT_FLEXPWM1; break;

  234. 		  case 1: flexpwm = &IMXRT_FLEXPWM2; break;

  235. 		  case 2: flexpwm = &IMXRT_FLEXPWM3; break;

  236. 		  default: flexpwm = &IMXRT_FLEXPWM4;

  237. 		}

  238. 		flexpwmWrite(flexpwm, info->module & 0x03, info->channel, val);

  239. 	} else if (info->type == 2) {

  240. 		// QuadTimer pin

  241. 		IMXRT_TMR_t *qtimer;

  242. 		switch ((info->module >> 4) & 3) {

  243. 		  case 0: qtimer = &IMXRT_TMR1; break;

  244. 		  case 1: qtimer = &IMXRT_TMR2; break;

  245. 		  case 2: qtimer = &IMXRT_TMR3; break;

  246. 		  default: qtimer = &IMXRT_TMR4;

  247. 		}

  248. 		quadtimerWrite(qtimer, info->module & 0x03, val);

  249. 	} else {

  250. 		return;

  251. 	}

  252. 	*(portConfigRegister(pin)) = info->muxval;

  253. 	// TODO: pad config register

  254. }

  255. 

  256. void analogWriteFrequency(uint8_t pin, float frequency)

  257. {

  258. 	const struct pwm_pin_info_struct *info;

  259. 

  260. 	if (pin >= CORE_NUM_DIGITAL) return;

  261. 	//printf("analogWriteFrequency, pin %d, freq %d\n", pin, (int)frequency);

  262. 	info = pwm_pin_info + pin;

  263. 	if (info->type == 1) {

  264. 		// FlexPWM pin

  265. 		IMXRT_FLEXPWM_t *flexpwm;

  266. 		switch ((info->module >> 4) & 3) {

  267. 		  case 0: flexpwm = &IMXRT_FLEXPWM1; break;

  268. 		  case 1: flexpwm = &IMXRT_FLEXPWM2; break;

  269. 		  case 2: flexpwm = &IMXRT_FLEXPWM3; break;

  270. 		  default: flexpwm = &IMXRT_FLEXPWM4;

  271. 		}

  272. 		flexpwmFrequency(flexpwm, info->module & 0x03, info->channel, frequency);

  273. 	} else if (info->type == 2) {

  274. 		// QuadTimer pin

  275. 		IMXRT_TMR_t *qtimer;

  276. 		switch ((info->module >> 4) & 3) {

  277. 		  case 0: qtimer = &IMXRT_TMR1; break;

  278. 		  case 1: qtimer = &IMXRT_TMR2; break;

  279. 		  case 2: qtimer = &IMXRT_TMR3; break;

  280. 		  default: qtimer = &IMXRT_TMR4;

  281. 		}

  282. 		quadtimerFrequency(qtimer, info->module & 0x03, frequency);

  283. 	}

  284. }

  285. 

  286. void flexpwm_init(IMXRT_FLEXPWM_t *p)

  287. {

  288. 	int i;

  289. 

  290. 	p->FCTRL0 = FLEXPWM_FCTRL0_FLVL(15); // logic high = fault

  291. 	p->FSTS0 = 0x000F; // clear fault status

  292. 	p->FFILT0 = 0;

  293. 	p->MCTRL |= FLEXPWM_MCTRL_CLDOK(15);

  294. 	for (i=0; i < 4; i++) {

  295. 		p->SM[i].CTRL2 = FLEXPWM_SMCTRL2_INDEP | FLEXPWM_SMCTRL2_WAITEN

  296. 			| FLEXPWM_SMCTRL2_DBGEN;

  297. 		p->SM[i].CTRL = FLEXPWM_SMCTRL_FULL;

  298. 		p->SM[i].OCTRL = 0;

  299. 		p->SM[i].DTCNT0 = 0;

  300. 		p->SM[i].INIT = 0;

  301. 		p->SM[i].VAL0 = 0;

  302. 		p->SM[i].VAL1 = 33464;

  303. 		p->SM[i].VAL2 = 0;

  304. 		p->SM[i].VAL3 = 0;

  305. 		p->SM[i].VAL4 = 0;

  306. 		p->SM[i].VAL5 = 0;

  307. 	}

  308. 	p->MCTRL |= FLEXPWM_MCTRL_LDOK(15);

  309. 	p->MCTRL |= FLEXPWM_MCTRL_RUN(15);

  310. }

  311. 

  312. void quadtimer_init(IMXRT_TMR_t *p)

  313. {

  314. 	int i;

  315. 

  316. 	for (i=0; i < 4; i++) {

  317. 		p->CH[i].CTRL = 0; // stop timer

  318. 		p->CH[i].CNTR = 0;

  319. 		p->CH[i].SCTRL = TMR_SCTRL_OEN | TMR_SCTRL_OPS | TMR_SCTRL_VAL | TMR_SCTRL_FORCE;

  320. 		p->CH[i].CSCTRL = TMR_CSCTRL_CL1(1) | TMR_CSCTRL_ALT_LOAD;

  321. 		// COMP must be less than LOAD - otherwise output is always low

  322. 		p->CH[i].LOAD = 24000;   // low time  (65537 - x) - 

  323. 		p->CH[i].COMP1 = 0;  // high time (0 = always low, max = LOAD-1)

  324. 		p->CH[i].CMPLD1 = 0;

  325. 		p->CH[i].CTRL = TMR_CTRL_CM(1) | TMR_CTRL_PCS(8) |

  326. 			TMR_CTRL_LENGTH | TMR_CTRL_OUTMODE(6);

  327. 	}

  328. }

  329. 

  330. void pwm_init(void)

  331. {

  332. 	//printf("pwm init\n");

  333. 	CCM_CCGR4 |= CCM_CCGR4_PWM1(CCM_CCGR_ON) | CCM_CCGR4_PWM2(CCM_CCGR_ON) |

  334. 		CCM_CCGR4_PWM3(CCM_CCGR_ON) | CCM_CCGR4_PWM4(CCM_CCGR_ON);

  335. 	CCM_CCGR6 |= CCM_CCGR6_QTIMER1(CCM_CCGR_ON) | CCM_CCGR6_QTIMER2(CCM_CCGR_ON) |

  336. 		CCM_CCGR6_QTIMER3(CCM_CCGR_ON) | CCM_CCGR6_QTIMER4(CCM_CCGR_ON);

  337. 	flexpwm_init(&IMXRT_FLEXPWM1);

  338. 	flexpwm_init(&IMXRT_FLEXPWM2);

  339. 	flexpwm_init(&IMXRT_FLEXPWM3);

  340. 	flexpwm_init(&IMXRT_FLEXPWM4);

  341. 	quadtimer_init(&IMXRT_TMR1);

  342. 	quadtimer_init(&IMXRT_TMR2);

  343. 	quadtimer_init(&IMXRT_TMR3);

  344. }

  345. 

  346. 

  347. 

  348. void xbar_connect(unsigned int input, unsigned int output)

  349. {

  350. 	if (input >= 88) return;

  351. 	if (output >= 132) return;

  352. #if 1

  353. 	volatile uint16_t *xbar = &XBARA1_SEL0 + (output / 2);

  354. 	uint16_t val = *xbar;

  355. 	if (!(output & 1)) {

  356. 		val = (val & 0xFF00) | input;

  357. 	} else {

  358. 		val = (val & 0x00FF) | (input << 8);

  359. 	}

  360. 	*xbar = val;

  361. #else

  362. 	// does not work, seems 8 bit access is not allowed

  363. 	volatile uint8_t *xbar = (volatile uint8_t *)XBARA1_SEL0;

  364. 	xbar[output] = input;

  365. #endif

  366. }

  367. 

  368. uint32_t analogWriteRes(uint32_t bits)

  369. {

  370. 	uint32_t prior;

  371. 	if (bits < 1) {

  372. 		bits = 1;

  373. 	} else if (bits > 16) {

  374. 		bits = 16;

  375. 	}

  376. 	prior = analog_write_res;

  377. 	analog_write_res = bits;

  378. 	return prior;

  379. }

  380.