EEPW论坛

Finish之后就完成啦~~接下来就是破解了！

CIDget的时候忘记截图了QAQ

成功激活~重启一次~

#include <stm32f10x_lib.h>  
#include "led.h"  

void LED_Init(void)  
{  
    RCC->APB2ENR|=1<<2;     
    RCC->APB2ENR|=1<<5;      
  
    GPIOA->CRH&=0XFFFFFFF0;  
    GPIOA->CRH|=0X00000003;  
    GPIOA->ODR=1<<8;        
  
    GPIOD->CRH&=0XFFFFF0FF;  
    GPIOD->CRH|=0X00000300;  
    GPIOD->ODR=1<<2;        
}  led.h
#ifndef __LED_H  
#define __LED_H    
#include "sys.h"  
  
//LED????  
#define LED0 PAout(8)// PA8  
#define LED1 PDout(2)// PD2   
  
void LED_Init(void);                             
#endif  
test.c
#include <stm32f10x_lib.h>  
#include "sys.h"  
#include "usart.h"        
#include "delay.h"    
#include "led.h"   
  
int main(void)  
{                       
    Stm32_Clock_Init(9);  
    delay_init(72);       
    LED_Init();         
    while(1)  
    {  
        LED0=0;  
        LED1=1;  
        delay_ms(300);  
        LED0=1;  
        LED1=0;  
        delay_ms(300);  
    }      
}  

#define SYS_GLOBALS 

#include "stm32f10x.h" 

#define u16 unsigned short 

#define u32 unsigned long u32 volatile gTimer_1ms=0;unsigned char seg_table[]={0xfc,0x60,0xda,0xf2,0x66,0xb6,0xbe,0xe0,0xfe,0xf6}; 

 #define DS(x) GPIOA->ODR=(GPIOA->ODR&(~GPIO_Pin_7) | (x ? GPIO_Pin_7 : 0) 

#define CLK(x) GPIOA->ODR=(GPIOA->ODR&~GPIO_Pin_6) | (x ? GPIO_Pin_6 : 0) 

#define RCK(x) GPIOA->ODR=(GPIOA->ODR&~GPIO_Pin_5) | (x ? GPIO_Pin_5 : 0)

 void GPIO_Configuration(void);

 void WR_595(unsigned char segdata); 

void OUT_595(void); void Delay(u32 nCount);

 void WR_595(unsigned char segdata) //输入一字节数码管数据进595

 { unsigned char i; for(i=0;i<8;i++) //循环移入8位数据， 

 { if((segdata&0x80)==0x80) // 取数码的最高位 

 { 

 DS(1); 

 } 

 else

 {

 DS(0);

 } 

 CLK(1); //上升沿把一位数据移入595

 segdata=segdata<<1; 

 Delay(1000);

 CLK(0); } 

}

 void OUT_595(void) //上升沿将数据送到输出锁存器 

{ RCK(0); 

 Delay(1000); 

 RCK(1);

 } 

 int main(void) 

{ GPIO_Configuration();//配置GPIO 

 while (1)

{

 WR_595(seg_table[1]); 

 WR_595(seg_table[2]);

 WR_595(seg_table[3]); 

 WR_595(seg_table[4]);

 OUT_595();

 }

 }

void GPIO_Configuration(void) 

{ GPIO_InitTypeDef GPIO_InitStructure;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能GPIO时钟 

 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7; 

 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;////通用推挽输出 

 GPIO_Init(GPIOA, &GPIO_InitStructure);

 } 

void Delay(u32 nCount) { for(; nCount != 0; nCount--); 

}

#include <stm32f10x_lib.h>    // STM32F10x Library Definitions
#include "STM32_Init.h"       // STM32 Initialization
  void Delay(vu16 cnt) {
uint16 i,j;
for (i=0;i<cnt;i++)
{ for (j=0;j<1000;j++)
  { }
 }
}void RCC_Configuration(void)
{
    ErrorStatus HSEStartUpStatus;


    
    RCC_HSEConfig(RCC_HSE_ON);
    HSEStartUpStatus = RCC_WaitForHSEStartUp();
    if(HSEStartUpStatus==SUCCESS)
    {
        //??HCLK(AHB??)=SYSCLK
        RCC_HCLKConfig(RCC_SYSCLK_Div1);


        //PCLK1(APB1) = HCLK/2
        RCC_PCLK1Config(RCC_HCLK_Div2);


        //PCLK2(APB2) = HCLK
        RCC_PCLK2Config(RCC_HCLK_Div1);
        
 
        RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_4);
        
        RCC_PLLCmd(ENABLE);
    
        while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
    
        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
        
        while(RCC_GetSYSCLKSource()!=0x08);  
     }
   /* RCC system reset(for debug purpose) */


  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO , ENABLE); //?GPIOA????????,??:?????RCC_APB2Periph_AFIO


}
void GPIO_Configuration(void)
 {


  GPIO_InitTypeDef  GPIO_InitStructure;
  /*??PA3???*/
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA,&GPIO_InitStructure);
  /*??PA1???*/
  GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_1;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);


 }
 void EXTI_Configuration(void)
{
  EXTI_InitTypeDef  EXTI_InitStructure;




  /* Configure EXTI Line3 to generate an interrupt on falling edge */  
  EXTI_InitStructure.EXTI_Line = EXTI_Line3;                   
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;    
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;        
  EXTI_Init(&EXTI_InitStructure);
  GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource3); 
}
 void NVIC_Configuration(void)
{
  NVIC_InitTypeDef NVIC_InitStructure; 


#ifdef  VECT_TAB_RAM  
  /* Set the Vector Table base location at 0x20000000 */ 
  NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); 
#else  /* VECT_TAB_FLASH  */
  /* Set the Vector Table base location at 0x08000000 */ 
  NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
#endif
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);           




  NVIC_InitStructure.NVIC_IRQChannel = EXTI3_IRQChannel;    
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;        
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         
  NVIC_Init(&NVIC_InitStructure);
} 
int main (void) 
{


 RCC_Configuration();                        
 GPIO_Configuration(); 
 NVIC_Configuration(); 
 EXTI_Configuration(); 
 while(1)
 {


  }
 }
   void EXTI3_IRQHandler (void)
 {
   if(EXTI_GetITStatus(EXTI_Line3) != RESET) 
    {
     //????????
  GPIO_WriteBit(GPIOA, GPIO_Pin_1,(BitAction)0); 
  Delay(1000);
  GPIO_WriteBit(GPIOA, GPIO_Pin_1,(BitAction)1);
  Delay(1000);
     EXTI_ClearFlag(EXTI_Line3);          
     EXTI_ClearITPendingBit(EXTI_Line3);
     }
 }

#include "stm32f10x.h"

 #include "stm32_eval.h"

GPIO_InitTypeDef GPIO_InitStructure;

void  RCC_Configuration(void)//时钟配置    
{     
 RCC_DeInit();     
        
  RCC_HSICmd(ENABLE);     
  while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);     
       
  RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);     
       
  RCC_HSEConfig(RCC_HSE_OFF);     
  RCC_LSEConfig(RCC_LSE_OFF);     
  RCC_PLLConfig(RCC_PLLSource_HSI_Div2,RCC_PLLMul_9); //  72HMz     
  RCC_PLLCmd(ENABLE);     
  while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);     
  RCC_ADCCLKConfig(RCC_PCLK2_Div4);     
  RCC_PCLK2Config(RCC_HCLK_Div1);     
  RCC_PCLK1Config(RCC_HCLK_Div2);     
  RCC_HCLKConfig(RCC_SYSCLK_Div1);     
  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);     
  while(RCC_GetSYSCLKSource() != 0x08);     
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);     
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG     
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;     
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;     
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;     
  GPIO_Init(GPIOD, &GPIO_InitStructure);     
    GPIO_ResetBits(GPIOD,GPIO_Pin_2);//关闭蜂鸣    
}    

/*GPIO初始化*/     
void GPIO_INIT()     
{     
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA, ENABLE);//使能PC,PA的时钟     
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;//要使用PC0至PC7     
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;     
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出    
  GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化PC     
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;//要使用PA1,PA2,PA3     
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;     
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出     
  GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化PA     
}     
/*延时函数 微秒*/     
void delay_us(u32 n)     
{     
    u8 j;     
    while(n--)     
    for(j=0;j<10;j++);     
}     
/*延时函数 微秒*/     
void  delay_ms(u32 n)     
{     
    while(n--)     
    delay_us(1000);     
}     
     
/*点亮LED与RGB*/     
void func(void)     
{     
            GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);//RGB熄灭     
    
    while(1)     
        {     
          GPIO_SetBits(GPIOC,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);//LED全部熄灭     
           delay_ms(1000);     
                
            GPIO_ResetBits(GPIOC,GPIO_Pin_3);//点亮D4          
            delay_ms(1000);               
           GPIO_SetBits(GPIOC,GPIO_Pin_3);//熄灭D4
           delay_ms(1000);      
            GPIO_ResetBits(GPIOC,GPIO_Pin_2);//点亮D3     
                          delay_ms(1000);         
           GPIO_SetBits(GPIOC,GPIO_Pin_2);//熄灭D3     
            
            GPIO_ResetBits(GPIOC,GPIO_Pin_1);//点亮D2     
            delay_ms(1000);     
                 
           GPIO_ResetBits(GPIOC,GPIO_Pin_0);//点亮D1     
           delay_ms(1000);     
           GPIO_SetBits(GPIOC,GPIO_Pin_0);//熄灭D1     
                     GPIO_ResetBits(GPIOC,GPIO_Pin_4);//点亮D5     
         delay_ms(1000);     
           GPIO_SetBits(GPIOC,GPIO_Pin_4);//熄灭D5     
              
                          GPIO_ResetBits(GPIOC,GPIO_Pin_5);//点亮D6     
          delay_ms(1000);     
            GPIO_SetBits(GPIOC,GPIO_Pin_5);//熄灭D6   
                          
                             GPIO_ResetBits(GPIOC,GPIO_Pin_6);//点亮D7     
           delay_ms(1000);     
                           
            GPIO_ResetBits(GPIOC,GPIO_Pin_7);//点亮D8     
            delay_ms(1000);     
            GPIO_SetBits(GPIOC,GPIO_Pin_7);//熄灭D8     
/*RGB蓝红绿紫靛黄*/     
                 
            GPIO_ResetBits(GPIOA,GPIO_Pin_1);//蓝     
            delay_ms(800);     
            GPIO_SetBits(GPIOA,GPIO_Pin_1);     
                 
            GPIO_ResetBits(GPIOA,GPIO_Pin_2);//红     
            delay_ms(800);     
            GPIO_SetBits(GPIOA,GPIO_Pin_2);     
     
            GPIO_ResetBits(GPIOA,GPIO_Pin_3);//绿     
            delay_ms(800);     
           GPIO_SetBits(GPIOA,GPIO_Pin_3);     
                 
            GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2);//紫      
           delay_ms(800);       
            GPIO_SetBits(GPIOA,GPIO_Pin_2);              
                 
         GPIO_ResetBits(GPIOA,GPIO_Pin_3);//靛     
          delay_ms(800);     
            GPIO_SetBits(GPIOA,GPIO_Pin_1);     
                
           GPIO_ResetBits(GPIOA,GPIO_Pin_2);//黄     
           delay_ms(800);     
                
            GPIO_SetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);//RGB全部熄灭     
                   }     
}          
int main(void)     
{      
    RCC_Configuration();     
    GPIO_INIT();     
    func();     
}

void RCC_Configuration(void)
{
 
 RCC_DeInit();
 
 RCC_HSEConfig(RCC_HSE_ON);
 
 HSEStartUpStatus=RCC_WaitForHSEStartUp();
 if(HSEStartUpStatus==SUCCESS)
 {
  
  RCC_HCLKConfig(RCC_SYSCLK_Div1);
  
  RCC_PCLK2Config(RCC_HCLK_Div1);
  
  RCC_PCLK1Config(RCC_HCLK_Div2);
  
  FLASH_SetLatency(FLASH_Latency_2);
  
  FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
  
  RCC_PLLConfig(RCC_PLLSource_HSE_Div1,RCC_PLLMul_9);
  
  RCC_PLLCmd(ENABLE);
  
  while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY)==RESET)
  {
  }
  
  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
  
  while(RCC_GetSYSCLKSource()!=0x08)
  {
  }
 }
 
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOE|
       RCC_APB2Periph_AFIO,ENABLE);
}


void SysTick_Configuration(void)
{
   
    SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
   
    NVIC_SystemHandlerPriorityConfig(SystemHandler_SysT
   
    SysTick_ITConfig(ENABLE);
}
vu32 TimingDelay = 0;
void SysTickHandler(void)
{
    TimingDelay--; 
}


void Delay(u32 nTime)
{
   
    SysTick_CounterCmd(SysTick_Counter_Enable);
    TimingDelay = nTime;
    while(TimingDelay != 0);
   
    SysTick_CounterCmd(SysTick_Counter_Disable);
   
    SysTick_CounterCmd(SysTick_Counter_Clear);
}


void GPIO_Configration(void)
{
   
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
    GPIO_Init(GPIOA,&GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_12;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
    GPIO_Init(GPIOA,&GPIO_InitStructure);
   
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource11);
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource12);
    EXTI_InitStructure.EXTI_Line=EXTI_Line11|EXTI_Line12;
    EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling;
    EXTI_InitStructure.EXTI_LineCmd=ENABLE;
    EXTI_Init(&EXTI_InitStructure);
}


void NVIC_Configuration(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;
    #ifdef VECT_TAB_RAM
        NVIC_SetVectorTable(NVIC_VectTab_RAM,0X0);//向量表位于RAM区
    #else
        NVIC_SetVectorTable(NVIC_VectTab_FLASH,0X0);//向量表位于FLASH区
    #endif
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);//选择第一组
    //使能EXTI15_10中断，按键PA11
    NVIC_InitStructure.NVIC_IRQChannel=EXTI15_10_IRQChannel;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;// 指定抢占式优先级别0
    NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;// 指定响应优先级别0
    NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;//
    NVIC_Init(&NVIC_InitStructure);
    //使能EXTI15_10中断，按键PA12
    NVIC_InitStructure.NVIC_IRQChannel=EXTI15_10_IRQChannel;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;// 指定抢占式优先级别0
    NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;// 指定响应优先级别0
    NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;//
    NVIC_Init(&NVIC_InitStructure);
}


void EXTI15_10_IRQHandler(void)
{
    if(EXTI_GetITStatus(EXTI_Line11)!=RESET)//判断标志，中断是否发生
    {
        ...
        EXTI_ClearITPendingBit(EXTI_Line11); //清标志位
    }
    if(EXTI_GetITStatus(EXTI_Line12)!=RESET)//判断标志，中断是否发生
    {
        ...
        EXTI_ClearITPendingBit(EXTI_Line12); //清标志位
    }
}

/** 
  ****************************************************************************** 
  * @file    EXTI/EXTI_Config/main.c  
  * @author  MCD Application Team 
  * @version V3.5.0 
  * @date    08-April-2011 
  * @brief   Main program body 
  ****************************************************************************** 
  * @attention 
  * 
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS 
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE 
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY 
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING 
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE 
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. 
  * 
  * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2> 
  ****************************************************************************** 
  */   
  
/* Includes ------------------------------------------------------------------*/  
#include "stm32f10x.h"  
#include "stm32_eval.h"  
  
#include <stdio.h>  
#define VREF 3.3  
/** @addtogroup STM32F10x_StdPeriph_Examples 
  * @{ 
  */  
  
/** @addtogroup EXTI_Config 
  * @{ 
  */   
  
/* Private typedef -----------------------------------------------------------*/  
/* Private define ------------------------------------------------------------*/  
/* Private macro -------------------------------------------------------------*/  
/* Private variables ---------------------------------------------------------*/  
GPIO_InitTypeDef   GPIO_InitStructure;  
USART_InitTypeDef USART_InitStructure;  
USART_ClockInitTypeDef USART_ClockInitStructure;  
  
void RCC_Configuration(void)  
{/* 
  RCC_DeInit(); 
     
  RCC_HSICmd(ENABLE); 
  while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET); 
   
  RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI); 
   
  RCC_HSEConfig(RCC_HSE_OFF); 
  RCC_LSEConfig(RCC_LSE_OFF); 
  RCC_PLLConfig(RCC_PLLSource_HSI_Div2,RCC_PLLMul_9); //  72HMz 
  RCC_PLLCmd(ENABLE); 
  while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET); 
  RCC_ADCCLKConfig(RCC_PCLK2_Div4); 
  RCC_PCLK2Config(RCC_HCLK_Div1); 
  RCC_PCLK1Config(RCC_HCLK_Div2); 
  RCC_HCLKConfig(RCC_SYSCLK_Div1); 
  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); 
  while(RCC_GetSYSCLKSource() != 0x08); 
*/  
    SystemInit();  
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);  
  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);  
  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG  
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;  
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  
  GPIO_Init(GPIOD, &GPIO_InitStructure);  
    GPIO_ResetBits(GPIOD,GPIO_Pin_2);  
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_AFIO, ENABLE);  
  GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG  
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;  
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  
  GPIO_Init(GPIOC, &GPIO_InitStructure);  
    GPIO_SetBits(GPIOC,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);  
      RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);  
}   
  
void USART_int(long BaudRate)  
{  
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);  
       GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;  
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;   
    GPIO_Init(GPIOA, &GPIO_InitStructure);  
    /* PA10 USART1_Rx  */  
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;  
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  
    GPIO_Init(GPIOA, &GPIO_InitStructure);  
  /* USARTx 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 = BaudRate;//??????  
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;//???????8bit  
  USART_InitStructure.USART_StopBits = USART_StopBits_1;//????1  
  USART_InitStructure.USART_Parity = USART_Parity_No;//????  
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//??????none  
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//??????????  
    USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;       
    USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;        
    USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;        
    USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;  
    USART_ClockInit(USART1, &USART_ClockInitStructure);  
  USART_Init(USART1, &USART_InitStructure);  
  USART_Cmd(USART1, ENABLE);  
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);  
 USART_Cmd(USART1, ENABLE);  
}  
  
  
void PWM_Config()  
{uint16_t PrescalerValue = 0;  
    TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;  
TIM_OCInitTypeDef  TIM_OCInitStructure;  
    /* TIM2 clock enable */  
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);  
  /* GPIOA  enable */  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO  , ENABLE);  
      
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;  
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
  GPIO_Init(GPIOA, &GPIO_InitStructure);  
        TIM_Cmd(TIM2, ENABLE);  
      /* Compute the prescaler value */  
  PrescalerValue = (uint16_t) (SystemCoreClock / 24000000) - 1;  
  /* Time base configuration */  
  TIM_TimeBaseStructure.TIM_Period = 0x07FF;  
  TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue;  
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;  
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);  
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;  
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;  
  /* PWM1 Mode configuration: Channel2 */  
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  
  TIM_OCInitStructure.TIM_Pulse = 0xFFFF;  
  TIM_OC2Init(TIM2, &TIM_OCInitStructure);  
    /* PWM1 Mode configuration: Channel3 */  
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  
  TIM_OCInitStructure.TIM_Pulse = 0xFFFF;  
  TIM_OC3Init(TIM2, &TIM_OCInitStructure);  
    /* PWM1 Mode configuration: Channel4 */  
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  
  TIM_OCInitStructure.TIM_Pulse = 0xFFFF;  
  TIM_OC4Init(TIM2, &TIM_OCInitStructure);  
  TIM_ARRPreloadConfig(TIM2, ENABLE);  
}  
void delay_us(u32 n)  
{  
    u8 j;  
    while(n--)  
    for(j=0;j<10;j++);  
}  
  
void  delay_ms(u32 n)  
{  
    while(n--)  
    delay_us(1000);  
}  
void PWM_TEST()    
{    
    unsigned int temp0=0,temp1=0,temp2=0;    
    printf("PWM-RGB TEST......\r\n");    
    while(1)    
    {    
   for(temp0=0;temp0<1500;temp0++)    
        {    
        TIM_SetCompare2(TIM2, temp0);    
            delay_us(1000);    
        }    
    if (temp0>=3000)    
    {    
        delay_ms(1000);    
        temp0=0;    
        
  }    
        
    for(temp1=1;temp1<2500;temp1++)    
        {    
        TIM_SetCompare3(TIM2, temp1);    
            delay_us(1000);    
        }    
    if (temp1>=2500)    
    {    
        delay_ms(100);    
        temp1=0;    
        
  }    
  
    
        for(temp2=0;temp2<2380;temp2++)    
        {    
        TIM_SetCompare4(TIM2, temp2);    
            delay_us(1000);    
        }    
    if (temp2>=2380)    
    {    
        delay_ms(1000);    
        temp2=0;    
        
  }    
}  
}  
      
          
      
  
/* Private functions ---------------------------------------------------------*/  
  
/** 
  * @brief  Main program. 
  * @param  None 
  * @retval None 
  */  
int main(void)  
{  
          
  /*!< At this stage the microcontroller clock setting is already configured,  
       this is done through SystemInit() function which is called from startup 
       file (startup_stm32f10x_xx.s) before to branch to application main. 
       To reconfigure the default setting of SystemInit() function, refer to 
       system_stm32f10x.c file 
     */       
         
  /* System Clocks Configuration */  
  RCC_Configuration();  
USART_int(115200);  
      
    printf(" config done...\r\n");  
    PWM_Config();  
    delay_ms(1000);  
    while(1)  
    {  
        PWM_TEST();  
    }  
}  
  
  
  
#ifdef  USE_FULL_ASSERT  
  
/** 
  * @brief  Reports the name of the source file and the source line number 
  *         where the assert_param error has occurred. 
  * @param  file: pointer to the source file name 
  * @param  line: assert_param error line source number 
  * @retval None 
  */  
void assert_failed(uint8_t* file, uint32_t line)  
{   
  /* User can add his own implementation to report the file name and line number, 
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */  
  
  /* Infinite loop */  
  while (1)  
  {  
  }  
}  
  
#endif  
  
/** 
  * @} 
  */   
  
/** 
  * @} 
  */   
  
#ifdef __GNUC__  
  /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf 
     set to 'Yes') calls __io_putchar() */  
  #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)  
#else  
  #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)  
#endif /* __GNUC__ */  
    
  
  
/** 
  * @brief  Retargets the C library printf function to the USART. 
  * @param  None 
  * @retval None 
  */  
PUTCHAR_PROTOTYPE  
{  
  /* Place your implementation of fputc here */  
  /* e.g. write a character to the USART */  
  USART_SendData(EVAL_COM1, (uint8_t) ch);  
  
  /* Loop until the end of transmission */  
  while (USART_GetFlagStatus(EVAL_COM1, USART_FLAG_TC) == RESET)  
  {}  
  
  return ch;  
}  
  
#ifdef  USE_FULL_ASSERT  
  
/** 
  * @brief  Reports the name of the source file and the source line number 
  *         where the assert_param error has occurred. 
  * @param  file: pointer to the source file name 
  * @param  line: assert_param error line source number 
  * @retval None 
  */  
void assert_failed(uint8_t* file, uint32_t line)  
{   
  /* User can add his own implementation to report the file name and line number, 
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */  
  
  /* Infinite loop */  
  while (1)  
  {  
  }  
}  
  
#endif  
  
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/ 

#include "stm32f10x.h"    
#include "stm32_eval.h"    
#include    "stdio.h"    
#include "math.h"    
#define buff_size  16;         
char rx_buff[], rx_buff_count=0;    
    
GPIO_InitTypeDef  GPIO_InitStructure;    
USART_InitTypeDef  USART_InitStructure;    
NVIC_InitTypeDef  NVIC_InitStructure;    
USART_ClockInitTypeDef  USART_ClockInitStructure;    
    
void RCC_Configuration(void)    
{    
    RCC_DeInit();    
    RCC_HSICmd(ENABLE);    
    while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);    
    RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);    
    RCC_HSEConfig(RCC_HSE_OFF);    
    RCC_LSEConfig(RCC_LSE_OFF);    
    RCC_PLLConfig(RCC_PLLSource_HSI_Div2,RCC_PLLMul_9); //  72HMz    
    RCC_PLLCmd(ENABLE);    
    while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);    
    RCC_ADCCLKConfig(RCC_PCLK2_Div4);    
    RCC_PCLK2Config(RCC_HCLK_Div1);    
    RCC_PCLK1Config(RCC_HCLK_Div2);    
    RCC_HCLKConfig(RCC_SYSCLK_Div1);    
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);    
    while(RCC_GetSYSCLKSource() != 0x08);    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);    
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;    
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    
    GPIO_Init(GPIOD, &GPIO_InitStructure);    
    GPIO_ResetBits(GPIOD,GPIO_Pin_2);   
}    
void GPIO_INIT()    
{    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);   
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;    
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;     
    GPIO_Init(GPIOC, &GPIO_InitStructure);  
}    
    
void USART_int(long BaudRate)    
{    
     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);  
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;     
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;    
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     
   GPIO_Init(GPIOA, &GPIO_InitStructure);    
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;   
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;   
   GPIO_Init(GPIOA, &GPIO_InitStructure);    
  /* USARTx 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 = BaudRate;   
    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_ClockInitStructure.USART_Clock = USART_Clock_Disable;         
  USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;          
  USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;          
  USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;    
    USART_ClockInit(USART1, &USART_ClockInitStructure);    
    USART_Init(USART1, &USART_InitStructure);   
    USART_Cmd(USART1, ENABLE);     
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);    
    USART_Cmd(USART1, ENABLE);    
  /* Configure four bit for preemption priority */    
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);   
  /* Enable the USART1 Interrupt */    
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;     
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 15;    
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;    
    NVIC_Init(&NVIC_InitStructure);//?????    
}    
    
/*delay_us*/     
void delay_us(u32 n)    
{    
    u8 j;    
    while(n--)    
    for(j=0;j<10;j++);    
}    
/*delay_ms*/     
void  delay_ms(u32 n)    
{    
    while(n--)    
    delay_us(1000);    
}    
    
void USART_SendStr(char *str)  
{    
   while((*str)!='\0')   
    {       
        USART_SendData(USART1,*str++);    
        while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);    
    }    
}    
    
unsigned int translate(char *S,char j)   
{    
    unsigned int a[4],sum=0;    
    char i;    
    for(i=0;i<j;i++)    
    {    
        a[i]=S[5+j-1-i]-48;   
        sum+=a[i]*pow(10,i);  
    }    
    return sum;  
}     
    
void func(char *S,char LEN)    
{     
    char count;//    
    unsigned int sum,i,j,k;    
    if((LEN!=6)&(LEN!=7)&(LEN!=8)&(LEN!=9))   
    {USART_SendStr("\r\n Erro input!!!\r\n");}  
    else     
    {    
        count=LEN-5;  
        sum = translate(S,count);  
        GPIO_SetBits(GPIOC,0x000000ff);   
        for(k=0;k<3;k++)  
        {    
            i=0x00000100;    
            for(j=1;j<=8;j++)   
            {    
                i>>=1;    
                GPIO_ResetBits(GPIOC,i);       
                delay_ms(50);    
                GPIO_SetBits(GPIOC,i);    
                delay_ms(sum);   
            }    
        }    
    }    
}    
    
void input_ASK()    
{    
    char j;    
    func(rx_buff,rx_buff_count);    
    rx_buff_count=0;    
    for (j=0;j<rx_buff_count;j++)    
    {rx_buff[j]='\0';}   
    USART_SendStr("\n>");    
}    
    
int main(void)    
{     
    RCC_Configuration();    
    GPIO_INIT();    
    USART_int(9600);    
    GPIO_ResetBits(GPIOC,0x000000ff);  //LED灯亮  
    delay_ms(200);    
    GPIO_SetBits(GPIOC,0x000000ff); //LED灯灭  
    USART_SendStr("SyStem booting......\r\n");  
    USART_SendStr("\n>");//     
    while(1)    
        {}    
}    
    
void USART1_IRQHandler(void)     
{     
  while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET)    
  {  }     
    if(USART_ReceiveData(USART1)==0x0d)  
    {input_ASK();}    
    else    
    {    
        USART_SendData(USART1,USART_ReceiveData(USART1));    
        rx_buff[rx_buff_count]= USART_ReceiveData(USART1);    
        rx_buff_count++;    
    }    
    USART_ClearFlag(USART1, USART_FLAG_RXNE);    
}    

/**  
  ******************************************************************************  
  * @file    EXTI/EXTI_Config/main.c   
  * @author  MCD Application Team  
  * @version V3.5.0  
  * @date    08-April-2011  
  * @brief   Main program body  
  ******************************************************************************  
  * @attention  
  *  
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS  
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE  
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY  
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING  
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE  
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.  
  *  
  * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>  
  ******************************************************************************  
  */     
    
/* Includes ------------------------------------------------------------------*/    
#include "stm32f10x.h"    
#include "stm32_eval.h"    
#include <stdio.h>    
#include "spi_flash.h"    
#define VREF 3.3    
    
void delay_us(u32 n)    
{    
    u8 j;    
    while(n--)    
    for(j=0;j<10;j++);    
}    
    
void  delay_ms(u32 n)    
{    
    while(n--)    
    delay_us(1000);    
}    
    
    
#define TxBufferSize1   (countof(TxBuffer1) - 1)    
#define RxBufferSize1   (countof(TxBuffer1) - 1)    
#define countof(a)      (sizeof(a) / sizeof(*(a)))    
#define  BufferSize (countof(Tx_Buffer)-1)    
typedef enum { FAILED = 0, PASSED = !FAILED} TestStatus;    
#define  FLASH_WriteAddress     0x00000    
#define  FLASH_ReadAddress      FLASH_WriteAddress    
#define  FLASH_SectorToErase    FLASH_WriteAddress    
#define  sFLASH_ID              0xEF3015     //W25X16    
//#define  sFLASH_ID              0xEF4015   //W25Q16    
#define buff_size  16;         
char rx_buff[],rx_buff_count=0;    
/* ???????? */    
uint8_t Tx_Buffer[4096] ;    
uint8_t Rx_Buffer[BufferSize];    
__IO uint32_t DeviceID = 0;    
__IO uint32_t FlashID = 0;    
__IO TestStatus TransferStatus1 = FAILED;    
    
// ??????    
void Delay(__IO uint32_t nCount);    
TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength);    
    
/** @addtogroup STM32F10x_StdPeriph_Examples  
  * @{  
  */    
    
/** @addtogroup EXTI_Config  
  * @{  
  */     
    
/* Private typedef -----------------------------------------------------------*/    
/* Private define ------------------------------------------------------------*/    
/* Private macro -------------------------------------------------------------*/    
/* Private variables ---------------------------------------------------------*/    
GPIO_InitTypeDef   GPIO_InitStructure;    
USART_InitTypeDef USART_InitStructure;    
USART_ClockInitTypeDef USART_ClockInitStructure;    
    
char *int_to_string(int number,char *strnum)//整形数据转换为字符型    
{    
int j=0,i=0,n=0;    
char temp;    
while(number>0)    
{    
*(strnum+j)=number%10+48;    
j++;    
number=number/10;    
n++;    
}    
    
        
for(i=0;i<n/2;i++)    
{    
temp=*(strnum+j+i-n);    
*(strnum+j+i-n)=*(strnum+j-i-1);    
*(strnum+j-i-1)=temp;    
}    
strnum[n]='\0';    
return strnum;    
}    
    
void RCC_Configuration(void)    
{    
  RCC_DeInit();    
        
  RCC_HSICmd(ENABLE);    
  while(RCC_GetFlagStatus(RCC_FLAG_HSIRDY) == RESET);    
      
  RCC_SYSCLKConfig(RCC_SYSCLKSource_HSI);    
      
  RCC_HSEConfig(RCC_HSE_OFF);    
  RCC_LSEConfig(RCC_LSE_OFF);    
  RCC_PLLConfig(RCC_PLLSource_HSI_Div2,RCC_PLLMul_9); //  72HMz    
  RCC_PLLCmd(ENABLE);    
  while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);    
  RCC_ADCCLKConfig(RCC_PCLK2_Div4);    
  RCC_PCLK2Config(RCC_HCLK_Div1);    
  RCC_PCLK1Config(RCC_HCLK_Div2);    
  RCC_HCLKConfig(RCC_SYSCLK_Div1);    
  RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);    
  while(RCC_GetSYSCLKSource() != 0x08);    
    
        
    //SystemInit();    
        
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);    
 GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG    
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE);    
 GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG    
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;    
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    
  GPIO_Init(GPIOD, &GPIO_InitStructure);    
    GPIO_ResetBits(GPIOD,GPIO_Pin_2);    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_AFIO, ENABLE);    
 GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);//disable JTAG    
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;    
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    
  GPIO_Init(GPIOC, &GPIO_InitStructure);    
    GPIO_SetBits(GPIOC,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);    
      RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);    
}     
    
void USART_int(long BaudRate)    
{    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);    
       GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;    
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     
    GPIO_Init(GPIOA, &GPIO_InitStructure);    
    /* PA10 USART1_Rx  */    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;    
    GPIO_Init(GPIOA, &GPIO_InitStructure);    
  /* USARTx 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 = BaudRate;//??????    
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;//???????8bit    
  USART_InitStructure.USART_StopBits = USART_StopBits_1;//????1    
  USART_InitStructure.USART_Parity = USART_Parity_No;//????    
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//??????none    
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//??????????    
    USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;         
    USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;          
    USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;          
    USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;    
    USART_ClockInit(USART1, &USART_ClockInitStructure);    
  USART_Init(USART1, &USART_InitStructure);    
  USART_Cmd(USART1, ENABLE);    
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);    
 USART_Cmd(USART1, ENABLE);    
}    
    
TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)    
{    
  while(BufferLength--)    
  {    
    if(*pBuffer1 != *pBuffer2)    
    {    
      return FAILED;    
    }    
    
    pBuffer1++;    
    pBuffer2++;    
  }    
  return PASSED;    
}    
    
void Delay(__IO uint32_t nCount)    
{    
  for(; nCount != 0; nCount--);    
}    
    
void ADC_CONFIG(){    
    ADC_InitTypeDef ADC_InitStructure;    
    #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)    
  /* ADCCLK = PCLK2/2 */    
  RCC_ADCCLKConfig(RCC_PCLK2_Div2);     
#else    
  /* ADCCLK = PCLK2/4 */    
  RCC_ADCCLKConfig(RCC_PCLK2_Div4);     
#endif    
ADC_DeInit(ADC1);    
  /* Enable ADC1 and GPIOC clock */    
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB, ENABLE);    
        
    /* Configure PB0 (ADC Channel14) as analog input -------------------------*/    
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;    
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;    
  GPIO_Init(GPIOB, &GPIO_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);    
    
    
  /* Enable ADC1 DMA */    
  ADC_DMACmd(ADC1, ENABLE);    
      
  /* Enable ADC1 */    
  ADC_Cmd(ADC1, ENABLE);    
    
}    
    
int Get_ADC(){    
     /* ADC1 regular channel configuration */     
  ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 1, ADC_SampleTime_55Cycles5);    
    /* Enable ADC1 reset calibration register */       
  ADC_ResetCalibration(ADC1);    
  /* Check the end of ADC1 reset calibration register */    
  while(ADC_GetResetCalibrationStatus(ADC1));    
    
  /* Start ADC1 calibration */    
  ADC_StartCalibration(ADC1);    
  /* Check the end of ADC1 calibration */    
  while(ADC_GetCalibrationStatus(ADC1));    
         
  /* Start ADC1 Software Conversion */     
  ADC_SoftwareStartConvCmd(ADC1, ENABLE);    
        
    return ADC_GetConversionValue(ADC1);    
}    
    
    
void SPI_TEST()    
{    
    printf("\r\n这是一个2M SPI总线flash(W25X16)测试 \r\n");    
    SPI_FLASH_Init();    
    /* Get SPI Flash Device ID */    
    DeviceID = SPI_FLASH_ReadDeviceID();    
    Delay( 200 );    
    /* Get SPI Flash ID */    
    FlashID = SPI_FLASH_ReadID();    
    printf("\r\n FlashID is 0x%X,  Manufacturer Device ID is 0x%X\r\n", FlashID, DeviceID);    
    /* Check the SPI Flash ID */    
    if (FlashID == sFLASH_ID)  /* #define  sFLASH_ID  0xEF3015 */    
    {    
        printf("\r\n 检测到华邦flash W25X16 !\r\n");    
        /* Erase SPI FLASH Sector to write on */    
        SPI_FLASH_SectorErase(FLASH_SectorToErase);          
            
        /*写缓存并发送*/    
        SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);    
        printf("\r\n写入的数据是:%s \r\t", Tx_Buffer);    
            
        /* 读出刚才写入的数据*/    
        SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);    
        printf("\r\n读出的数据是:%s \r\n", Rx_Buffer);    
            
        /* ????????????????? */    
        TransferStatus1 = Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);    
            
        if( PASSED == TransferStatus1 )    
        {        
            printf("\r\n 2M SPI总线flash(W25X16)测试成功!\n\r");    
        }    
        else    
        {            
            printf("\r\n 2M SPI总线flash(W25X16)测试失败!\n\r");    
        }    
    }// if (FlashID == sFLASH_ID)    
    else    
    {        
        printf("\r\n 未检测到 W25X16 ID!\n\r");    
    }    
        
    SPI_Flash_PowerDown();      
    printf("\r\n=================================================\n\r");    
}    
/* Private functions ---------------------------------------------------------*/    
    
/**  
  * @brief  Main program.  
  * @param  None  
  * @retval None  
  */    
int main(void)    
{    
            
  /*!< At this stage the microcontroller clock setting is already configured,   
       this is done through SystemInit() function which is called from startup  
       file (startup_stm32f10x_xx.s) before to branch to application main.  
       To reconfigure the default setting of SystemInit() function, refer to  
       system_stm32f10x.c file  
     */         
           
  /* System Clocks Configuration */    
    int i=0;    
    int shuzhi = 0;    
     char Buffer[100];    
  RCC_Configuration();    
  USART_int(115200);    
 printf(" config done...\r\n");    
    ADC_CONFIG();    
    delay_ms(1000);    
    while(1)    
    {    
            
        for(i=0;i<5;i++)    
        {     
             shuzhi = Get_ADC();    
              int_to_string(shuzhi,Buffer);    
            Tx_Buffer[i]=Buffer[i];    
    }    
      SPI_TEST();    
        delay_ms(1000);    
    }    
}    
    
    
    
    
#ifdef  USE_FULL_ASSERT    
    
/**  
  * @brief  Reports the name of the source file and the source line number  
  *         where the assert_param error has occurred.  
  * @param  file: pointer to the source file name  
  * @param  line: assert_param error line source number  
  * @retval None  
  */    
void assert_failed(uint8_t* file, uint32_t line)    
{     
  /* User can add his own implementation to report the file name and line number,  
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */    
    
  /* Infinite loop */    
  while (1)    
  {    
  }    
}    
    
#endif    
    
/**  
  * @}  
  */     
    
/**  
  * @}  
  */     
    
#ifdef __GNUC__    
  /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf  
     set to 'Yes') calls __io_putchar() */    
  #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)    
#else    
  #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)    
#endif /* __GNUC__ */    
      
    
    
/**  
  * @brief  Retargets the C library printf function to the USART.  
  * @param  None  
  * @retval None  
  */    
PUTCHAR_PROTOTYPE    
{    
  /* Place your implementation of fputc here */    
  /* e.g. write a character to the USART */    
  USART_SendData(EVAL_COM1, (uint8_t) ch);    
    
  /* Loop until the end of transmission */    
  while (USART_GetFlagStatus(EVAL_COM1, USART_FLAG_TC) == RESET)    
  {}    
    
  return ch;    
}    
    
#ifdef  USE_FULL_ASSERT    
    
/**  
  * @brief  Reports the name of the source file and the source line number  
  *         where the assert_param error has occurred.  
  * @param  file: pointer to the source file name  
  * @param  line: assert_param error line source number  
  * @retval None  
  */    
void assert_failed(uint8_t* file, uint32_t line)    
{     
  /* User can add his own implementation to report the file name and line number,  
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */    
    
  /* Infinite loop */    
  while (1)    
  {    
  }    
}    
    
#endif    
    
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/