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.

358 lines
9.7 KiB

2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
  1. #include "zgpio.hpp"
  2. #define TAG "GPIO"
  3. namespace iflytop {
  4. /*******************************************************************************
  5. * LISTENER *
  6. *******************************************************************************/
  7. static ZGPIO *s_irqGPIO[20];
  8. int s_irqGPIO_num = 0;
  9. extern "C" {
  10. /**
  11. * @brief This function handles EXTI line3 interrupt.
  12. */
  13. void EXTI0_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0); }
  14. void EXTI1_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_1); }
  15. void EXTI2_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_2); }
  16. void EXTI3_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_3); }
  17. void EXTI4_IRQHandler() { HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_4); }
  18. void EXTI9_5_IRQHandler(void) {
  19. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_5);
  20. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_6);
  21. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_7);
  22. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8);
  23. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_9);
  24. }
  25. void EXTI15_10_IRQHandler(void) {
  26. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_10);
  27. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_11);
  28. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_12);
  29. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
  30. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
  31. HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_15);
  32. }
  33. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
  34. for (int i = 0; i < s_irqGPIO_num; i++) {
  35. s_irqGPIO[i]->tryTriggerIRQ(GPIO_Pin);
  36. }
  37. }
  38. }
  39. void ZGPIO::regListener(onirq_t listener) { m_onirq = listener; }
  40. /*******************************************************************************
  41. * GPIOIMPL *
  42. *******************************************************************************/
  43. /*******************************************************************************
  44. * BASE_FUNC *
  45. *******************************************************************************/
  46. bool ZGPIO::enableClock() {
  47. #ifdef GPIOA
  48. if (m_gpio == GPIOA) {
  49. __HAL_RCC_GPIOA_CLK_ENABLE();
  50. return true;
  51. }
  52. #endif
  53. #ifdef GPIOB
  54. if (m_gpio == GPIOB) {
  55. __HAL_RCC_GPIOB_CLK_ENABLE();
  56. return true;
  57. }
  58. #endif
  59. #ifdef GPIOC
  60. if (m_gpio == GPIOC) {
  61. __HAL_RCC_GPIOC_CLK_ENABLE();
  62. return true;
  63. }
  64. #endif
  65. #ifdef GPIOD
  66. if (m_gpio == GPIOD) {
  67. __HAL_RCC_GPIOD_CLK_ENABLE();
  68. return true;
  69. }
  70. #endif
  71. #ifdef GPIOE
  72. if (m_gpio == GPIOE) {
  73. __HAL_RCC_GPIOE_CLK_ENABLE();
  74. return true;
  75. }
  76. #endif
  77. #ifdef GPIOF
  78. if (m_gpio == GPIOF) {
  79. __HAL_RCC_GPIOF_CLK_ENABLE();
  80. return true;
  81. }
  82. #endif
  83. #ifdef GPIOG
  84. if (m_gpio == GPIOG) {
  85. __HAL_RCC_GPIOG_CLK_ENABLE();
  86. return true;
  87. }
  88. #endif
  89. #ifdef GPIOH
  90. if (m_gpio == GPIOH) {
  91. __HAL_RCC_GPIOH_CLK_ENABLE();
  92. return true;
  93. }
  94. #endif
  95. #ifdef GPIOI
  96. if (m_gpio == GPIOI) {
  97. __HAL_RCC_GPIOI_CLK_ENABLE();
  98. return true;
  99. }
  100. #endif
  101. #ifdef GPIOJ
  102. if (m_gpio == GPIOJ) {
  103. __HAL_RCC_GPIOJ_CLK_ENABLE();
  104. return true;
  105. }
  106. #endif
  107. #ifdef GPIOK
  108. if (m_gpio == GPIOK) {
  109. __HAL_RCC_GPIOK_CLK_ENABLE();
  110. return true;
  111. }
  112. #endif
  113. return false;
  114. }
  115. void regIRQGPIO(ZGPIO *gpio) {
  116. for (int i = 0; i < s_irqGPIO_num; i++) {
  117. if (s_irqGPIO[i] == gpio) {
  118. return;
  119. }
  120. }
  121. EARLY_ASSERT((s_irqGPIO_num + 1) < (int)ZARRAY_SIZE(s_irqGPIO));
  122. s_irqGPIO[s_irqGPIO_num] = gpio;
  123. s_irqGPIO_num++;
  124. }
  125. bool ZGPIO::isMirror() { return m_mirror; }
  126. void ZGPIO::initAsInput(Pin_t pin, GPIOMode_t mode, GPIOIrqType_t irqtype, bool mirror) {
  127. m_mirror = mirror;
  128. m_mode = mode;
  129. m_irqtype = irqtype;
  130. m_gpiotype = kType_Input;
  131. m_gpio = chip_get_gpio(pin);
  132. m_pinoff = chip_get_pinoff(pin);
  133. uint32_t pulluptype = 0;
  134. if (mode == kMode_nopull) {
  135. pulluptype = GPIO_NOPULL;
  136. } else if (mode == kMode_pullup) {
  137. pulluptype = GPIO_PULLUP;
  138. } else if (mode == kMode_pulldown) {
  139. pulluptype = GPIO_PULLDOWN;
  140. }
  141. enableClock();
  142. GPIO_InitTypeDef m_GPIO_InitStruct = {0};
  143. if (m_irqtype == kIRQ_noIrq) {
  144. m_GPIO_InitStruct.Pin = m_pinoff;
  145. m_GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  146. m_GPIO_InitStruct.Pull = pulluptype;
  147. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  148. } else if (m_irqtype == kIRQ_risingIrq) {
  149. m_GPIO_InitStruct.Pin = m_pinoff;
  150. m_GPIO_InitStruct.Mode = m_mirror ? GPIO_MODE_IT_FALLING : GPIO_MODE_IT_RISING;
  151. m_GPIO_InitStruct.Pull = pulluptype;
  152. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  153. } else if (m_irqtype == kIRQ_fallingIrq) {
  154. m_GPIO_InitStruct.Pin = m_pinoff;
  155. m_GPIO_InitStruct.Mode = !m_mirror ? GPIO_MODE_IT_FALLING : GPIO_MODE_IT_RISING;
  156. m_GPIO_InitStruct.Pull = pulluptype;
  157. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  158. } else if (m_irqtype == kIRQ_risingAndFallingIrq) {
  159. m_GPIO_InitStruct.Pin = m_pinoff;
  160. m_GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
  161. m_GPIO_InitStruct.Pull = pulluptype;
  162. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  163. }
  164. HAL_GPIO_Init(m_gpio, &m_GPIO_InitStruct);
  165. if (m_irqtype != kIRQ_noIrq) {
  166. regIRQGPIO(this);
  167. lastLevel = getState();
  168. HAL_NVIC_SetPriority(getEXTIIRQn(), IFLYTOP_PREEMPTPRIORITY_DEFAULT, 0);
  169. HAL_NVIC_EnableIRQ(getEXTIIRQn());
  170. }
  171. m_initflag = true;
  172. return;
  173. }
  174. void ZGPIO::initAsOutput(Pin_t pin, GPIOMode_t mode, bool mirror, bool initLevel) {
  175. m_mirror = mirror;
  176. m_mode = mode;
  177. m_irqtype = kIRQ_noIrq;
  178. m_gpiotype = kType_Output;
  179. m_gpio = chip_get_gpio(pin);
  180. m_pinoff = chip_get_pinoff(pin);
  181. enableClock();
  182. GPIO_InitTypeDef m_GPIO_InitStruct = {0};
  183. initLevel = m_mirror ? !initLevel : initLevel;
  184. GPIO_PinState pinState = initLevel ? GPIO_PIN_SET : GPIO_PIN_RESET;
  185. HAL_GPIO_WritePin(m_gpio, m_pinoff, pinState);
  186. if (m_mode == kMode_nopull) {
  187. m_GPIO_InitStruct.Pin = m_pinoff;
  188. m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  189. m_GPIO_InitStruct.Pull = GPIO_NOPULL;
  190. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  191. } else if (m_mode == kMode_pullup) {
  192. m_GPIO_InitStruct.Pin = m_pinoff;
  193. m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  194. m_GPIO_InitStruct.Pull = GPIO_PULLUP;
  195. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  196. } else if (m_mode == kMode_pulldown) {
  197. m_GPIO_InitStruct.Pin = m_pinoff;
  198. m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  199. m_GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  200. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  201. } else if (m_mode == kMode_od) {
  202. m_GPIO_InitStruct.Pin = m_pinoff;
  203. m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
  204. m_GPIO_InitStruct.Pull = 0;
  205. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  206. }
  207. HAL_GPIO_Init(m_gpio, &m_GPIO_InitStruct);
  208. m_initflag = true;
  209. return;
  210. }
  211. bool ZGPIO::isItRisingEXITGPIO() { return m_irqtype == kIRQ_risingIrq; }
  212. bool ZGPIO::isItFallingEXITGPIO() { return m_irqtype == kIRQ_fallingIrq; }
  213. bool ZGPIO::isItRisingAndItFallingEXITGPIO() { return m_irqtype == kIRQ_risingAndFallingIrq; }
  214. /*******************************************************************************
  215. * EXT FUNC *
  216. *******************************************************************************/
  217. /**
  218. * @brief жϵǰǷŲж
  219. *
  220. * @param checkloop
  221. * @param GPIO_Pin
  222. * @return true
  223. * @return false
  224. *
  225. * STM32GPIOжǹõģҪGPIOļʱ״̬жǷŲ??
  226. *
  227. * ж߼??:
  228. * жжģʽ GPIO_MODE_IT_RISING ?? GPIO_MODE_IT_FALLING ţǰƽжǷŲж
  229. * жжģʽ GPIO_MODE_IT_RISING_FALLING ţֱӷtrue
  230. */
  231. bool ZGPIO::tryTriggerIRQ(uint16_t GPIO_Pin) {
  232. bool ret = false;
  233. bool nostate = false;
  234. if (GPIO_Pin != m_pinoff) return false;
  235. if (!(isItRisingEXITGPIO() || isItFallingEXITGPIO() || isItRisingAndItFallingEXITGPIO())) {
  236. return false;
  237. }
  238. nostate = getState();
  239. if (isItRisingEXITGPIO()) {
  240. if (nostate) {
  241. ret = true;
  242. if (m_onirq) {
  243. m_onirq(this, kRisingIrqEvent);
  244. }
  245. }
  246. } else if (isItFallingEXITGPIO()) {
  247. if (!nostate) {
  248. ret = true;
  249. if (m_onirq) {
  250. m_onirq(this, kFallingIrqEvent);
  251. }
  252. }
  253. } else {
  254. if (lastLevel != nostate) {
  255. ret = true;
  256. if (m_onirq) {
  257. if (lastLevel)
  258. m_onirq(this, kRisingIrqEvent);
  259. else
  260. m_onirq(this, kFallingIrqEvent);
  261. }
  262. }
  263. }
  264. lastLevel = nostate;
  265. return ret;
  266. }
  267. void ZGPIO::toggleState() { HAL_GPIO_TogglePin(m_gpio, m_pinoff); }
  268. uint32_t ZGPIO::getStateUint32() {
  269. if (getState())
  270. return 1;
  271. else
  272. return 0;
  273. }
  274. bool ZGPIO::getState() {
  275. bool ret = false;
  276. if (HAL_GPIO_ReadPin(m_gpio, m_pinoff) == GPIO_PIN_SET) {
  277. ret = true;
  278. } else {
  279. ret = false;
  280. }
  281. if (m_mirror) ret = !ret;
  282. return ret;
  283. }
  284. bool ZGPIO::setState(bool state) {
  285. if (m_mirror) state = !state;
  286. if (state) {
  287. HAL_GPIO_WritePin(m_gpio, m_pinoff, GPIO_PIN_SET);
  288. } else {
  289. HAL_GPIO_WritePin(m_gpio, m_pinoff, GPIO_PIN_RESET);
  290. }
  291. return true;
  292. }
  293. IRQn_Type ZGPIO::getEXTIIRQn() {
  294. switch (m_pinoff) {
  295. case GPIO_PIN_0:
  296. return EXTI0_IRQn;
  297. case GPIO_PIN_1:
  298. return EXTI1_IRQn;
  299. case GPIO_PIN_2:
  300. return EXTI2_IRQn;
  301. case GPIO_PIN_3:
  302. return EXTI3_IRQn;
  303. case GPIO_PIN_4:
  304. return EXTI4_IRQn;
  305. case GPIO_PIN_5:
  306. case GPIO_PIN_6:
  307. case GPIO_PIN_7:
  308. case GPIO_PIN_8:
  309. case GPIO_PIN_9:
  310. return EXTI9_5_IRQn;
  311. case GPIO_PIN_10:
  312. case GPIO_PIN_11:
  313. case GPIO_PIN_12:
  314. case GPIO_PIN_13:
  315. case GPIO_PIN_14:
  316. case GPIO_PIN_15:
  317. return EXTI15_10_IRQn;
  318. default:
  319. ZEARLY_ASSERT(0);
  320. }
  321. return EXTI0_IRQn;
  322. }
  323. /**
  324. * @brief ʼGPIOΪжģ??
  325. *
  326. * @param pull GPIO_NOPULL, GPIO_PULLUP, GPIO_PULLDOWN
  327. * @param mode GPIO_MODE_IT_RISING, GPIO_MODE_IT_FALLING, GPIO_MODE_IT_RISING_FALLING
  328. * @return true
  329. * @return false
  330. */
  331. } // namespace iflytop