#define _TIM

#define _TIM2

vu16 CCR1_Val = 49152;

vu16 CCR2_Val = 32768;

vu16 CCR3_Val = 16384;

vu16 CCR4_Val = 8192;

main()

{

..............

TIM2_Configuration();

}

void TIM2_Configuration_RCC(void)

{

  /* TIM2 clock enable */

  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

}

void TIM2_Configuration_NVIC(void)

{

  NVIC_InitTypeDef NVIC_InitStructure;

  /* Enable the TIM2 gloabal Interrupt */

  NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQChannel;

  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;

  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  NVIC_Init(&NVIC_InitStructure);

}

void TIM2_Configuration(void)

{

  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;

  TIM_OCInitTypeDef  TIM_OCInitStructure;

  TIM2_Configuration_RCC();

  TIM2_Configuration_NVIC();

  /* ---------------------------------------------------------------

    TIM2 Configuration: Output Compare Timing Mode:

    TIM2CLK = 36 MHz, Prescaler = 4, TIM2 counter clock = 7.2 MHz

    CC1 update rate = TIM2 counter clock / CCR1_Val = 146.48 Hz

    CC2 update rate = TIM2 counter clock / CCR2_Val = 219.7 Hz

    CC3 update rate = TIM2 counter clock / CCR3_Val = 439.4 Hz

    CC4 update rate = TIM2 counter clock / CCR4_Val =  878.9 Hz

  --------------------------------------------------------------- */

  /* Time base configuration */

  TIM_TimeBaseStructure.TIM_Period = 65535;

  TIM_TimeBaseStructure.TIM_Prescaler = 0;

  TIM_TimeBaseStructure.TIM_ClockDivision = 0;

  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

  /* Prescaler configuration */

  TIM_PrescalerConfig(TIM2, 4, TIM_PSCReloadMode_Immediate);

  /* Output Compare Timing Mode configuration: Channel1 */

  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Timing;

  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;

  TIM_OCInitStructure.TIM_Pulse = CCR1_Val;

  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

  TIM_OC1Init(TIM2, &TIM_OCInitStructure);

  TIM_OC1PreloadConfig(TIM2, TIM_OCPreload_Disable);

  /* Output Compare Timing Mode configuration: Channel2 */

  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;

  TIM_OCInitStructure.TIM_Pulse = CCR2_Val;

  TIM_OC2Init(TIM2, &TIM_OCInitStructure);

  TIM_OC2PreloadConfig(TIM2, TIM_OCPreload_Disable);

  /* Output Compare Timing Mode configuration: Channel3 */

  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;

  TIM_OCInitStructure.TIM_Pulse = CCR3_Val;

  TIM_OC3Init(TIM2, &TIM_OCInitStructure);

  TIM_OC3PreloadConfig(TIM2, TIM_OCPreload_Disable);

  /* Output Compare Timing Mode configuration: Channel4 */

  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;

  TIM_OCInitStructure.TIM_Pulse = CCR4_Val;

  TIM_OC4Init(TIM2, &TIM_OCInitStructure);

  TIM_OC4PreloadConfig(TIM2, TIM_OCPreload_Disable);

  /* TIM IT enable */

  TIM_ITConfig(TIM2, TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3 | TIM_IT_CC4, ENABLE);

  /* TIM2 enable counter */

  TIM_Cmd(TIM2, ENABLE);

}

void TIM2_IRQHandler(void)

{

  if (TIM_GetITStatus(TIM2, TIM_IT_CC1) != RESET)

  {

    TIM_ClearITPendingBit(TIM2, TIM_IT_CC1);

    /* Pin PE.12 toggling with frequency = 73.24 Hz */

    GPIO_WriteBit(GPIOE, GPIO_Pin_12, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOE, GPIO_Pin_12)));

    capture = TIM_GetCapture1(TIM2);

    TIM_SetCompare1(TIM2, capture + CCR1_Val);

  }

  else if (TIM_GetITStatus(TIM2, TIM_IT_CC2) != RESET)

  {

    TIM_ClearITPendingBit(TIM2, TIM_IT_CC2);

    /* Pin PE.13 toggling with frequency = 109.8 Hz */

    GPIO_WriteBit(GPIOE, GPIO_Pin_13, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOE, GPIO_Pin_13)));

    capture = TIM_GetCapture2(TIM2);

    TIM_SetCompare2(TIM2, capture + CCR2_Val);

  }

  else if (TIM_GetITStatus(TIM2, TIM_IT_CC3) != RESET)

  {

    TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);

    /* Pin PE.14 toggling with frequency = 219.7 Hz */

    GPIO_WriteBit(GPIOE, GPIO_Pin_14, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOE, GPIO_Pin_14)));

    capture = TIM_GetCapture3(TIM2);

    TIM_SetCompare3(TIM2, capture + CCR3_Val);

  }

  else

  {

    TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);

    /* Pin PE.15 toggling with frequency = 439.4 Hz */

    GPIO_WriteBit(GPIOE, GPIO_Pin_15, (BitAction)(1 - GPIO_ReadOutputDataBit(GPIOE, GPIO_Pin_15)));

    capture = TIM_GetCapture4(TIM2);

    TIM_SetCompare4(TIM2, capture + CCR4_Val);

  }

}

#define _SysTick

The RCC feeds the Cortex System Timer (SysTick) external clock with the AHB clock

(HCLK) divided by 8. The SysTick can work either with this clock or with the Cortex clock

(HCLK), configurable in the SysTick Control and Status Register.

int main(void)

{

.......

/* SysTick end of count event each 1ms with input clock equal to 9MHz (HCLK/8, default) */

1>  SysTick_SetReload(9000);

  /* Enable SysTick interrupt */

2>  SysTick_ITConfig(ENABLE);

while (1)

  {

/* Insert 300 ms delay */

    Delay(300);

// do somthing

  }

}

void Delay(u32 nTime)

{

  /* Enable the SysTick Counter */

 1> SysTick_CounterCmd(SysTick_Counter_Enable);

  2> TimingDelay = nTime;

  3> while(TimingDelay != 0);

  /* Disable SysTick Counter */

  4> SysTick_CounterCmd(SysTick_Counter_Disable);

  /* Clear SysTick Counter */

  5> SysTick_CounterCmd(SysTick_Counter_Clear);

}

void SysTickHandler(void)

{

  TimingDelay_Decrement();

}

void TimingDelay_Decrement(void)

{

  if (TimingDelay != 0x00)

  { 

    TimingDelay--;

  }

}

#define _ADC2

void NVIC_Configuration(void)

{

  NVIC_InitTypeDef NVIC_InitStructure;

..................

  /* Configure and enable ADC interrupt */

  NVIC_InitStructure.NVIC_IRQChannel = ADC1_2_IRQChannel;

  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  NVIC_Init(&NVIC_InitStructure);

}

vu16 ADC2ConvertedValue

/*******************************************************************************

* Function Name  : ADC1_2_IRQHandler

* Description    : This function handles ADC1 and ADC2 global interrupts requests.

* Input          : None

* Output         : None

* Return         : None

*******************************************************************************/

void ADC1_2_IRQHandler(void)

{

  /* Get injected channel13 converted value */

  ADC2ConvertedValue = ADC_GetConversionValue(ADC2);

}

/* Enable ADC1, ADC2, ADC3 and GPIOC clocks */

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC2 | RCC_APB2Periph_GPIOC, ENABLE);

void GPIO_Configuration(void)

{

  GPIO_InitTypeDef GPIO_InitStructure;

  /* Configure PC.0 (ADC Channel10,  as analog inputs */

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;

  GPIO_Init(GPIOC, &GPIO_InitStructure);

}

/* ADC2 configuration ------------------------------------------------------*/

  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;

  ADC_InitStructure.ADC_ScanConvMode = DISABLE;

  ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;

  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;

  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;

  ADC_InitStructure.ADC_NbrOfChannel = 1;

  ADC_Init(ADC2, &ADC_InitStructure);

  /* ADC2 regular channels configuration */ 

  ADC_RegularChannelConfig(ADC2, ADC_Channel_10, 1, ADC_SampleTime_28Cycles5);

 /* Enable ADC2 EOC interupt */

  ADC_ITConfig(ADC2, ADC_IT_EOC, ENABLE);

/* Enable ADC2 */

  ADC_Cmd(ADC2, ENABLE);

  /* Enable ADC2 reset calibaration register */   

  ADC_ResetCalibration(ADC2);

  /* Check the end of ADC2 reset calibration register */

  while(ADC_GetResetCalibrationStatus(ADC2));

  /* Start ADC2 calibaration */

  ADC_StartCalibration(ADC2);

  /* Check the end of ADC2 calibration */

  while(ADC_GetCalibrationStatus(ADC2));

/* Start ADC2 Software Conversion */ 

  ADC_SoftwareStartConvCmd(ADC2, ENABLE);

printf("==== %d ====\r\n",ADC2ConvertedValue*3300/4096);

void ADC1_2_IRQHandler(void)

{

  /* Get injected channel13 converted value */

  ADC2ConvertedValue = ADC_GetConversionValue(ADC2);

  /*if (GPIO_ReadInputDataBit(GPIOE, GPIO_Pin_13) == 0x00)

      GPIO_SetBits(GPIOE, GPIO_Pin_13);

    else

      GPIO_ResetBits(GPIOE, GPIO_Pin_13);*/

}

#define _ADC

#define _ADC1

#define _DMA

#define _DMA1_Channel1

 /* Enable DMA1 clock */

  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

  /* Enable ADC1 and GPIOC clock */

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOC, ENABLE);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;

GPIO_Init(GPIOC, &GPIO_InitStructure);

1>#define ADC1_DR_Address    ((u32)0x4001244C)

2>vu16 ADCConvertedValue;

3>DMA_InitTypeDef DMA_InitStructure;

/* DMA1 channel1 configuration ----------------------------------------------*/

3>  DMA_DeInit(DMA1_Channel1);

4> DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_DR_Address;

5>  DMA_InitStructure.DMA_MemoryBaseAddr = (u32)&ADCConvertedValue;

6>  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;

7> DMA_InitStructure.DMA_BufferSize = 1;

8>  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;

9> DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;

10>  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;

11> DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;

12>  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;

13> DMA_InitStructure.DMA_Priority = DMA_Priority_High;

14>  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

15>  DMA_Init(DMA1_Channel1, &DMA_InitStructure);

/* Enable DMA1 channel1 */

  DMA_Cmd(DMA1_Channel1, ENABLE);

typedef struct

{

  u32 DMA_PeripheralBaseAddr;

  u32 DMA_MemoryBaseAddr;

  u32 DMA_DIR;

  u32 DMA_BufferSize;

  u32 DMA_PeripheralInc;

  u32 DMA_MemoryInc;

  u32 DMA_PeripheralDataSize;

  u32 DMA_MemoryDataSize;

  u32 DMA_Mode;

  u32 DMA_Priority;

  u32 DMA_M2M;

}DMA_InitTypeDef;

/*******************************************************************************

* Function Name  : DMA_Init

* Description    : Initializes the DMAy Channelx according to the specified

*                  parameters in the DMA_InitStruct.

* Input          : - DMAy_Channelx: where y can be 1 or 2 to select the DMA and 

*                    x can be 1 to 7 for DMA1 and 1 to 5 for DMA2 to select the 

*                    DMA Channel.

*                  - DMA_InitStruct: pointer to a DMA_InitTypeDef structure that

*                    contains the configuration information for the specified

*                    DMA Channel.

* Output         : None

* Return         : None

******************************************************************************/

void DMA_Init(DMA_Channel_TypeDef* DMAy_Channelx, DMA_InitTypeDef* DMA_InitStruct)

{

  u32 tmpreg = 0;

  /* Check the parameters */

  assert_param(IS_DMA_ALL_PERIPH(DMAy_Channelx));

  assert_param(IS_DMA_DIR(DMA_InitStruct->DMA_DIR));

  assert_param(IS_DMA_BUFFER_SIZE(DMA_InitStruct->DMA_BufferSize));

  assert_param(IS_DMA_PERIPHERAL_INC_STATE(DMA_InitStruct->DMA_PeripheralInc));

  assert_param(IS_DMA_MEMORY_INC_STATE(DMA_InitStruct->DMA_MemoryInc));   

  assert_param(IS_DMA_PERIPHERAL_DATA_SIZE(DMA_InitStruct->DMA_PeripheralDataSize));

  assert_param(IS_DMA_MEMORY_DATA_SIZE(DMA_InitStruct->DMA_MemoryDataSize));

  assert_param(IS_DMA_MODE(DMA_InitStruct->DMA_Mode));

  assert_param(IS_DMA_PRIORITY(DMA_InitStruct->DMA_Priority));

  assert_param(IS_DMA_M2M_STATE(DMA_InitStruct->DMA_M2M));

/*--------------------------- DMAy Channelx CCR Configuration -----------------*/

  /* Get the DMAy_Channelx CCR value */

  tmpreg = DMAy_Channelx->CCR;

  /* Clear MEM2MEM, PL, MSIZE, PSIZE, MINC, PINC, CIRC and DIR bits */

  tmpreg &= CCR_CLEAR_Mask;

  /* Configure DMAy Channelx: data transfer, data size, priority level and mode */

  /* Set DIR bit according to DMA_DIR value */

  /* Set CIRC bit according to DMA_Mode value */

  /* Set PINC bit according to DMA_PeripheralInc value */

  /* Set MINC bit according to DMA_MemoryInc value */

  /* Set PSIZE bits according to DMA_PeripheralDataSize value */

  /* Set MSIZE bits according to DMA_MemoryDataSize value */

  /* Set PL bits according to DMA_Priority value */

  /* Set the MEM2MEM bit according to DMA_M2M value */

  tmpreg |= DMA_InitStruct->DMA_DIR | DMA_InitStruct->DMA_Mode |

            DMA_InitStruct->DMA_PeripheralInc | DMA_InitStruct->DMA_MemoryInc |

            DMA_InitStruct->DMA_PeripheralDataSize | DMA_InitStruct->DMA_MemoryDataSize |

            DMA_InitStruct->DMA_Priority | DMA_InitStruct->DMA_M2M;

  /* Write to DMAy Channelx CCR */

  DMAy_Channelx->CCR = tmpreg;

/*--------------------------- DMAy Channelx CNDTR Configuration ---------------*/

  /* Write to DMAy Channelx CNDTR */

  DMAy_Channelx->CNDTR = DMA_InitStruct->DMA_BufferSize;

/*--------------------------- DMAy Channelx CPAR Configuration ----------------*/

  /* Write to DMAy Channelx CPAR */

  DMAy_Channelx->CPAR = DMA_InitStruct->DMA_PeripheralBaseAddr;

/*--------------------------- DMAy Channelx CMAR Configuration ----------------*/

  /* Write to DMAy Channelx CMAR */

  DMAy_Channelx->CMAR = DMA_InitStruct->DMA_MemoryBaseAddr;

}

ADC_InitTypeDef ADC_InitStructure;

/* ADC1 configuration ------------------------------------------------------*/

  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;

  ADC_InitStructure.ADC_ScanConvMode = ENABLE;

  ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;

  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;

  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;

  ADC_InitStructure.ADC_NbrOfChannel = 1;

  ADC_Init(ADC1, &ADC_InitStructure);

  /* ADC1 regular channel14 configuration */ 

  ADC_RegularChannelConfig(ADC1, ADC_Channel_10, 1, ADC_SampleTime_55Cycles5);

  /* Enable ADC1 DMA */

  ADC_DMACmd(ADC1, ENABLE);

  /* Enable ADC1 */

  ADC_Cmd(ADC1, ENABLE);

  /* Enable ADC1 reset calibaration register */   

  ADC_ResetCalibration(ADC1);

  /* Check the end of ADC1 reset calibration register */

  while(ADC_GetResetCalibrationStatus(ADC1));

  /* Start ADC1 calibaration */

  ADC_StartCalibration(ADC1);

  /* Check the end of ADC1 calibration */

  while(ADC_GetCalibrationStatus(ADC1));

  /* Start ADC1 Software Conversion */ 

  ADC_SoftwareStartConvCmd(ADC1, ENABLE);

/* ADC Init structure definition */

typedef struct

{

  u32 ADC_Mode;

  FunctionalState ADC_ScanConvMode; 

  FunctionalState ADC_ContinuousConvMode;

  u32 ADC_ExternalTrigConv;

  u32 ADC_DataAlign;

  u8 ADC_NbrOfChannel;

}ADC_InitTypeDef;

printf("==== %d ====\r\n",ADCConvertedValue*3300/4096);

  1> RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

  2> GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;

  3> GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

  4> GPIO_Init(GPIOA, &GPIO_InitStructure);

typedef enum

{ GPIO_Mode_AIN = 0x0,

  GPIO_Mode_IN_FLOATING = 0x04,

  GPIO_Mode_IPD = 0x28,

  GPIO_Mode_IPU = 0x48,

  GPIO_Mode_Out_OD = 0x14,

  GPIO_Mode_Out_PP = 0x10,

  GPIO_Mode_AF_OD = 0x1C,

  GPIO_Mode_AF_PP = 0x18

}GPIOMode_TypeDef;

1> if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) != 0x00)

 2>       printf("==== GPIO PORT A  PIN 0 == 0  ====\r\n");

#define DEBUG    1

#define _USART

#define _USART1

void GPIO_Configuration(void)

{

  GPIO_InitTypeDef GPIO_InitStructure;

  /* Configure USART1 Tx (PA.09) as alternate function push-pull */

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIOA, &GPIO_InitStructure);

  /* Configure USART1 Rx (PA.10) as input floating */

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

  GPIO_Init(GPIOA, &GPIO_InitStructure);

}

RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

void USART_Configuration(void)

{

  USART_InitTypeDef USART_InitStructure;

/* USART1 configuration ------------------------------------------------------*/

  /* USART1 configured as follow:

        - BaudRate = 115200 baud  

        - Word Length = 8 Bits

        - One Stop Bit

        - No parity

        - Hardware flow control disabled (RTS and CTS signals)

        - Receive and transmit enabled

  */

  USART_InitStructure.USART_BaudRate = 115200;

  USART_InitStructure.USART_WordLength = USART_WordLength_8b;

  USART_InitStructure.USART_StopBits = USART_StopBits_1;

  USART_InitStructure.USART_Parity = USART_Parity_No;

  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

  USART_Init(USART1, &USART_InitStructure);

  /* Enable USART1 */

  USART_Cmd(USART1, ENABLE); //인제 동작시작

}

PUTCHAR_PROTOTYPE

{

  /* Place your implementation of fputc here */

  /* e.g. write a character to the USART */

  USART_SendData(USART1, (u8) ch);

  /* Loop until the end of transmission */

  while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)

  {

  }

  return ch;

}

int main(void)

{

   int i=0;

#ifdef DEBUG

  debug();  //요건 몰까요?

#endif

  /* Configure the system clocks */

  RCC_Configuration(); // 클럭관련 설정후 UART 클럭도 설정

  /* NVIC Configuration */

  NVIC_Configuration();

   /* Configure the GPIOs */

  GPIO_Configuration();            // uart관련 io설정

  /* Configure the USART1 */

  USART_Configuration(); // UART1에 대하여 초기화 작업

  printf("\r\n STM32F10x Firmware Library compiled in DEBUG mode... \n\r");

  printf("...Run-time checking enabled  \n\r");

  while (1)

  {

    Delay(0xFFFFF);

    printf("==== %d ====\r\n",i++); // 뺑뺑이 돌려보았습니다.

  }

}

 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIO_LED, ENABLE);

 1>GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15 | GPIO_Pin_12;

  2>GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 

  3>GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 

  4>GPIO_Init(GPIO_LED, &GPIO_InitStructure); 

#include "stm32f10x_lib.h"

#include "platform_config.h"

GPIO_InitTypeDef GPIO_InitStructure;

ErrorStatus HSEStartUpStatus;

/* Private function prototypes -----------------------------------------------*/

void RCC_Configuration(void);

void NVIC_Configuration(void);

void Delay(vu32 nCount);

int main(void)

{

  /* System Clocks Configuration **********************************************/

  RCC_Configuration();   // clock에 대한 정의를 한다.

  /* NVIC Configuration *******************************************************/

  NVIC_Configuration(); // ram 또는 rom 에 따라 vector를 설정한다.

  /* Configure IO connected to LD1, LD2, LD3 and LD4 leds *********************/

  /* Enable GPIO_LED clock */

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIO_LED, ENABLE); 

   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15 | GPIO_Pin_12; 핀설정

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 

  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(GPIO_LED, &GPIO_InitStructure); 

  while (1)

  {

    /* Turn on LD1 */

    GPIO_SetBits(GPIO_LED, GPIO_Pin_12); // 해당 핀 셋

    /* Insert delay */

    Delay(0xFFFFF);

    GPIO_ResetBits(GPIO_LED, GPIO_Pin_12); // 해당핀 리셋

    Delay(0xFFFFF);

  }

}