设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › stm32餐厨油烟在线监测代码
返回列表 发新帖
查看: 2347|回复: 3
收起左侧

stm32餐厨油烟在线监测代码

[复制链接]
ID:426765 发表于 2018-11-14 23:25 | 显示全部楼层 |阅读模式
餐厨油烟监测项目，采集油烟浓度，压力，温湿度，通过GPRS上传数据中心。

单片机源程序如下:
  1. /* Includes ------------------------------------------------------------------*/
  2. #include "main.h"
  3. #include "stm32f2xx_hal.h"
  4. #include "cmsis_os.h"
  5. #include "fatfs.h"
  6. #include "usb_device.h"

  8. /* USER CODE BEGIN Includes */

  10. /* USER CODE END Includes */

  12. /* Private variables ---------------------------------------------------------*/
  13. CRC_HandleTypeDef hcrc;

  15. IWDG_HandleTypeDef hiwdg;

  17. RTC_HandleTypeDef hrtc;

  19. SD_HandleTypeDef hsd;

  21. SPI_HandleTypeDef hspi1;

  23. TIM_HandleTypeDef htim2;

  25. UART_HandleTypeDef huart4;
  26. UART_HandleTypeDef huart1;
  27. UART_HandleTypeDef huart2;
  28. UART_HandleTypeDef huart3;
  29. UART_HandleTypeDef huart6;
  30. DMA_HandleTypeDef hdma_usart1_rx;
  31. DMA_HandleTypeDef hdma_usart3_rx;
  32. DMA_HandleTypeDef hdma_usart6_rx;

  34. osThreadId defaultTaskHandle;

  36. /* USER CODE BEGIN PV */
  37. /* Private variables ---------------------------------------------------------*/

  39. /* USER CODE END PV */

  41. /* Private function prototypes -----------------------------------------------*/
  42. void SystemClock_Config(void);
  43. static void MX_GPIO_Init(void);
  44. static void MX_DMA_Init(void);
  45. static void MX_SDIO_SD_Init(void);
  46. static void MX_SPI1_Init(void);
  47. static void MX_UART4_Init(void);
  48. static void MX_USART1_UART_Init(void);
  49. static void MX_USART2_UART_Init(void);
  50. static void MX_USART3_UART_Init(void);
  51. static void MX_USART6_UART_Init(void);
  52. static void MX_RTC_Init(void);
  53. static void MX_IWDG_Init(void);
  54. static void MX_TIM2_Init(void);
  55. static void MX_CRC_Init(void);
  56. void StartDefaultTask(void const * argument);

  58. /* USER CODE BEGIN PFP */
  59. /* Private function prototypes -----------------------------------------------*/

  61. /* USER CODE END PFP */

  63. /* USER CODE BEGIN 0 */

  65. /* USER CODE END 0 */

  67. int main(void)
  68. {

  70.   /* USER CODE BEGIN 1 */

  72.   /* USER CODE END 1 */

  74.   /* MCU Configuration----------------------------------------------------------*/

  76.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  77.   HAL_Init();

  79.   /* USER CODE BEGIN Init */

  81.   /* USER CODE END Init */

  83.   /* Configure the system clock */
  84.   SystemClock_Config();

  86.   /* USER CODE BEGIN SysInit */

  88.   /* USER CODE END SysInit */

  90.   /* Initialize all configured peripherals */
  91.   MX_GPIO_Init();
  92.   MX_DMA_Init();
  93.   MX_SDIO_SD_Init();
  94.   MX_SPI1_Init();
  95.   MX_UART4_Init();
  96.   MX_USART1_UART_Init();
  97.   MX_USART2_UART_Init();
  98.   MX_USART3_UART_Init();
  99.   MX_USART6_UART_Init();
  100.   MX_RTC_Init();
  101.   MX_IWDG_Init();
  102.   MX_TIM2_Init();
  103.   MX_CRC_Init();

  105.   /* USER CODE BEGIN 2 */

  107.   /* USER CODE END 2 */

  109.   /* USER CODE BEGIN RTOS_MUTEX */
  110.   /* add mutexes, ... */
  111.   /* USER CODE END RTOS_MUTEX */

  113.   /* USER CODE BEGIN RTOS_SEMAPHORES */
  114.   /* add semaphores, ... */
  115.   /* USER CODE END RTOS_SEMAPHORES */

  117.   /* USER CODE BEGIN RTOS_TIMERS */
  118.   /* start timers, add new ones, ... */
  119.   /* USER CODE END RTOS_TIMERS */

  121.   /* Create the thread(s) */
  122.   /* definition and creation of defaultTask */
  123.   osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 768);
  124.   defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);

  126.   /* USER CODE BEGIN RTOS_THREADS */
  127.   /* add threads, ... */
  128.   /* USER CODE END RTOS_THREADS */

  130.   /* USER CODE BEGIN RTOS_QUEUES */
  131.   /* add queues, ... */
  132.   /* USER CODE END RTOS_QUEUES */


  135.   /* Start scheduler */
  136.   osKernelStart();
  137.   
  138.   /* We should never get here as control is now taken by the scheduler */

  140.   /* Infinite loop */
  141.   /* USER CODE BEGIN WHILE */
  142.   while (1)
  143.   {
  144.   /* USER CODE END WHILE */

  146.   /* USER CODE BEGIN 3 */

  148.   }
  149.   /* USER CODE END 3 */

  151. }

  153. /** System Clock Configuration
  154. */
  155. void SystemClock_Config(void)
  156. {

  158.   RCC_OscInitTypeDef RCC_OscInitStruct;
  159.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
  160.   RCC_PeriphCLKInitTypeDef PeriphClkInitStruct;

  162.     /**Initializes the CPU, AHB and APB busses clocks
  163.     */
  164.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI|RCC_OSCILLATORTYPE_HSE
  165.                               |RCC_OSCILLATORTYPE_LSE;
  166.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  167.   RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  168.   RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  169.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  170.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  171.   RCC_OscInitStruct.PLL.PLLM = 20;
  172.   RCC_OscInitStruct.PLL.PLLN = 192;
  173.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  174.   RCC_OscInitStruct.PLL.PLLQ = 5;
  175.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  176.   {
  177.     _Error_Handler(__FILE__, __LINE__);
  178.   }

  180.     /**Initializes the CPU, AHB and APB busses clocks
  181.     */
  182.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  183.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  184.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  185.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  186.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  187.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  189.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
  190.   {
  191.     _Error_Handler(__FILE__, __LINE__);
  192.   }

  194.   PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
  195.   PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
  196.   if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
  197.   {
  198.     _Error_Handler(__FILE__, __LINE__);
  199.   }

  201.     /**Configure the Systick interrupt time
  202.     */
  203.   HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

  205.     /**Configure the Systick
  206.     */
  207.   HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

  209.   /* SysTick_IRQn interrupt configuration */
  210.   HAL_NVIC_SetPriority(SysTick_IRQn, 15, 0);
  211. }

  213. /* CRC init function */
  214. static void MX_CRC_Init(void)
  215. {

  217.   hcrc.Instance = CRC;
  218.   if (HAL_CRC_Init(&hcrc) != HAL_OK)
  219.   {
  220.     _Error_Handler(__FILE__, __LINE__);
  221.   }

  223. }

  225. /* IWDG init function */
  226. static void MX_IWDG_Init(void)
  227. {

  229.   hiwdg.Instance = IWDG;
  230.   hiwdg.Init.Prescaler = IWDG_PRESCALER_256;
  231.   hiwdg.Init.Reload = 4095;
  232.   if (HAL_IWDG_Init(&hiwdg) != HAL_OK)
  233.   {
  234.     _Error_Handler(__FILE__, __LINE__);
  235.   }

  237. }

  239. /* RTC init function */
  240. static void MX_RTC_Init(void)
  241. {

  243.   RTC_TimeTypeDef sTime;
  244.   RTC_DateTypeDef sDate;

  246.     /**Initialize RTC Only
  247.     */
  248.   hrtc.Instance = RTC;
  249.   hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
  250.   hrtc.Init.AsynchPrediv = 127;
  251.   hrtc.Init.SynchPrediv = 255;
  252.   hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
  253.   hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  254.   hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  255.   if (HAL_RTC_Init(&hrtc) != HAL_OK)
  256.   {
  257.     _Error_Handler(__FILE__, __LINE__);
  258.   }

  260.     /**Initialize RTC and set the Time and Date
  261.     */
  262.   if(HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR0) != 0x32F2){
  263.   sTime.Hours = 20;
  264.   sTime.Minutes = 42;
  265.   sTime.Seconds = 42;
  266.   sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
  267.   sTime.StoreOperation = RTC_STOREOPERATION_RESET;
  268.   if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
  269.   {
  270.     _Error_Handler(__FILE__, __LINE__);
  271.   }

  273.   sDate.WeekDay = RTC_WEEKDAY_SUNDAY;
  274.   sDate.Month = RTC_MONTH_APRIL;
  275.   sDate.Date = 30;
  276.   sDate.Year = 0;

  278.   if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)
  279.   {
  280.     _Error_Handler(__FILE__, __LINE__);
  281.   }

  283.     HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR0,0x32F2);
  284.   }

  286. }

  288. /* SDIO init function */
  289. static void MX_SDIO_SD_Init(void)
  290. {

  292.   hsd.Instance = SDIO;
  293.   hsd.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
  294.   hsd.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
  295.   hsd.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
  296.   hsd.Init.BusWide = SDIO_BUS_WIDE_1B;
  297.   hsd.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
  298.   hsd.Init.ClockDiv = 0;

  300. }

  302. /* SPI1 init function */
  303. static void MX_SPI1_Init(void)
  304. {

  306.   hspi1.Instance = SPI1;
  307.   hspi1.Init.Mode = SPI_MODE_MASTER;
  308.   hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  309.   hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  310.   hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  311.   hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  312.   hspi1.Init.NSS = SPI_NSS_HARD_OUTPUT;
  313.   hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  314.   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  315.   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  316.   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  317.   hspi1.Init.CRCPolynomial = 10;
  318.   if (HAL_SPI_Init(&hspi1) != HAL_OK)
  319.   {
  320.     _Error_Handler(__FILE__, __LINE__);
  321.   }

  323. }

  325. /* TIM2 init function */
  326. static void MX_TIM2_Init(void)
  327. {

  329.   TIM_ClockConfigTypeDef sClockSourceConfig;
  330.   TIM_MasterConfigTypeDef sMasterConfig;

  332.   htim2.Instance = TIM2;
  333.   htim2.Init.Prescaler = 0;
  334.   htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  335.   htim2.Init.Period = 0;
  336.   htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  337.   htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  338.   if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  339.   {
  340.     _Error_Handler(__FILE__, __LINE__);
  341.   }

  343.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  344.   if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  345.   {
  346.     _Error_Handler(__FILE__, __LINE__);
  347.   }

  349.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  350.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  351.   if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  352.   {
  353.     _Error_Handler(__FILE__, __LINE__);
  354.   }

  356. }

  358. /* UART4 init function */
  359. static void MX_UART4_Init(void)
  360. {

  362.   huart4.Instance = UART4;
  363.   huart4.Init.BaudRate = 115200;
  364.   huart4.Init.WordLength = UART_WORDLENGTH_8B;
  365.   huart4.Init.StopBits = UART_STOPBITS_1;
  366.   huart4.Init.Parity = UART_PARITY_NONE;
  367.   huart4.Init.Mode = UART_MODE_TX_RX;
  368.   huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  369.   huart4.Init.OverSampling = UART_OVERSAMPLING_16;
  370.   if (HAL_UART_Init(&huart4) != HAL_OK)
  371.   {
  372.     _Error_Handler(__FILE__, __LINE__);
  373.   }

  375. }

  377. /* USART1 init function */
  378. static void MX_USART1_UART_Init(void)
  379. {

  381.   huart1.Instance = USART1;
  382.   huart1.Init.BaudRate = 115200;
  383.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
  384.   huart1.Init.StopBits = UART_STOPBITS_1;
  385.   huart1.Init.Parity = UART_PARITY_NONE;
  386.   huart1.Init.Mode = UART_MODE_TX_RX;
  387.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  388.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  389.   if (HAL_UART_Init(&huart1) != HAL_OK)
  390.   {
  391.     _Error_Handler(__FILE__, __LINE__);
  392.   }

  394. }

  396. /* USART2 init function */
  397. static void MX_USART2_UART_Init(void)
  398. {

  400.   huart2.Instance = USART2;
  401.   huart2.Init.BaudRate = 115200;
  402.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
  403.   huart2.Init.StopBits = UART_STOPBITS_1;
  404.   huart2.Init.Parity = UART_PARITY_NONE;
  405.   huart2.Init.Mode = UART_MODE_TX_RX;
  406.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  407.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  408.   if (HAL_UART_Init(&huart2) != HAL_OK)
  409.   {
  410.     _Error_Handler(__FILE__, __LINE__);
  411.   }

  413. }

  415. /* USART3 init function */
  416. static void MX_USART3_UART_Init(void)
  417. {

  419.   huart3.Instance = USART3;
  420.   huart3.Init.BaudRate = 115200;
  421.   huart3.Init.WordLength = UART_WORDLENGTH_8B;
  422.   huart3.Init.StopBits = UART_STOPBITS_1;
  423.   huart3.Init.Parity = UART_PARITY_NONE;
  424.   huart3.Init.Mode = UART_MODE_TX_RX;
  425.   huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  426.   huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  427.   if (HAL_UART_Init(&huart3) != HAL_OK)
  428.   {
  429.     _Error_Handler(__FILE__, __LINE__);
  430.   }

  432. }

  434. /* USART6 init function */
  435. static void MX_USART6_UART_Init(void)
  436. {

  438.   huart6.Instance = USART6;
  439.   huart6.Init.BaudRate = 115200;
  440.   huart6.Init.WordLength = UART_WORDLENGTH_8B;
  441.   huart6.Init.StopBits = UART_STOPBITS_1;
  442.   huart6.Init.Parity = UART_PARITY_NONE;
  443.   huart6.Init.Mode = UART_MODE_TX_RX;
  444.   huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  445.   huart6.Init.OverSampling = UART_OVERSAMPLING_16;
  446.   if (HAL_UART_Init(&huart6) != HAL_OK)
  447.   {
  448.     _Error_Handler(__FILE__, __LINE__);
  449.   }

  451. }

  453. /**
  454.   * Enable DMA controller clock
  455.   */
  456. static void MX_DMA_Init(void)
  457. {
  458.   /* DMA controller clock enable */
  459.   __HAL_RCC_DMA2_CLK_ENABLE();
  460.   __HAL_RCC_DMA1_CLK_ENABLE();

  462.   /* DMA interrupt init */
  463.   /* DMA1_Stream1_IRQn interrupt configuration */
  464.   HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 5, 0);
  465.   HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
  466.   /* DMA2_Stream2_IRQn interrupt configuration */
  467.   HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0);
  468.   HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
  469.   /* DMA2_Stream5_IRQn interrupt configuration */
  470.   HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 5, 0);
  471.   HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn);

  473. }

  475. /** Configure pins as
  476.         * Analog
  477.         * Input
  478.         * Output
  479.         * EVENT_OUT
  480.         * EXTI
  481. */
  482. static void MX_GPIO_Init(void)
  483. {

  485.   GPIO_InitTypeDef GPIO_InitStruct;

  487.   /* GPIO Ports Clock Enable */
  488.   __HAL_RCC_GPIOC_CLK_ENABLE();
  489.   __HAL_RCC_GPIOH_CLK_ENABLE();
  490.   __HAL_RCC_GPIOA_CLK_ENABLE();
  491.   __HAL_RCC_GPIOB_CLK_ENABLE();
  492.   __HAL_RCC_GPIOD_CLK_ENABLE();

  494.   /*Configure GPIO pin Output Level */
  495.   HAL_GPIO_WritePin(GPIOC, LED5_Pin|LED4_Pin|LED3_Pin|LED2_Pin
  496.                           |LED1_Pin|W5500RST_Pin, GPIO_PIN_RESET);

  498.   /*Configure GPIO pin Output Level */
  499.   HAL_GPIO_WritePin(GPIOB, C485E_Pin|JDQ1_Pin|JDQ2_Pin|LED6_Pin, GPIO_PIN_RESET);

  501.   /*Configure GPIO pin Output Level */
  502.   HAL_GPIO_WritePin(CGE_GPIO_Port, CGE_Pin, GPIO_PIN_RESET);

  504.   /*Configure GPIO pins : LED5_Pin LED4_Pin LED3_Pin LED2_Pin
  505.                            LED1_Pin W5500RST_Pin */
  506.   GPIO_InitStruct.Pin = LED5_Pin|LED4_Pin|LED3_Pin|LED2_Pin
  507.                           |LED1_Pin|W5500RST_Pin;
  508.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  509.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  510.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  511.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  513.   /*Configure GPIO pin : W5500INT_Pin */
  514.   GPIO_InitStruct.Pin = W5500INT_Pin;
  515.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  516.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  517.   HAL_GPIO_Init(W5500INT_GPIO_Port, &GPIO_InitStruct);

  519.   /*Configure GPIO pins : JDSR1_Pin JDSR2_Pin BUSY_Pin */
  520.   GPIO_InitStruct.Pin = JDSR1_Pin|JDSR2_Pin|BUSY_Pin;
  521.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  522.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  523.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  525.   /*Configure GPIO pin : C485E_Pin */
  526.   GPIO_InitStruct.Pin = C485E_Pin;
  527.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  528.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  529.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
  530.   HAL_GPIO_Init(C485E_GPIO_Port, &GPIO_InitStruct);

  532.   /*Configure GPIO pins : JDQ1_Pin JDQ2_Pin LED6_Pin */
  533.   GPIO_InitStruct.Pin = JDQ1_Pin|JDQ2_Pin|LED6_Pin;
  534.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  535.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  536.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  537.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  539.   /*Configure GPIO pin : CGE_Pin */
  540.   GPIO_InitStruct.Pin = CGE_Pin;
  541.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  542.   GPIO_InitStruct.Pull = GPIO_NOPULL;
  543.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
  544.   HAL_GPIO_Init(CGE_GPIO_Port, &GPIO_InitStruct);

  546.   /*Configure GPIO pins : KEY6_Pin KEY5_Pin KEY4_Pin KEY3_Pin
  547.                            KEY2_Pin KEY1_Pin */
  548.   GPIO_InitStruct.Pin = KEY6_Pin|KEY5_Pin|KEY4_Pin|KEY3_Pin
  549.                           |KEY2_Pin|KEY1_Pin;
  550.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  551.   GPIO_InitStruct.Pull = GPIO_PULLUP;
  552.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  554. }

  556. /* USER CODE BEGIN 4 */

  558. /* USER CODE END 4 */

  560. /* StartDefaultTask function */
  561. void StartDefaultTask(void const * argument)
  562. {
  563.   /* init code for USB_DEVICE */
  564.   MX_USB_DEVICE_Init();

  566.   /* init code for FATFS */
  567.   MX_FATFS_Init();

  569.   /* USER CODE BEGIN 5 */
  570.   /* Infinite loop */
  571.   for(;;)
  572.   {
  573.     osDelay(1);
  574.   }
  575.   /* USER CODE END 5 */
  576. ……………………

  578. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
CNB.zip (880.87 KB, 下载次数: 21)
回复

使用道具 举报

ID:1 发表于 2018-11-15 03:33 | 显示全部楼层
原理图能分享吗？
回复

使用道具 举报

ID:235588 发表于 2018-11-15 09:44 | 显示全部楼层
谢谢大佬分享
回复

使用道具 举报

ID:720649 发表于 2020-5-3 10:44 | 显示全部楼层
能分享一下原理图吗楼主
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表