www.open-tager.ru

static void SetSysClock(void)
{
/******************************************************************************/
/*            PLL (clocked by HSE) used as System clock source                */
/******************************************************************************/
  __IO uint32_t StartUpCounter = 0, HSEStatus = 0;
 
  /* Enable HSE */
  RCC->CR |= ((uint32_t)RCC_CR_HSEON);
 
  /* Wait till HSE is ready and if Time out is reached exit */
  do
  {
    HSEStatus = RCC->CR & RCC_CR_HSERDY;
    StartUpCounter++;
  } while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));

  if ((RCC->CR & RCC_CR_HSERDY) != RESET)
  {
    HSEStatus = (uint32_t)0x01;
  }
  else
  {
    HSEStatus = (uint32_t)0x00;
  }

  if (HSEStatus == (uint32_t)0x01)
  {
    /* Enable high performance mode, System frequency up to 168 MHz */
    RCC->APB1ENR |= RCC_APB1ENR_PWREN;
    PWR->CR |= PWR_CR_PMODE;

    /* HCLK = SYSCLK / 1*/
    RCC->CFGR |= RCC_CFGR_HPRE_DIV1;
     
    /* PCLK2 = HCLK / 2*/
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV2;
   
    /* PCLK1 = HCLK / 4*/
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV4;

    /* Configure the main PLL */
    RCC->PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) -1) << 16) |
                   (RCC_PLLCFGR_PLLSRC_HSE) | (PLL_Q << 24);

    /* Enable the main PLL */
    RCC->CR |= RCC_CR_PLLON;

    /* Wait till the main PLL is ready */
    while((RCC->CR & RCC_CR_PLLRDY) == 0)
    {
    }
   
    /* Configure Flash prefetch, Instruction cache, Data cache and wait state */
    FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;

    /* Select the main PLL as system clock source */
    RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
    RCC->CFGR |= RCC_CFGR_SW_PLL;

    /* Wait till the main PLL is used as system clock source */
    while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
    {
    }
  }
  else
  { /* If HSE fails to start-up, the application will have wrong clock
         configuration. User can add here some code to deal with this error */
  }

/******************************************************************************/
/*                        I2S clock configuration                             */
/******************************************************************************/
  /* PLLI2S clock used as I2S clock source */
  RCC->CFGR &= ~RCC_CFGR_I2SSRC;

  /* Configure PLLI2S */
  RCC->PLLI2SCFGR = (PLLI2S_N << 6) | (PLLI2S_R << 28);

  /* Enable PLLI2S */
  RCC->CR |= ((uint32_t)RCC_CR_PLLI2SON);

  /* Wait till PLLI2S is ready */
  while((RCC->CR & RCC_CR_PLLI2SRDY) == 0)
  {
  }
}

 RCC->CR |= ((uint32_t)RCC_CR_HSEON);

RCC->CR|=RCC_CR_HSION; // Включить генератор HSI.

#include "stm32f4xx.h"
#include "stm32f4xx_conf.h"
#include "stm32f4_discovery.h"
#include "FreeRTOS.h"
#include "task.h"

void vTaskLED5(void *pvParameters);
void vTaskLED6(void *pvParameters);
void vTaskLED3(void *pvParameters);
void vTaskLED4(void *pvParameters);

int main(void)
{

   STM32F4_Discovery_LEDInit(LED3);
   STM32F4_Discovery_LEDInit(LED4);
   STM32F4_Discovery_LEDInit(LED6);
   STM32F4_Discovery_LEDInit(LED5);

   xTaskCreate( vTaskLED5, ( signed char * ) "LED5", configMINIMAL_STACK_SIZE, NULL, 2, ( xTaskHandle * ) NULL);
   xTaskCreate( vTaskLED6, ( signed char * ) "LED6", configMINIMAL_STACK_SIZE, NULL, 2, ( xTaskHandle * ) NULL);
   xTaskCreate( vTaskLED3, ( signed char * ) "LED3", configMINIMAL_STACK_SIZE, NULL, 2, ( xTaskHandle * ) NULL);
   xTaskCreate( vTaskLED4, ( signed char * ) "LED4", configMINIMAL_STACK_SIZE, NULL, 2, ( xTaskHandle * ) NULL);

   vTaskStartScheduler();
}


void vTaskLED5(void *pvParameters) {
   for (;;) {
      STM32F4_Discovery_LEDOn(LED5);
      vTaskDelay(50);
      STM32F4_Discovery_LEDOff(LED5);
      vTaskDelay(50);
   }
}

void vTaskLED6(void *pvParameters) {
   for (;;) {
      STM32F4_Discovery_LEDOn(LED6);
      vTaskDelay(32);
      STM32F4_Discovery_LEDOff(LED6);
      vTaskDelay(32);
   }
}


void vTaskLED3(void *pvParameters) {
   for (;;) {
      STM32F4_Discovery_LEDOn(LED3);
      vTaskDelay(60);
      STM32F4_Discovery_LEDOff(LED3);
      vTaskDelay(60);
   }
}

void vTaskLED4(void *pvParameters) {
   for (;;) {
      STM32F4_Discovery_LEDOn(LED4);
      vTaskDelay(70);
      STM32F4_Discovery_LEDOff(LED4);
      vTaskDelay(70);
   }
}