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.

354 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
  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. return;
  172. }
  173. void ZGPIO::initAsOutput(Pin_t pin, GPIOMode_t mode, bool mirror, bool initLevel) {
  174. m_mirror = mirror;
  175. m_mode = mode;
  176. m_irqtype = kIRQ_noIrq;
  177. m_gpiotype = kType_Output;
  178. m_gpio = chip_get_gpio(pin);
  179. m_pinoff = chip_get_pinoff(pin);
  180. enableClock();
  181. GPIO_InitTypeDef m_GPIO_InitStruct = {0};
  182. initLevel = m_mirror ? !initLevel : initLevel;
  183. GPIO_PinState pinState = initLevel ? GPIO_PIN_SET : GPIO_PIN_RESET;
  184. HAL_GPIO_WritePin(m_gpio, m_pinoff, pinState);
  185. if (m_mode == kMode_nopull) {
  186. m_GPIO_InitStruct.Pin = m_pinoff;
  187. m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  188. m_GPIO_InitStruct.Pull = GPIO_NOPULL;
  189. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  190. } else if (m_mode == kMode_pullup) {
  191. m_GPIO_InitStruct.Pin = m_pinoff;
  192. m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  193. m_GPIO_InitStruct.Pull = GPIO_PULLUP;
  194. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  195. } else if (m_mode == kMode_pulldown) {
  196. m_GPIO_InitStruct.Pin = m_pinoff;
  197. m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  198. m_GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  199. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  200. } else if (m_mode == kMode_od) {
  201. m_GPIO_InitStruct.Pin = m_pinoff;
  202. m_GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
  203. m_GPIO_InitStruct.Pull = 0;
  204. m_GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  205. }
  206. HAL_GPIO_Init(m_gpio, &m_GPIO_InitStruct);
  207. return;
  208. }
  209. bool ZGPIO::isItRisingEXITGPIO() { return m_irqtype == kIRQ_risingIrq; }
  210. bool ZGPIO::isItFallingEXITGPIO() { return m_irqtype == kIRQ_fallingIrq; }
  211. bool ZGPIO::isItRisingAndItFallingEXITGPIO() { return m_irqtype == kIRQ_risingAndFallingIrq; }
  212. /*******************************************************************************
  213. * EXT FUNC *
  214. *******************************************************************************/
  215. /**
  216. * @brief жϵǰǷŲж
  217. *
  218. * @param checkloop
  219. * @param GPIO_Pin
  220. * @return true
  221. * @return false
  222. *
  223. * STM32GPIOжǹõģҪGPIOļʱ״̬жǷŲ??
  224. *
  225. * ж߼??:
  226. * жжģʽ GPIO_MODE_IT_RISING ?? GPIO_MODE_IT_FALLING ţǰƽжǷŲж
  227. * жжģʽ GPIO_MODE_IT_RISING_FALLING ţֱӷtrue
  228. */
  229. bool ZGPIO::tryTriggerIRQ(uint16_t GPIO_Pin) {
  230. bool ret = false;
  231. bool nostate = false;
  232. if (GPIO_Pin != m_pinoff) return false;
  233. if (!(isItRisingEXITGPIO() || isItFallingEXITGPIO() || isItRisingAndItFallingEXITGPIO())) {
  234. return false;
  235. }
  236. nostate = getState();
  237. if (isItRisingEXITGPIO()) {
  238. if (nostate) {
  239. ret = true;
  240. if (m_onirq) {
  241. m_onirq(this, kRisingIrqEvent);
  242. }
  243. }
  244. } else if (isItFallingEXITGPIO()) {
  245. if (!nostate) {
  246. ret = true;
  247. if (m_onirq) {
  248. m_onirq(this, kFallingIrqEvent);
  249. }
  250. }
  251. } else {
  252. if (lastLevel != nostate) {
  253. ret = true;
  254. if (m_onirq) {
  255. if (lastLevel)
  256. m_onirq(this, kRisingIrqEvent);
  257. else
  258. m_onirq(this, kFallingIrqEvent);
  259. }
  260. }
  261. }
  262. lastLevel = nostate;
  263. return ret;
  264. }
  265. void ZGPIO::toggleState() { HAL_GPIO_TogglePin(m_gpio, m_pinoff); }
  266. uint32_t ZGPIO::getStateUint32() {
  267. if (getState())
  268. return 1;
  269. else
  270. return 0;
  271. }
  272. bool ZGPIO::getState() {
  273. bool ret = false;
  274. if (HAL_GPIO_ReadPin(m_gpio, m_pinoff) == GPIO_PIN_SET) {
  275. ret = true;
  276. } else {
  277. ret = false;
  278. }
  279. if (m_mirror) ret = !ret;
  280. return ret;
  281. }
  282. bool ZGPIO::setState(bool state) {
  283. if (m_mirror) state = !state;
  284. if (state) {
  285. HAL_GPIO_WritePin(m_gpio, m_pinoff, GPIO_PIN_SET);
  286. } else {
  287. HAL_GPIO_WritePin(m_gpio, m_pinoff, GPIO_PIN_RESET);
  288. }
  289. return true;
  290. }
  291. IRQn_Type ZGPIO::getEXTIIRQn() {
  292. switch (m_pinoff) {
  293. case GPIO_PIN_0:
  294. return EXTI0_IRQn;
  295. case GPIO_PIN_1:
  296. return EXTI1_IRQn;
  297. case GPIO_PIN_2:
  298. return EXTI2_IRQn;
  299. case GPIO_PIN_3:
  300. return EXTI3_IRQn;
  301. case GPIO_PIN_4:
  302. return EXTI4_IRQn;
  303. case GPIO_PIN_5:
  304. case GPIO_PIN_6:
  305. case GPIO_PIN_7:
  306. case GPIO_PIN_8:
  307. case GPIO_PIN_9:
  308. return EXTI9_5_IRQn;
  309. case GPIO_PIN_10:
  310. case GPIO_PIN_11:
  311. case GPIO_PIN_12:
  312. case GPIO_PIN_13:
  313. case GPIO_PIN_14:
  314. case GPIO_PIN_15:
  315. return EXTI15_10_IRQn;
  316. default:
  317. ZEARLY_ASSERT(0);
  318. }
  319. return EXTI0_IRQn;
  320. }
  321. /**
  322. * @brief ʼGPIOΪжģ??
  323. *
  324. * @param pull GPIO_NOPULL, GPIO_PULLUP, GPIO_PULLDOWN
  325. * @param mode GPIO_MODE_IT_RISING, GPIO_MODE_IT_FALLING, GPIO_MODE_IT_RISING_FALLING
  326. * @return true
  327. * @return false
  328. */
  329. } // namespace iflytop