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.

394 lines
6.7 KiB

1 year ago
  1. #include "pin.h"
  2. const char* stm32pin2name(Pin_t pin) {
  3. switch (pin) {
  4. case PinNull:
  5. return "PinNull";
  6. case PA0:
  7. return "PA0";
  8. case PA1:
  9. return "PA1";
  10. case PA2:
  11. return "PA2";
  12. case PA3:
  13. return "PA3";
  14. case PA4:
  15. return "PA4";
  16. case PA5:
  17. return "PA5";
  18. case PA6:
  19. return "PA6";
  20. case PA7:
  21. return "PA7";
  22. case PA8:
  23. return "PA8";
  24. case PA9:
  25. return "PA9";
  26. case PA10:
  27. return "PA10";
  28. case PA11:
  29. return "PA11";
  30. case PA12:
  31. return "PA12";
  32. case PA13:
  33. return "PA13";
  34. case PA14:
  35. return "PA14";
  36. case PA15:
  37. return "PA15";
  38. case PB0:
  39. return "PB0";
  40. case PB1:
  41. return "PB1";
  42. case PB2:
  43. return "PB2";
  44. case PB3:
  45. return "PB3";
  46. case PB4:
  47. return "PB4";
  48. case PB5:
  49. return "PB5";
  50. case PB6:
  51. return "PB6";
  52. case PB7:
  53. return "PB7";
  54. case PB8:
  55. return "PB8";
  56. case PB9:
  57. return "PB9";
  58. case PB10:
  59. return "PB10";
  60. case PB11:
  61. return "PB11";
  62. case PB12:
  63. return "PB12";
  64. case PB13:
  65. return "PB13";
  66. case PB14:
  67. return "PB14";
  68. case PB15:
  69. return "PB15";
  70. case PC0:
  71. return "PC0";
  72. case PC1:
  73. return "PC1";
  74. case PC2:
  75. return "PC2";
  76. case PC3:
  77. return "PC3";
  78. case PC4:
  79. return "PC4";
  80. case PC5:
  81. return "PC5";
  82. case PC6:
  83. return "PC6";
  84. case PC7:
  85. return "PC7";
  86. case PC8:
  87. return "PC8";
  88. case PC9:
  89. return "PC9";
  90. case PC10:
  91. return "PC10";
  92. case PC11:
  93. return "PC11";
  94. case PC12:
  95. return "PC12";
  96. case PC13:
  97. return "PC13";
  98. case PC14:
  99. return "PC14";
  100. case PC15:
  101. return "PC15";
  102. case PD0:
  103. return "PD0";
  104. case PD1:
  105. return "PD1";
  106. case PD2:
  107. return "PD2";
  108. case PD3:
  109. return "PD3";
  110. case PD4:
  111. return "PD4";
  112. case PD5:
  113. return "PD5";
  114. case PD6:
  115. return "PD6";
  116. case PD7:
  117. return "PD7";
  118. case PD8:
  119. return "PD8";
  120. case PD9:
  121. return "PD9";
  122. case PD10:
  123. return "PD10";
  124. case PD11:
  125. return "PD11";
  126. case PD12:
  127. return "PD12";
  128. case PD13:
  129. return "PD13";
  130. case PD14:
  131. return "PD14";
  132. case PD15:
  133. return "PD15";
  134. case PE0:
  135. return "PE0";
  136. case PE1:
  137. return "PE1";
  138. case PE2:
  139. return "PE2";
  140. case PE3:
  141. return "PE3";
  142. case PE4:
  143. return "PE4";
  144. case PE5:
  145. return "PE5";
  146. case PE6:
  147. return "PE6";
  148. case PE7:
  149. return "PE7";
  150. case PE8:
  151. return "PE8";
  152. case PE9:
  153. return "PE9";
  154. case PE10:
  155. return "PE10";
  156. case PE11:
  157. return "PE11";
  158. case PE12:
  159. return "PE12";
  160. case PE13:
  161. return "PE13";
  162. case PE14:
  163. return "PE14";
  164. case PE15:
  165. return "PE15";
  166. case PF0:
  167. return "PF0";
  168. case PF1:
  169. return "PF1";
  170. case PF2:
  171. return "PF2";
  172. case PF3:
  173. return "PF3";
  174. case PF4:
  175. return "PF4";
  176. case PF5:
  177. return "PF5";
  178. case PF6:
  179. return "PF6";
  180. case PF7:
  181. return "PF7";
  182. case PF8:
  183. return "PF8";
  184. case PF9:
  185. return "PF9";
  186. case PF10:
  187. return "PF10";
  188. case PF11:
  189. return "PF11";
  190. case PF12:
  191. return "PF12";
  192. case PF13:
  193. return "PF13";
  194. case PF14:
  195. return "PF14";
  196. case PF15:
  197. return "PF15";
  198. case PG0:
  199. return "PG0";
  200. case PG1:
  201. return "PG1";
  202. case PG2:
  203. return "PG2";
  204. case PG3:
  205. return "PG3";
  206. case PG4:
  207. return "PG4";
  208. case PG5:
  209. return "PG5";
  210. case PG6:
  211. return "PG6";
  212. case PG7:
  213. return "PG7";
  214. case PG8:
  215. return "PG8";
  216. case PG9:
  217. return "PG9";
  218. case PG10:
  219. return "PG10";
  220. case PG11:
  221. return "PG11";
  222. case PG12:
  223. return "PG12";
  224. case PG13:
  225. return "PG13";
  226. case PG14:
  227. return "PG14";
  228. case PG15:
  229. return "PG15";
  230. default:
  231. break;
  232. }
  233. return "UNKNOWN_PIN";
  234. };
  235. GPIO_TypeDef* stm32_get_gpio_group(Pin_t pin) {
  236. int port = pin >> 4;
  237. switch (port) {
  238. case (PA0 >> 4):
  239. #ifdef GPIOA
  240. return GPIOA;
  241. #endif
  242. break;
  243. case (PB0 >> 4):
  244. #ifdef GPIOB
  245. return GPIOB;
  246. #endif
  247. break;
  248. case (PC0 >> 4):
  249. #ifdef GPIOC
  250. return GPIOC;
  251. #endif
  252. break;
  253. case (PD0 >> 4):
  254. #ifdef GPIOD
  255. return GPIOD;
  256. #endif
  257. break;
  258. case (PE0 >> 4):
  259. #ifdef GPIOE
  260. return GPIOE;
  261. #endif
  262. break;
  263. case (PF0 >> 4):
  264. #ifdef GPIOF
  265. return GPIOF;
  266. #endif
  267. break;
  268. case (PG0 >> 4):
  269. #ifdef GPIOG
  270. return GPIOG;
  271. #endif
  272. break;
  273. default:
  274. break;
  275. }
  276. return NULL;
  277. }
  278. const char* stm32_gpio_group_get_name(GPIO_TypeDef* gpio_group) {
  279. if (gpio_group == GPIOA) {
  280. return "GPIOA";
  281. }
  282. if (gpio_group == GPIOB) {
  283. return "GPIOB";
  284. }
  285. if (gpio_group == GPIOC) {
  286. return "GPIOC";
  287. }
  288. if (gpio_group == GPIOD) {
  289. return "GPIOD";
  290. }
  291. if (gpio_group == GPIOE) {
  292. return "GPIOE";
  293. }
  294. if (gpio_group == GPIOF) {
  295. return "GPIOF";
  296. }
  297. if (gpio_group == GPIOG) {
  298. return "GPIOG";
  299. }
  300. return "unknown gpio group";
  301. }
  302. uint16_t stm32_get_pinoff(Pin_t pin) {
  303. uint16_t pinoff = pin & 0x0F;
  304. switch (pinoff) {
  305. case 0:
  306. return GPIO_PIN_0;
  307. case 1:
  308. return GPIO_PIN_1;
  309. case 2:
  310. return GPIO_PIN_2;
  311. case 3:
  312. return GPIO_PIN_3;
  313. case 4:
  314. return GPIO_PIN_4;
  315. case 5:
  316. return GPIO_PIN_5;
  317. case 6:
  318. return GPIO_PIN_6;
  319. case 7:
  320. return GPIO_PIN_7;
  321. case 8:
  322. return GPIO_PIN_8;
  323. case 9:
  324. return GPIO_PIN_9;
  325. case 10:
  326. return GPIO_PIN_10;
  327. case 11:
  328. return GPIO_PIN_11;
  329. case 12:
  330. return GPIO_PIN_12;
  331. case 13:
  332. return GPIO_PIN_13;
  333. case 14:
  334. return GPIO_PIN_14;
  335. case 15:
  336. return GPIO_PIN_15;
  337. default:
  338. break;
  339. };
  340. return 0;
  341. }
  342. const char* stm32_pinoff_get_name(uint16_t pinoff) {
  343. if (pinoff == GPIO_PIN_0) {
  344. return "0";
  345. }
  346. if (pinoff == GPIO_PIN_1) {
  347. return "1";
  348. }
  349. if (pinoff == GPIO_PIN_2) {
  350. return "2";
  351. }
  352. if (pinoff == GPIO_PIN_3) {
  353. return "3";
  354. }
  355. if (pinoff == GPIO_PIN_4) {
  356. return "4";
  357. }
  358. if (pinoff == GPIO_PIN_5) {
  359. return "5";
  360. }
  361. if (pinoff == GPIO_PIN_6) {
  362. return "6";
  363. }
  364. if (pinoff == GPIO_PIN_7) {
  365. return "7";
  366. }
  367. if (pinoff == GPIO_PIN_8) {
  368. return "8";
  369. }
  370. if (pinoff == GPIO_PIN_9) {
  371. return "9";
  372. }
  373. if (pinoff == GPIO_PIN_10) {
  374. return "10";
  375. }
  376. if (pinoff == GPIO_PIN_11) {
  377. return "11";
  378. }
  379. if (pinoff == GPIO_PIN_12) {
  380. return "12";
  381. }
  382. if (pinoff == GPIO_PIN_13) {
  383. return "13";
  384. }
  385. if (pinoff == GPIO_PIN_14) {
  386. return "14";
  387. }
  388. if (pinoff == GPIO_PIN_15) {
  389. return "15";
  390. }
  391. return "unknown pinoff";
  392. }