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.

441 lines
15 KiB

11 months ago
9 months ago
12 months ago
11 months ago
12 months ago
11 months ago
12 months ago
11 months ago
11 months ago
11 months ago
9 months ago
12 months ago
11 months ago
12 months ago
9 months ago
12 months ago
11 months ago
12 months ago
9 months ago
11 months ago
11 months ago
9 months ago
11 months ago
9 months ago
11 months ago
9 months ago
11 months ago
9 months ago
11 months ago
9 months ago
11 months ago
9 months ago
11 months ago
9 months ago
11 months ago
9 months ago
11 months ago
9 months ago
11 months ago
9 months ago
11 months ago
9 months ago
9 months ago
9 months ago
9 months ago
  1. #include "apphal.hpp"
  2. #include "uappbase\appcfg\appcfg.hpp"
  3. using namespace iflytop;
  4. void AppHal::MX_TIM6_Init(void) {
  5. __HAL_RCC_TIM6_CLK_ENABLE();
  6. TIM_MasterConfigTypeDef sMasterConfig = {0};
  7. htim6.Instance = TIM6;
  8. htim6.Init.Prescaler = 71;
  9. htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
  10. htim6.Init.Period = 65535;
  11. htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  12. if (HAL_TIM_Base_Init(&htim6) != HAL_OK) {
  13. Error_Handler();
  14. }
  15. sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  16. sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  17. if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK) {
  18. Error_Handler();
  19. }
  20. /* TIM6 interrupt Init */
  21. HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 5, 0);
  22. HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
  23. }
  24. /* TIM7 init function */
  25. void AppHal::MX_TIM7_Init(void) {
  26. __HAL_RCC_TIM7_CLK_ENABLE();
  27. TIM_MasterConfigTypeDef sMasterConfig = {0};
  28. htim7.Instance = TIM7;
  29. htim7.Init.Prescaler = 81;
  30. htim7.Init.CounterMode = TIM_COUNTERMODE_UP;
  31. htim7.Init.Period = 65535;
  32. htim7.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  33. if (HAL_TIM_Base_Init(&htim7) != HAL_OK) {
  34. Error_Handler();
  35. }
  36. sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  37. sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  38. if (HAL_TIMEx_MasterConfigSynchronization(&htim7, &sMasterConfig) != HAL_OK) {
  39. Error_Handler();
  40. }
  41. /* TIM7 interrupt Init */
  42. HAL_NVIC_SetPriority(TIM7_IRQn, 5, 0);
  43. HAL_NVIC_EnableIRQ(TIM7_IRQn);
  44. }
  45. #define EARLY_ASSERT(exptr) \
  46. if (!(exptr)) { \
  47. while (true) { \
  48. } \
  49. }
  50. void AppHal::DEBUG_UART_INIT(Pin_t tx, Pin_t rx, int32_t baudrate) {
  51. #if (DEBUG_UART_INDEX == 1)
  52. GPIO_InitTypeDef GPIO_InitStruct = {0};
  53. __HAL_RCC_USART1_CLK_ENABLE();
  54. __HAL_RCC_GPIOA_CLK_ENABLE();
  55. __HAL_RCC_DMA2_CLK_ENABLE();
  56. if (tx == PA9 && rx == PA10) {
  57. GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10;
  58. GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  59. GPIO_InitStruct.Pull = GPIO_NOPULL;
  60. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  61. GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
  62. HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  63. } else if (tx == PB6 && rx == PB7) {
  64. GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7;
  65. GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  66. GPIO_InitStruct.Pull = GPIO_NOPULL;
  67. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  68. GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
  69. HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  70. } else {
  71. EARLY_ASSERT(false);
  72. }
  73. huart1.Instance = USART1;
  74. huart1.Init.BaudRate = baudrate;
  75. huart1.Init.WordLength = UART_WORDLENGTH_8B;
  76. huart1.Init.StopBits = UART_STOPBITS_1;
  77. huart1.Init.Parity = UART_PARITY_NONE;
  78. huart1.Init.Mode = UART_MODE_TX_RX;
  79. huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  80. huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  81. if (HAL_UART_Init(&huart1) != HAL_OK) {
  82. Error_Handler();
  83. }
  84. HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0);
  85. HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
  86. hdma2_stream2.Instance = DMA2_Stream2;
  87. hdma2_stream2.Init.Channel = DMA_CHANNEL_4;
  88. hdma2_stream2.Init.Direction = DMA_PERIPH_TO_MEMORY;
  89. hdma2_stream2.Init.PeriphInc = DMA_PINC_DISABLE;
  90. hdma2_stream2.Init.MemInc = DMA_MINC_ENABLE;
  91. hdma2_stream2.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  92. hdma2_stream2.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  93. hdma2_stream2.Init.Mode = DMA_NORMAL;
  94. hdma2_stream2.Init.Priority = DMA_PRIORITY_LOW;
  95. hdma2_stream2.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  96. if (HAL_DMA_Init(&hdma2_stream2) != HAL_OK) {
  97. Error_Handler();
  98. }
  99. __HAL_LINKDMA(&huart1, hdmarx, hdma2_stream2);
  100. HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
  101. HAL_NVIC_EnableIRQ(USART1_IRQn);
  102. #else
  103. #error "DEBUG_UART_INDEX not supported"
  104. #endif
  105. }
  106. void AppHal::MX_IWDG_Init(void) {
  107. hiwdg.Instance = IWDG;
  108. hiwdg.Init.Prescaler = IWDG_PRESCALER_64;
  109. hiwdg.Init.Reload = 4095;
  110. if (HAL_IWDG_Init(&hiwdg) != HAL_OK) {
  111. Error_Handler();
  112. }
  113. }
  114. void AppHal::UART3_Init(Pin_t tx, Pin_t rx, int32_t baudrate) {
  115. GPIO_InitTypeDef GPIO_InitStruct = {0};
  116. __HAL_RCC_USART3_CLK_ENABLE();
  117. __HAL_RCC_GPIOB_CLK_ENABLE();
  118. __HAL_RCC_DMA1_CLK_ENABLE();
  119. huart3.Instance = USART3;
  120. huart3.Init.BaudRate = baudrate;
  121. huart3.Init.WordLength = UART_WORDLENGTH_8B;
  122. huart3.Init.StopBits = UART_STOPBITS_1;
  123. huart3.Init.Parity = UART_PARITY_NONE;
  124. huart3.Init.Mode = UART_MODE_TX_RX;
  125. huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  126. huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  127. if (HAL_UART_Init(&huart3) != HAL_OK) {
  128. Error_Handler();
  129. }
  130. if (tx == PB10 && rx == PB11) {
  131. __HAL_RCC_GPIOB_CLK_ENABLE();
  132. GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_11;
  133. GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  134. GPIO_InitStruct.Pull = GPIO_NOPULL;
  135. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  136. GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
  137. HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  138. } else if (tx == PD8 && rx == PD9) {
  139. __HAL_RCC_GPIOD_CLK_ENABLE();
  140. GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9;
  141. GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  142. GPIO_InitStruct.Pull = GPIO_NOPULL;
  143. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  144. GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
  145. HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
  146. } else {
  147. ASSERT(false, "UART3 NOT SUPPORT PIN");
  148. }
  149. hdma1_stream1.Instance = DMA1_Stream1;
  150. hdma1_stream1.Init.Channel = DMA_CHANNEL_4;
  151. hdma1_stream1.Init.Direction = DMA_PERIPH_TO_MEMORY;
  152. hdma1_stream1.Init.PeriphInc = DMA_PINC_DISABLE;
  153. hdma1_stream1.Init.MemInc = DMA_MINC_ENABLE;
  154. hdma1_stream1.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  155. hdma1_stream1.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  156. hdma1_stream1.Init.Mode = DMA_NORMAL;
  157. hdma1_stream1.Init.Priority = DMA_PRIORITY_LOW;
  158. hdma1_stream1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  159. if (HAL_DMA_Init(&hdma1_stream1) != HAL_OK) {
  160. Error_Handler();
  161. }
  162. __HAL_LINKDMA(&huart3, hdmarx, hdma1_stream1);
  163. hdma1_stream3.Instance = DMA1_Stream3;
  164. hdma1_stream3.Init.Channel = DMA_CHANNEL_4;
  165. hdma1_stream3.Init.Direction = DMA_MEMORY_TO_PERIPH;
  166. hdma1_stream3.Init.PeriphInc = DMA_PINC_DISABLE;
  167. hdma1_stream3.Init.MemInc = DMA_MINC_ENABLE;
  168. hdma1_stream3.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  169. hdma1_stream3.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  170. hdma1_stream3.Init.Mode = DMA_NORMAL;
  171. hdma1_stream3.Init.Priority = DMA_PRIORITY_LOW;
  172. hdma1_stream3.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  173. if (HAL_DMA_Init(&hdma1_stream3) != HAL_OK) {
  174. Error_Handler();
  175. }
  176. __HAL_LINKDMA(&huart3, hdmatx, hdma1_stream3);
  177. HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 5, 0);
  178. HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
  179. HAL_NVIC_SetPriority(DMA1_Stream3_IRQn, 5, 0);
  180. HAL_NVIC_EnableIRQ(DMA1_Stream3_IRQn);
  181. HAL_NVIC_SetPriority(USART3_IRQn, 5, 0);
  182. HAL_NVIC_EnableIRQ(USART3_IRQn);
  183. }
  184. /**
  185. * @brief
  186. */
  187. void AppHal::UART4_Init(Pin_t tx, Pin_t rx, int32_t baudrate) {
  188. GPIO_InitTypeDef GPIO_InitStruct = {0};
  189. __HAL_RCC_UART4_CLK_ENABLE();
  190. __HAL_RCC_GPIOC_CLK_ENABLE();
  191. huart4.Instance = UART4;
  192. huart4.Init.BaudRate = baudrate; // 256000
  193. huart4.Init.WordLength = UART_WORDLENGTH_8B;
  194. huart4.Init.StopBits = UART_STOPBITS_1;
  195. huart4.Init.Parity = UART_PARITY_NONE;
  196. huart4.Init.Mode = UART_MODE_TX_RX;
  197. huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  198. huart4.Init.OverSampling = UART_OVERSAMPLING_16;
  199. if (HAL_UART_Init(&huart4) != HAL_OK) {
  200. Error_Handler();
  201. }
  202. /**UART4 GPIO Configuration
  203. PC10 ------> UART4_TX
  204. PC11 ------> UART4_RX
  205. */
  206. if (tx == PC10 && rx == PC11) {
  207. GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_11;
  208. GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  209. GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  210. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  211. GPIO_InitStruct.Alternate = GPIO_AF8_UART4;
  212. HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  213. } else {
  214. ASSERT(false, "UART4 NOT SUPPORT PIN");
  215. }
  216. /* UART4 interrupt Init */
  217. HAL_NVIC_SetPriority(UART4_IRQn, 5, 0);
  218. HAL_NVIC_EnableIRQ(UART4_IRQn);
  219. /***********************************************************************************************************************
  220. * DMA_INIT *
  221. ***********************************************************************************************************************/
  222. /* UART4 DMA Init */
  223. /* UART4_RX Init */
  224. hdma1_stream2.Instance = DMA1_Stream2;
  225. hdma1_stream2.Init.Channel = DMA_CHANNEL_4;
  226. hdma1_stream2.Init.Direction = DMA_PERIPH_TO_MEMORY;
  227. hdma1_stream2.Init.PeriphInc = DMA_PINC_DISABLE;
  228. hdma1_stream2.Init.MemInc = DMA_MINC_ENABLE;
  229. hdma1_stream2.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  230. hdma1_stream2.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  231. hdma1_stream2.Init.Mode = DMA_NORMAL;
  232. hdma1_stream2.Init.Priority = DMA_PRIORITY_LOW;
  233. hdma1_stream2.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  234. if (HAL_DMA_Init(&hdma1_stream2) != HAL_OK) {
  235. Error_Handler();
  236. }
  237. __HAL_LINKDMA(&huart4, hdmarx, hdma1_stream2);
  238. /* UART4_TX Init */
  239. hdma1_stream4.Instance = DMA1_Stream4;
  240. hdma1_stream4.Init.Channel = DMA_CHANNEL_4;
  241. hdma1_stream4.Init.Direction = DMA_MEMORY_TO_PERIPH;
  242. hdma1_stream4.Init.PeriphInc = DMA_PINC_DISABLE;
  243. hdma1_stream4.Init.MemInc = DMA_MINC_ENABLE;
  244. hdma1_stream4.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  245. hdma1_stream4.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  246. hdma1_stream4.Init.Mode = DMA_NORMAL;
  247. hdma1_stream4.Init.Priority = DMA_PRIORITY_LOW;
  248. hdma1_stream4.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  249. if (HAL_DMA_Init(&hdma1_stream4) != HAL_OK) {
  250. Error_Handler();
  251. }
  252. __HAL_LINKDMA(&huart4, hdmatx, hdma1_stream4);
  253. }
  254. void AppHal::MX_I2C1_Init(void) {
  255. __HAL_RCC_GPIOB_CLK_ENABLE();
  256. __HAL_RCC_I2C1_CLK_ENABLE();
  257. hi2c1.Instance = I2C1;
  258. hi2c1.Init.ClockSpeed = 400000;
  259. hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  260. hi2c1.Init.OwnAddress1 = 0;
  261. hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  262. hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  263. hi2c1.Init.OwnAddress2 = 0;
  264. hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  265. hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  266. if (HAL_I2C_Init(&hi2c1) != HAL_OK) {
  267. Error_Handler();
  268. }
  269. GPIO_InitTypeDef GPIO_InitStruct = {0};
  270. /**I2C1 GPIO Configuration
  271. PB8 ------> I2C1_SCL
  272. PB9 ------> I2C1_SDA
  273. */
  274. GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9;
  275. GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
  276. GPIO_InitStruct.Pull = GPIO_NOPULL;
  277. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  278. GPIO_InitStruct.Alternate = GPIO_AF4_I2C1;
  279. HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  280. }
  281. void AppHal::tmc_spi_init() {
  282. #if (MOTOR_SPI_INDEX == 1)
  283. __HAL_RCC_SPI1_CLK_ENABLE();
  284. __HAL_RCC_GPIOA_CLK_ENABLE();
  285. static_assert(&MOTOR_SPI_INS == &hspi1);
  286. hspi1.Instance = SPI1;
  287. hspi1.Init.Mode = SPI_MODE_MASTER;
  288. hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  289. hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  290. hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  291. hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  292. hspi1.Init.NSS = SPI_NSS_SOFT;
  293. hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
  294. hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  295. hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  296. hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  297. hspi1.Init.CRCPolynomial = 10;
  298. if (HAL_SPI_Init(&hspi1) != HAL_OK) {
  299. Error_Handler();
  300. }
  301. static_assert(MOTOR_SPI_SCK == PA5);
  302. static_assert(MOTOR_SPI_SDO == PA6);
  303. static_assert(MOTOR_SPI_SDI == PA7);
  304. GPIO_InitTypeDef GPIO_InitStruct = {0};
  305. GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7;
  306. GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  307. GPIO_InitStruct.Pull = GPIO_NOPULL;
  308. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  309. GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
  310. HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  311. #else
  312. #error "MOTOR_SPI_INDEX not supported"
  313. #endif
  314. }
  315. void AppHal::rtc_init() {
  316. RTC_TimeTypeDef sTime = {0};
  317. RTC_DateTypeDef sDate = {0};
  318. RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
  319. PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
  320. PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
  321. if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) {
  322. Error_Handler();
  323. }
  324. __HAL_RCC_RTC_ENABLE();
  325. /** Initialize RTC Only
  326. */
  327. hrtc.Instance = RTC;
  328. hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
  329. hrtc.Init.AsynchPrediv = 127;
  330. hrtc.Init.SynchPrediv = 255;
  331. hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
  332. hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  333. hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  334. if (HAL_RTC_Init(&hrtc) != HAL_OK) {
  335. Error_Handler();
  336. }
  337. /** Initialize RTC and set the Time and Date
  338. */
  339. sTime.Hours = 0x0;
  340. sTime.Minutes = 0x0;
  341. sTime.Seconds = 0x0;
  342. sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
  343. sTime.StoreOperation = RTC_STOREOPERATION_RESET;
  344. if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK) {
  345. Error_Handler();
  346. }
  347. sDate.WeekDay = 0x01;
  348. sDate.Month = 0x1;
  349. sDate.Date = 0x1;
  350. sDate.Year = 0x24;
  351. if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK) {
  352. Error_Handler();
  353. }
  354. }
  355. void AppHal::usb_init() {
  356. GPIO_InitTypeDef GPIO_InitStruct = {0};
  357. __HAL_RCC_GPIOA_CLK_ENABLE();
  358. /**USB_OTG_FS GPIO Configuration
  359. PA11 ------> USB_OTG_FS_DM
  360. PA12 ------> USB_OTG_FS_DP
  361. */
  362. GPIO_InitStruct.Pin = GPIO_PIN_11 | GPIO_PIN_12;
  363. GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  364. GPIO_InitStruct.Pull = GPIO_NOPULL;
  365. GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  366. GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;
  367. HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  368. __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
  369. hhcd_USB_OTG_FS.Instance = USB_OTG_FS;
  370. hhcd_USB_OTG_FS.Init.Host_channels = 8;
  371. hhcd_USB_OTG_FS.Init.speed = HCD_SPEED_FULL;
  372. hhcd_USB_OTG_FS.Init.dma_enable = DISABLE;
  373. hhcd_USB_OTG_FS.Init.phy_itface = HCD_PHY_EMBEDDED;
  374. hhcd_USB_OTG_FS.Init.Sof_enable = DISABLE;
  375. if (HAL_HCD_Init(&hhcd_USB_OTG_FS) != HAL_OK) {
  376. Error_Handler();
  377. }
  378. #if 0
  379. __HAL_RCC_USB_OTG_FS_CLK_DISABLE();
  380. /**USB_OTG_FS GPIO Configuration
  381. PA11 ------> USB_OTG_FS_DM
  382. PA12 ------> USB_OTG_FS_DP
  383. */
  384. HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11|GPIO_PIN_12);
  385. #endif
  386. }