API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 2nd, 2016
330
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.05 KB | None | 0 0
raw download clone embed print report
  1. void MX_DMA_Init(void)
  2. {
  3.   /* DMA controller clock enable */
  4.   __HAL_RCC_DMA1_CLK_ENABLE();
  5.   __HAL_RCC_DMA2_CLK_ENABLE();
  6.  
  7.   /* DMA interrupt init */
  8.   /* DMA1_Stream5_IRQn interrupt configuration */
  9.   HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 1, 0);
  10.   HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
  11.   /* DMA2_Stream0_IRQn interrupt configuration */
  12.   HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 1, 0);
  13.   HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
  14.   /* DMA2_Stream2_IRQn interrupt configuration */
  15.   HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 0, 0);
  16.   HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
  17.   /* DMA2_Stream3_IRQn interrupt configuration */
  18.   HAL_NVIC_SetPriority(DMA2_Stream3_IRQn, 0, 0);
  19.   HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
  20.   /* DMA2_Stream7_IRQn interrupt configuration */
  21.   HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 0, 0);
  22.   HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);
  23.  
  24. }
  25.  
  26.  
  27.  
  28. void MX_DAC_Init(void)
  29. {
  30.   DAC_ChannelConfTypeDef sConfig;
  31.  
  32.     /**DAC Initialization
  33.     */
  34.   hdac.Instance = DAC;
  35.   if (HAL_DAC_Init(&hdac) != HAL_OK)
  36.   {
  37.     Error_Handler();
  38.   }
  39.  
  40.     /**DAC channel OUT1 config
  41.     */
  42.   sConfig.DAC_Trigger = DAC_TRIGGER_T2_TRGO;
  43.   sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
  44.   if (HAL_DAC_ConfigChannel(&hdac, &sConfig, DAC_CHANNEL_1) != HAL_OK)
  45.   {
  46.     Error_Handler();
  47.   }
  48.  
  49.     /**DAC channel OUT2 config
  50.     */
  51.   sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
  52.   sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
  53.   if (HAL_DAC_ConfigChannel(&hdac, &sConfig, DAC_CHANNEL_2) != HAL_OK)
  54.   {
  55.     Error_Handler();
  56.   }
  57.  
  58. }
  59.  
  60. void HAL_DAC_MspInit(DAC_HandleTypeDef* dacHandle)
  61. {
  62.  
  63.   GPIO_InitTypeDef GPIO_InitStruct;
  64.   if(dacHandle->Instance==DAC)
  65.   {
  66.   /* USER CODE BEGIN DAC_MspInit 0 */
  67.  
  68.   /* USER CODE END DAC_MspInit 0 */
  69.     /* Peripheral clock enable */
  70.     __HAL_RCC_DAC_CLK_ENABLE();
  71.  
  72.     /**DAC GPIO Configuration    
  73.     PA4     ------> DAC_OUT1
  74.     PA5     ------> DAC_OUT2
  75.     */
  76.     GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5;
  77.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  78.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  79.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  80.  
  81.     /* Peripheral DMA init*/
  82.  
  83.     hdma_dac1.Instance = DMA1_Stream5;
  84.     hdma_dac1.Init.Channel = DMA_CHANNEL_7;
  85.     hdma_dac1.Init.Direction = DMA_MEMORY_TO_PERIPH;
  86.     hdma_dac1.Init.PeriphInc = DMA_PINC_DISABLE;
  87.     hdma_dac1.Init.MemInc = DMA_MINC_ENABLE;
  88.     hdma_dac1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
  89.     hdma_dac1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
  90.     hdma_dac1.Init.Mode = DMA_CIRCULAR;
  91.     hdma_dac1.Init.Priority = DMA_PRIORITY_VERY_HIGH;
  92.     hdma_dac1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  93.     if (HAL_DMA_Init(&hdma_dac1) != HAL_OK)
  94.     {
  95.       Error_Handler();
  96.     }
  97.  
  98.     __HAL_LINKDMA(dacHandle,DMA_Handle1,hdma_dac1);
  99.  
  100.     /* Peripheral interrupt init */
  101.     HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 1, 0);
  102.     HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
  103.   /* USER CODE BEGIN DAC_MspInit 1 */
  104.  
  105.   /* USER CODE END DAC_MspInit 1 */
  106.   }
  107. }
  108.  
  109. void MX_ADC1_Init(void)
  110. {
  111.   ADC_ChannelConfTypeDef sConfig;
  112.  
  113.     /**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
  114.     */
  115.   hadc1.Instance = ADC1;
  116.   hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
  117.   hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  118.   hadc1.Init.ScanConvMode = DISABLE;
  119.   hadc1.Init.ContinuousConvMode = DISABLE;
  120.   hadc1.Init.DiscontinuousConvMode = DISABLE;
  121.   hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
  122.   hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T2_TRGO;
  123.   hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  124.   hadc1.Init.NbrOfConversion = 1;
  125.   hadc1.Init.DMAContinuousRequests = ENABLE;
  126.   hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  127.   if (HAL_ADC_Init(&hadc1) != HAL_OK)
  128.   {
  129.     Error_Handler();
  130.   }
  131.  
  132.     /**Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
  133.     */
  134.   sConfig.Channel = ADC_CHANNEL_10;
  135.   sConfig.Rank = 1;
  136.   sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
  137.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  138.   {
  139.     Error_Handler();
  140.   }
  141.  
  142. }
  143. void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
  144. {
  145.  
  146.   GPIO_InitTypeDef GPIO_InitStruct;
  147.   if(adcHandle->Instance==ADC1)
  148.   {
  149.   /* USER CODE BEGIN ADC1_MspInit 0 */
  150.  
  151.   /* USER CODE END ADC1_MspInit 0 */
  152.     /* Peripheral clock enable */
  153.     __HAL_RCC_ADC1_CLK_ENABLE();
  154.  
  155.     /**ADC1 GPIO Configuration    
  156.     PC0     ------> ADC1_IN10
  157.     */
  158.     GPIO_InitStruct.Pin = GPIO_PIN_0;
  159.     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  160.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  161.     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
  162.  
  163.     /* Peripheral DMA init*/
  164.  
  165.     hdma_adc1.Instance = DMA2_Stream0;
  166.     hdma_adc1.Init.Channel = DMA_CHANNEL_0;
  167.     hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
  168.     hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
  169.     hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
  170.     hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
  171.     hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
  172.     hdma_adc1.Init.Mode = DMA_CIRCULAR;
  173.     hdma_adc1.Init.Priority = DMA_PRIORITY_VERY_HIGH;
  174.     hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  175.     if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
  176.     {
  177.       Error_Handler();
  178.     }
  179.  
  180.     __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1);
  181.  
  182.     /* Peripheral interrupt init */
  183.     HAL_NVIC_SetPriority(ADC_IRQn, 1, 0);
  184.     HAL_NVIC_EnableIRQ(ADC_IRQn);
  185.   /* USER CODE BEGIN ADC1_MspInit 1 */
  186.  
  187.   /* USER CODE END ADC1_MspInit 1 */
  188.  
  189. void MX_USART1_UART_Init(void)
  190. {
  191.  
  192.   huart1.Instance = USART1;
  193.   huart1.Init.BaudRate = 115200;
  194.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
  195.   huart1.Init.StopBits = UART_STOPBITS_1;
  196.   huart1.Init.Parity = UART_PARITY_NONE;
  197.   huart1.Init.Mode = UART_MODE_TX_RX;
  198.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  199.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  200.   if (HAL_UART_Init(&huart1) != HAL_OK)
  201.   {
  202.     Error_Handler();
  203.   }
  204.  
  205. }
  206. void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
  207. {
  208.  
  209.   GPIO_InitTypeDef GPIO_InitStruct;
  210.   if(uartHandle->Instance==USART1)
  211.   {
  212.   /* USER CODE BEGIN USART1_MspInit 0 */
  213.  
  214.   /* USER CODE END USART1_MspInit 0 */
  215.     /* Peripheral clock enable */
  216.     __HAL_RCC_USART1_CLK_ENABLE();
  217.  
  218.     /**USART1 GPIO Configuration    
  219.     PB6     ------> USART1_TX
  220.     PB7     ------> USART1_RX
  221.     */
  222.     GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
  223.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  224.     GPIO_InitStruct.Pull = GPIO_PULLUP;
  225.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  226.     GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
  227.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  228.  
  229.     /* Peripheral DMA init*/
  230.  
  231.     hdma_usart1_rx.Instance = DMA2_Stream2;
  232.     hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4;
  233.     hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
  234.     hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
  235.     hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
  236.     hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  237.     hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  238.     hdma_usart1_rx.Init.Mode = DMA_NORMAL;
  239.     hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW;
  240.     hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  241.     if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
  242.     {
  243.       Error_Handler();
  244.     }
  245.  
  246.     __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx);
  247.  
  248.     hdma_usart1_tx.Instance = DMA2_Stream7;
  249.     hdma_usart1_tx.Init.Channel = DMA_CHANNEL_4;
  250.     hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
  251.     hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
  252.     hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
  253.     hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
  254.     hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
  255.     hdma_usart1_tx.Init.Mode = DMA_NORMAL;
  256.     hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;
  257.     hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
  258.     if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
  259.     {
  260.       Error_Handler();
  261.     }
  262.  
  263.     __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart1_tx);
  264.  
  265.     /* Peripheral interrupt init */
  266.     HAL_NVIC_SetPriority(USART1_IRQn, 1, 0);
  267.     HAL_NVIC_EnableIRQ(USART1_IRQn);
  268.   /* USER CODE BEGIN USART1_MspInit 1 */
  269.     HAL_UART_Transmit_DMA(&huart1, tx_charbuf, strlen(tx_charbuf));
  270.   /* USER CODE END USART1_MspInit 1 */
  271.   }
  272.  
  273. }
  274.  
  275. void MX_TIM2_Init(void)
  276. {
  277.   TIM_ClockConfigTypeDef sClockSourceConfig;
  278.   TIM_MasterConfigTypeDef sMasterConfig;
  279.  
  280.   htim2.Instance = TIM2;
  281.   htim2.Init.Prescaler = 1;
  282.   htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  283.   htim2.Init.Period = 105;
  284.   htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV2;
  285.   if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  286.   {
  287.     Error_Handler();
  288.   }
  289.  
  290.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  291.   if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  292.   {
  293.     Error_Handler();
  294.   }
  295.  
  296.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  297.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
  298.   if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  299.   {
  300.     Error_Handler();
  301.   }
  302.  
  303. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!