API tools faq
paste
Guest User

Program

a guest
Mar 22nd, 2024
76
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 19.00 KB | None | 0 0
raw download clone embed print report
  1. /* USER CODE BEGIN Header */
  2. /**
  3.  ******************************************************************************
  4.  * @file           : main.c
  5.  * @brief          : Main program body
  6.  ******************************************************************************
  7.  * @attention
  8.  *
  9.  * Copyright (c) 2024 STMicroelectronics.
  10.  * All rights reserved.
  11.  *
  12.  * This software is licensed under terms that can be found in the LICENSE file
  13.  * in the root directory of this software component.
  14.  * If no LICENSE file comes with this software, it is provided AS-IS.
  15.  *
  16.  ******************************************************************************
  17.  */
  18. /* USER CODE END Header */
  19. /* Includes ------------------------------------------------------------------*/
  20. #include "main.h"
  21.  
  22. /* Private includes ----------------------------------------------------------*/
  23. /* USER CODE BEGIN Includes */
  24. #include "stdio.h"
  25. #include "stdlib.h"
  26. #include "math.h"
  27. #include "string.h"
  28.  
  29. /* USER CODE END Includes */
  30.  
  31. /* Private typedef -----------------------------------------------------------*/
  32. /* USER CODE BEGIN PTD */
  33.  
  34. /* USER CODE END PTD */
  35.  
  36. /* Private define ------------------------------------------------------------*/
  37. /* USER CODE BEGIN PD */
  38. #define MAX_BUFFER_SIZE 64
  39. #define MAX_COMMAND_PARSED 10
  40.  
  41. /* USER CODE END PD */
  42.  
  43. /* Private macro -------------------------------------------------------------*/
  44. /* USER CODE BEGIN PM */
  45.  
  46. /* USER CODE END PM */
  47.  
  48. /* Private variables ---------------------------------------------------------*/
  49. ADC_HandleTypeDef hadc3;
  50.  
  51. TIM_HandleTypeDef htim16;
  52. TIM_HandleTypeDef htim17;
  53.  
  54. UART_HandleTypeDef huart3;
  55. DMA_HandleTypeDef hdma_usart3_rx;
  56. DMA_HandleTypeDef hdma_usart3_tx;
  57.  
  58. /* USER CODE BEGIN PV */
  59. uint8_t CMD_LINE[MAX_BUFFER_SIZE];
  60. uint8_t Flag_Enable_Parse_And_Receive = 0;
  61. char *CMD_PARSED[MAX_COMMAND_PARSED];
  62.  
  63. /* USER CODE END PV */
  64.  
  65. /* Private function prototypes -----------------------------------------------*/
  66. void SystemClock_Config(void);
  67. static void MX_GPIO_Init(void);
  68. static void MX_DMA_Init(void);
  69. static void MX_ADC3_Init(void);
  70. static void MX_TIM16_Init(void);
  71. static void MX_USART3_UART_Init(void);
  72. static void MX_TIM17_Init(void);
  73. /* USER CODE BEGIN PFP */
  74.  
  75. /* USER CODE END PFP */
  76.  
  77. /* Private user code ---------------------------------------------------------*/
  78. /* USER CODE BEGIN 0 */
  79. typedef struct {
  80.     uint8_t mode;
  81.     uint8_t enable;
  82.     uint8_t period;
  83.     uint8_t continuous_refresh;
  84.     uint8_t read_pos_vel;
  85.     uint8_t samples;
  86. } Command_line;
  87. typedef enum {
  88.     STATE_RESET,
  89.     STATE_CONFIG,
  90.     STATE_MANUALCTR,
  91.     STATE_OPENLOOP,
  92.     STATE_AUTOMATIC,
  93.     STATE_ERROR
  94. } Table_State;
  95. typedef struct {
  96.     Table_State State;
  97.     uint8_t mode;
  98. } Search_engine;
  99.  
  100. void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size) {
  101.     if (huart == &huart3) {
  102.         Flag_Enable_Parse_And_Receive = 1;
  103.     }
  104. }
  105. void error() {
  106.  
  107. }
  108. void config(){
  109.  
  110. }
  111. void initialize_modes(Search_engine Modes[5][5]) {
  112.     for (uint8_t i = 0; i < 4; i++) {
  113.         for (uint8_t j = 0; j < 4; j++) {
  114.             Modes[i][j].State = STATE_ERROR;
  115.             Modes[i][j].mode = j;
  116.         }
  117.     }
  118.     Modes[STATE_RESET][0].State = STATE_RESET;
  119.     Modes[STATE_RESET][1].State = STATE_CONFIG;
  120.     Modes[STATE_CONFIG][0].State = STATE_RESET;
  121.     Modes[STATE_CONFIG][1].State = STATE_CONFIG;
  122.     Modes[STATE_CONFIG][2].State = STATE_MANUALCTR;
  123.     Modes[STATE_CONFIG][3].State = STATE_OPENLOOP;
  124.     Modes[STATE_CONFIG][4].State = STATE_AUTOMATIC;
  125.     Modes[STATE_MANUALCTR][1].State = STATE_CONFIG;
  126.     Modes[STATE_MANUALCTR][2].State = STATE_MANUALCTR;
  127.     Modes[STATE_MANUALCTR][3].State = STATE_OPENLOOP;
  128.     Modes[STATE_OPENLOOP][1].State = STATE_CONFIG;
  129.     Modes[STATE_OPENLOOP][2].State = STATE_MANUALCTR;
  130.     Modes[STATE_OPENLOOP][3].State = STATE_OPENLOOP;
  131.     Modes[STATE_AUTOMATIC][1].State = STATE_CONFIG;
  132.     Modes[STATE_AUTOMATIC][4].State = STATE_AUTOMATIC;
  133.  
  134. }
  135. void state_configuration(Table_State Current_State,Command_line *User_Inputs){
  136.     switch(Current_State){
  137.     case STATE_RESET:
  138.         User_Inputs->enable=0;
  139.         User_Inputs->period=1;
  140.         User_Inputs->continuous_refresh=0;
  141.         User_Inputs->read_pos_vel=0;
  142.         User_Inputs->samples=0;
  143.         break;
  144.     case STATE_CONFIG:
  145.         config();
  146.         break;
  147.     case STATE_MANUALCTR:
  148.         break;
  149.     case STATE_OPENLOOP:
  150.         break;
  151.     case STATE_AUTOMATIC:
  152.         break;
  153.     case STATE_ERROR:
  154.         break;
  155.     }
  156.  
  157. }
  158. Table_State get_state(Search_engine Modes[5][5],Command_line *User_Inputs,Table_State Current_State) {
  159.     uint8_t mode=0;
  160.  
  161.     mode=User_Inputs->mode;
  162.     if(mode<0 || mode >4){
  163.  
  164.     }else{
  165.         Table_State Next_State=Modes[Current_State][mode].State;
  166.         if(Next_State == STATE_ERROR){
  167.             //handle error
  168.         }else return Next_State;
  169.     }
  170.     exit(EXIT_FAILURE);
  171. }
  172.  
  173. uint8_t parsing(uint8_t CMD_LINE[], char *CMD_PARSED[]) {
  174.     uint8_t Space_Counter = 0;
  175.     char *Token = strtok((char*) CMD_LINE, " ");
  176.     while (Token != NULL) {
  177.         CMD_PARSED[Space_Counter] = Token;
  178.         Space_Counter++;
  179.         Token = strtok(NULL, " ");
  180.     }
  181.     Space_Counter--;
  182.     return Space_Counter;
  183. }
  184. uint8_t search_engine(char *CMD_PARSED[], uint8_t Space_Counter,
  185.         Command_line *User_Inputs) {
  186.     for (uint8_t i = 0; i < Space_Counter; i++) {
  187.         if (strcmp(CMD_PARSED[i], "CS") == 0) {
  188.             User_Inputs->mode = strtoul(CMD_PARSED[++i], NULL, 10);
  189.             if (User_Inputs->mode > 4) {
  190.                 User_Inputs->mode = 0;
  191.                 return 1 ;
  192.             }
  193.         } else if (strcmp(CMD_PARSED[i], "EN") == 0) {
  194.             User_Inputs->enable = strtoul(CMD_PARSED[++i], NULL, 10);
  195.             if (User_Inputs->enable > 1) {
  196.                 User_Inputs->enable = 0;
  197.                 return 2;
  198.             }
  199.  
  200.         } else if (strcmp(CMD_PARSED[i], "HW") == 0) {
  201.             User_Inputs->period = strtoul(CMD_PARSED[++i], NULL, 10);
  202.             if (User_Inputs->period > 1000 || User_Inputs->period < 1) {
  203.                 User_Inputs->period = 1;
  204.                 return 3;
  205.             }
  206.  
  207.         } else if (strcmp(CMD_PARSED[i], "CR") == 0) {
  208.             User_Inputs->continuous_refresh = strtoul(CMD_PARSED[++i], NULL, 10);
  209.             if (User_Inputs->continuous_refresh > 2) {
  210.                 User_Inputs->continuous_refresh = 0;
  211.                 return 4;
  212.             }
  213.  
  214.         } else if (strcmp(CMD_PARSED[i], "L") == 0) {
  215.             User_Inputs->read_pos_vel = strtoul(CMD_PARSED[++i], NULL, 10);
  216.             if (User_Inputs->read_pos_vel > 2) {
  217.                 User_Inputs->read_pos_vel = 0;
  218.                 return 5;
  219.             }
  220.  
  221.         } else if (strcmp(CMD_PARSED[i], "KA") == 0) {
  222.             User_Inputs->samples = strtoul(CMD_PARSED[++i], NULL, 10);
  223.             if (User_Inputs->samples > 10000) {
  224.                 User_Inputs->samples = 0;
  225.                 return 6;
  226.             }
  227.         }
  228.     }
  229.     return 7;
  230. }
  231.  
  232. /* USER CODE END 0 */
  233.  
  234. /**
  235.  * @brief  The application entry point.
  236.  * @retval int
  237.  */
  238. int main(void) {
  239.     /* USER CODE BEGIN 1 */
  240.     Command_line User_Inputs = { 0 };
  241.     Search_engine Modes[5][5];
  242.     Table_State Current_State=STATE_RESET;
  243.     Table_State Next_State=STATE_RESET;
  244.     /* USER CODE END 1 */
  245.  
  246.     /* MCU Configuration--------------------------------------------------------*/
  247.  
  248.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  249.     HAL_Init();
  250.  
  251.     /* USER CODE BEGIN Init */
  252.  
  253.     /* USER CODE END Init */
  254.  
  255.     /* Configure the system clock */
  256.     SystemClock_Config();
  257.  
  258.     /* USER CODE BEGIN SysInit */
  259.  
  260.     /* USER CODE END SysInit */
  261.  
  262.     /* Initialize all configured peripherals */
  263.     MX_GPIO_Init();
  264.     MX_DMA_Init();
  265.     MX_ADC3_Init();
  266.     MX_TIM16_Init();
  267.     MX_USART3_UART_Init();
  268.     MX_TIM17_Init();
  269.     /* USER CODE BEGIN 2 */
  270.     initialize_modes(Modes);
  271.     HAL_UARTEx_ReceiveToIdle_DMA(&huart3, CMD_LINE, MAX_BUFFER_SIZE);
  272.     __HAL_DMA_DISABLE_IT(&hdma_usart3_rx, DMA_IT_HT);
  273.     /* USER CODE END 2 */
  274.  
  275.     /* Infinite loop */
  276.     /* USER CODE BEGIN WHILE */
  277.     while (1) {
  278.         if (Flag_Enable_Parse_And_Receive == 1) {
  279.             Flag_Enable_Parse_And_Receive = 0;
  280.             uint8_t Spaces_Counter = parsing(CMD_LINE, CMD_PARSED);
  281.             search_engine(CMD_PARSED, Spaces_Counter, &User_Inputs);
  282.             state_configuration(Current_State,&User_Inputs);
  283.             Next_State=get_state(Modes,&User_Inputs,Current_State);
  284.             Current_State=Next_State;
  285.             memset(CMD_LINE,0,MAX_BUFFER_SIZE);
  286.             HAL_UARTEx_ReceiveToIdle_DMA(&huart3, CMD_LINE,
  287.             MAX_BUFFER_SIZE);
  288.             __HAL_DMA_DISABLE_IT(&hdma_usart3_rx, DMA_IT_HT);
  289.         }
  290.         /* USER CODE END WHILE */
  291.  
  292.         /* USER CODE BEGIN 3 */
  293.     }
  294.     /* USER CODE END 3 */
  295. }
  296.  
  297. /**
  298.  * @brief System Clock Configuration
  299.  * @retval None
  300.  */
  301. void SystemClock_Config(void) {
  302.     RCC_OscInitTypeDef RCC_OscInitStruct = { 0 };
  303.     RCC_ClkInitTypeDef RCC_ClkInitStruct = { 0 };
  304.  
  305.     /** Supply configuration update enable
  306.      */
  307.     HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);
  308.  
  309.     /** Configure the main internal regulator output voltage
  310.      */
  311.     __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);
  312.  
  313.     while (!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {
  314.     }
  315.  
  316.     /** Macro to configure the PLL clock source
  317.      */
  318.     __HAL_RCC_PLL_PLLSOURCE_CONFIG(RCC_PLLSOURCE_HSE);
  319.  
  320.     /** Initializes the RCC Oscillators according to the specified parameters
  321.      * in the RCC_OscInitTypeDef structure.
  322.      */
  323.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI
  324.             | RCC_OSCILLATORTYPE_HSE;
  325.     RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
  326.     RCC_OscInitStruct.HSIState = RCC_HSI_DIV1;
  327.     RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  328.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  329.     if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
  330.         Error_Handler();
  331.     }
  332.  
  333.     /** Initializes the CPU, AHB and APB buses clocks
  334.      */
  335.     RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
  336.             | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_D3PCLK1
  337.             | RCC_CLOCKTYPE_D1PCLK1;
  338.     RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  339.     RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
  340.     RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV1;
  341.     RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV1;
  342.     RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV1;
  343.     RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV1;
  344.     RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV1;
  345.  
  346.     if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK) {
  347.         Error_Handler();
  348.     }
  349. }
  350.  
  351. /**
  352.  * @brief ADC3 Initialization Function
  353.  * @param None
  354.  * @retval None
  355.  */
  356. static void MX_ADC3_Init(void) {
  357.  
  358.     /* USER CODE BEGIN ADC3_Init 0 */
  359.  
  360.     /* USER CODE END ADC3_Init 0 */
  361.  
  362.     ADC_ChannelConfTypeDef sConfig = { 0 };
  363.  
  364.     /* USER CODE BEGIN ADC3_Init 1 */
  365.  
  366.     /* USER CODE END ADC3_Init 1 */
  367.  
  368.     /** Common config
  369.      */
  370.     hadc3.Instance = ADC3;
  371.     hadc3.Init.Resolution = ADC_RESOLUTION_16B;
  372.     hadc3.Init.ScanConvMode = ADC_SCAN_DISABLE;
  373.     hadc3.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  374.     hadc3.Init.LowPowerAutoWait = DISABLE;
  375.     hadc3.Init.ContinuousConvMode = DISABLE;
  376.     hadc3.Init.NbrOfConversion = 1;
  377.     hadc3.Init.DiscontinuousConvMode = DISABLE;
  378.     hadc3.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  379.     hadc3.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  380.     hadc3.Init.ConversionDataManagement = ADC_CONVERSIONDATA_DR;
  381.     hadc3.Init.Overrun = ADC_OVR_DATA_PRESERVED;
  382.     hadc3.Init.LeftBitShift = ADC_LEFTBITSHIFT_NONE;
  383.     hadc3.Init.OversamplingMode = DISABLE;
  384.     if (HAL_ADC_Init(&hadc3) != HAL_OK) {
  385.         Error_Handler();
  386.     }
  387.  
  388.     /** Configure Regular Channel
  389.      */
  390.     sConfig.Channel = ADC_CHANNEL_1;
  391.     sConfig.Rank = ADC_REGULAR_RANK_1;
  392.     sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  393.     sConfig.SingleDiff = ADC_SINGLE_ENDED;
  394.     sConfig.OffsetNumber = ADC_OFFSET_NONE;
  395.     sConfig.Offset = 0;
  396.     sConfig.OffsetSignedSaturation = DISABLE;
  397.     if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK) {
  398.         Error_Handler();
  399.     }
  400.     /* USER CODE BEGIN ADC3_Init 2 */
  401.  
  402.     /* USER CODE END ADC3_Init 2 */
  403.  
  404. }
  405.  
  406. /**
  407.  * @brief TIM16 Initialization Function
  408.  * @param None
  409.  * @retval None
  410.  */
  411. static void MX_TIM16_Init(void) {
  412.  
  413.     /* USER CODE BEGIN TIM16_Init 0 */
  414.  
  415.     /* USER CODE END TIM16_Init 0 */
  416.  
  417.     /* USER CODE BEGIN TIM16_Init 1 */
  418.  
  419.     /* USER CODE END TIM16_Init 1 */
  420.     htim16.Instance = TIM16;
  421.     htim16.Init.Prescaler = 64 - 1;
  422.     htim16.Init.CounterMode = TIM_COUNTERMODE_UP;
  423.     htim16.Init.Period = 1000 - 1;
  424.     htim16.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  425.     htim16.Init.RepetitionCounter = 0;
  426.     htim16.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  427.     if (HAL_TIM_Base_Init(&htim16) != HAL_OK) {
  428.         Error_Handler();
  429.     }
  430.     /* USER CODE BEGIN TIM16_Init 2 */
  431.  
  432.     /* USER CODE END TIM16_Init 2 */
  433.  
  434. }
  435.  
  436. /**
  437.  * @brief TIM17 Initialization Function
  438.  * @param None
  439.  * @retval None
  440.  */
  441. static void MX_TIM17_Init(void) {
  442.  
  443.     /* USER CODE BEGIN TIM17_Init 0 */
  444.  
  445.     /* USER CODE END TIM17_Init 0 */
  446.  
  447.     /* USER CODE BEGIN TIM17_Init 1 */
  448.  
  449.     /* USER CODE END TIM17_Init 1 */
  450.     htim17.Instance = TIM17;
  451.     htim17.Init.Prescaler = 64000 - 1;
  452.     htim17.Init.CounterMode = TIM_COUNTERMODE_UP;
  453.     htim17.Init.Period = 65535;
  454.     htim17.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  455.     htim17.Init.RepetitionCounter = 0;
  456.     htim17.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  457.     if (HAL_TIM_Base_Init(&htim17) != HAL_OK) {
  458.         Error_Handler();
  459.     }
  460.     /* USER CODE BEGIN TIM17_Init 2 */
  461.  
  462.     /* USER CODE END TIM17_Init 2 */
  463.  
  464. }
  465.  
  466. /**
  467.  * @brief USART3 Initialization Function
  468.  * @param None
  469.  * @retval None
  470.  */
  471. static void MX_USART3_UART_Init(void) {
  472.  
  473.     /* USER CODE BEGIN USART3_Init 0 */
  474.  
  475.     /* USER CODE END USART3_Init 0 */
  476.  
  477.     /* USER CODE BEGIN USART3_Init 1 */
  478.  
  479.     /* USER CODE END USART3_Init 1 */
  480.     huart3.Instance = USART3;
  481.     huart3.Init.BaudRate = 115200;
  482.     huart3.Init.WordLength = UART_WORDLENGTH_8B;
  483.     huart3.Init.StopBits = UART_STOPBITS_1;
  484.     huart3.Init.Parity = UART_PARITY_NONE;
  485.     huart3.Init.Mode = UART_MODE_TX_RX;
  486.     huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  487.     huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  488.     huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  489.     huart3.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  490.     huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  491.     if (HAL_UART_Init(&huart3) != HAL_OK) {
  492.         Error_Handler();
  493.     }
  494.     if (HAL_UARTEx_SetTxFifoThreshold(&huart3, UART_TXFIFO_THRESHOLD_1_8)
  495.             != HAL_OK) {
  496.         Error_Handler();
  497.     }
  498.     if (HAL_UARTEx_SetRxFifoThreshold(&huart3, UART_RXFIFO_THRESHOLD_1_8)
  499.             != HAL_OK) {
  500.         Error_Handler();
  501.     }
  502.     if (HAL_UARTEx_DisableFifoMode(&huart3) != HAL_OK) {
  503.         Error_Handler();
  504.     }
  505.     /* USER CODE BEGIN USART3_Init 2 */
  506.  
  507.     /* USER CODE END USART3_Init 2 */
  508.  
  509. }
  510.  
  511. /**
  512.  * Enable DMA controller clock
  513.  */
  514. static void MX_DMA_Init(void) {
  515.  
  516.     /* DMA controller clock enable */
  517.     __HAL_RCC_DMA1_CLK_ENABLE();
  518.  
  519.     /* DMA interrupt init */
  520.     /* DMA1_Stream0_IRQn interrupt configuration */
  521.     HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 0, 0);
  522.     HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
  523.     /* DMA1_Stream1_IRQn interrupt configuration */
  524.     HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 0, 0);
  525.     HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
  526.  
  527. }
  528.  
  529. /**
  530.  * @brief GPIO Initialization Function
  531.  * @param None
  532.  * @retval None
  533.  */
  534. static void MX_GPIO_Init(void) {
  535.     GPIO_InitTypeDef GPIO_InitStruct = { 0 };
  536.     /* USER CODE BEGIN MX_GPIO_Init_1 */
  537.     /* USER CODE END MX_GPIO_Init_1 */
  538.  
  539.     /* GPIO Ports Clock Enable */
  540.     __HAL_RCC_GPIOC_CLK_ENABLE();
  541.     __HAL_RCC_GPIOF_CLK_ENABLE();
  542.     __HAL_RCC_GPIOH_CLK_ENABLE();
  543.     __HAL_RCC_GPIOA_CLK_ENABLE();
  544.     __HAL_RCC_GPIOB_CLK_ENABLE();
  545.     __HAL_RCC_GPIOD_CLK_ENABLE();
  546.     __HAL_RCC_GPIOG_CLK_ENABLE();
  547.     __HAL_RCC_GPIOE_CLK_ENABLE();
  548.  
  549.     /*Configure GPIO pin Output Level */
  550.     HAL_GPIO_WritePin(GPIOB, LD1_Pin | LD3_Pin, GPIO_PIN_RESET);
  551.  
  552.     /*Configure GPIO pin Output Level */
  553.     HAL_GPIO_WritePin(USB_OTG_FS_PWR_EN_GPIO_Port, USB_OTG_FS_PWR_EN_Pin,
  554.             GPIO_PIN_RESET);
  555.  
  556.     /*Configure GPIO pin Output Level */
  557.     HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);
  558.  
  559.     /*Configure GPIO pin : PC13 */
  560.     GPIO_InitStruct.Pin = GPIO_PIN_13;
  561.     GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  562.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  563.     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  564.  
  565.     /*Configure GPIO pins : PC1 PC4 PC5 */
  566.     GPIO_InitStruct.Pin = GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5;
  567.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  568.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  569.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  570.     GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  571.     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  572.  
  573.     /*Configure GPIO pins : PA1 PA2 PA7 */
  574.     GPIO_InitStruct.Pin = GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_7;
  575.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  576.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  577.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  578.     GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  579.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  580.  
  581.     /*Configure GPIO pins : LD1_Pin LD3_Pin */
  582.     GPIO_InitStruct.Pin = LD1_Pin | LD3_Pin;
  583.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  584.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  585.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  586.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  587.  
  588.     /*Configure GPIO pin : PB13 */
  589.     GPIO_InitStruct.Pin = GPIO_PIN_13;
  590.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  591.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  592.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  593.     GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  594.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  595.  
  596.     /*Configure GPIO pin : USB_OTG_FS_PWR_EN_Pin */
  597.     GPIO_InitStruct.Pin = USB_OTG_FS_PWR_EN_Pin;
  598.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  599.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  600.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  601.     HAL_GPIO_Init(USB_OTG_FS_PWR_EN_GPIO_Port, &GPIO_InitStruct);
  602.  
  603.     /*Configure GPIO pin : PG5 */
  604.     GPIO_InitStruct.Pin = GPIO_PIN_5;
  605.     GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  606.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  607.     HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
  608.  
  609.     /*Configure GPIO pins : PA8 PA11 PA12 */
  610.     GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_11 | GPIO_PIN_12;
  611.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  612.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  613.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  614.     GPIO_InitStruct.Alternate = GPIO_AF10_OTG1_FS;
  615.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  616.  
  617.     /*Configure GPIO pins : PG11 PG13 */
  618.     GPIO_InitStruct.Pin = GPIO_PIN_11 | GPIO_PIN_13;
  619.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  620.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  621.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  622.     GPIO_InitStruct.Alternate = GPIO_AF11_ETH;
  623.     HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
  624.  
  625.     /*Configure GPIO pin : LD2_Pin */
  626.     GPIO_InitStruct.Pin = LD2_Pin;
  627.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  628.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  629.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  630.     HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);
  631.  
  632.     /* EXTI interrupt init*/
  633.     HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
  634.     HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
  635.  
  636.     /* USER CODE BEGIN MX_GPIO_Init_2 */
  637.     /* USER CODE END MX_GPIO_Init_2 */
  638. }
  639.  
  640. /* USER CODE BEGIN 4 */
  641.  
  642. /* USER CODE END 4 */
  643.  
  644. /**
  645.  * @brief  This function is executed in case of error occurrence.
  646.  * @retval None
  647.  */
  648. void Error_Handler(void) {
  649.     /* USER CODE BEGIN Error_Handler_Debug */
  650.     /* User can add his own implementation to report the HAL error return state */
  651.     __disable_irq();
  652.     while (1) {
  653.     }
  654.     /* USER CODE END Error_Handler_Debug */
  655. }
  656.  
  657. #ifdef  USE_FULL_ASSERT
  658. /**
  659.   * @brief  Reports the name of the source file and the source line number
  660.   *         where the assert_param error has occurred.
  661.   * @param  file: pointer to the source file name
  662.   * @param  line: assert_param error line source number
  663.   * @retval None
  664.   */
  665. void assert_failed(uint8_t *file, uint32_t line)
  666. {
  667.   /* USER CODE BEGIN 6 */
  668.   /* User can add his own implementation to report the file name and line number,
  669.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  670.   /* USER CODE END 6 */
  671. }
  672. #endif /* USE_FULL_ASSERT */
  673.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!