物联网ESP8266配置成AP模式

功能描述：

上电配置初始化时：第一个小灯会闪烁，配置完成时，小灯保持直亮；

上电完成，串口调试助手会出现ESP8266的参数，WIFI名称，WIFI密码，端口号等；

手机上连接这个WIFI，在手机上利用网络调试助手发送一些数据给ESP8266，ESP8266会将接收到的数据发送给手机，并且串口调试助手上会显示，哪部手机发送的数据和发送数据的长度。

串口调试助手是电脑端的，网络调试助手是手机端的，

上电完成，串口1显示各种初始化，如图：

按照显示的WIFI名称和密码，连接WIFI，连接后，打开手机上网络调试助手

网络调试助手配置如下：

打开网络调试助手

 在串口调试助手上显示

看最后两句话：有客户端连接，表示我们手机已经连接上了（只有我们客户端发送一个数据这句话才能显示出来）

ID=0：表示这个客户端的分机号，就是在ESP8266看来，就是第一号客户

 程序：

main.c

#include "stm32f10x.h"                
#include "led.h" 
#include "esp8266.h"
#include "esp8266_usart1.h"  
#include "esp8266_usart2.h"
#include "esp8266_delay.h"

extern char MCU_Rx_ESP8266_BUF[1024];
extern char MCU_Rx_ESP8266_Count;
char  Data_buff[2048];  //数据缓冲区
char  Data_len[5];      //数据长度缓冲区
char  Data_id[5];       //数据发送者的id缓冲区


int main()
{
	USART1_GPIO_Init();
	USART2_Init();
	led_init();
	while(ESP8266_Cmd()==0)
	{
		delay_ms(100);
	}
	else GPIO_ResetBits(GPIOC,GPIO_Pin_0);
	
	MCU_Rx_ESP8266_Count=0;                    //WiFi接收数据长度变量清零                        
	memset(MCU_Rx_ESP8266_BUF,0,1024);            //清空 ESP8266_TO_MCU 接收缓冲区
	while(1)
	{
		WiFi_Get_LinkSta();                               //检测有无客户端连接或是断开
		if(WiFi_Get_Data(Data_buff,Data_len,Data_id)){    //接收数据		
			MCU_Tx_USART1_Data("连接id:%s有%s字节数据到来rn",Data_id,Data_len);   //串口显示信息
			MCU_Tx_USART1_Data("数据:%srn",Data_buff);                            //串口显示信息
			WiFi_SendData(Char_to_Hex(Data_id,strlen(Data_id)),Data_buff,strlen(Data_buff),500);//5s的发送超时时间，发送数据
		}
	}
}

esp8266.c

#include "esp8266.h"

char a[]="AT+CWMODE=2";					//设置成AP模式（路由器）
char b[]="AT+RST";								//复位
char c[]="AT+CWSAP_DEF="ESP8266","123456789",5,4" ;//设置WIFI的名称，密码，通道号和加密方式
char d[]="AT+CIPAP="192.168.10.2"";   //开启服务器并设置AP模式的IP地址 
char h[]="AT+CIPMODE=0";			//关闭透传模式
char e[]="AT+CIPMUX=1";						//设置多连接
char f[]="AT+CIPSERVER=1,8080";   //设置端口号
char g[]="AT+CIPAP="192.168.10.2"";   //开启服务器并设置AP模式的IP地址 

extern char MCU_Tx_ESP8266_BUF[1024];
extern char MCU_Rx_ESP8266_BUF[1024];
extern uint16_t	MCU_Rx_ESP8266_Count;



void MCU_TO_ESP8266_Cmd(u8 *cmd)
{
  MCU_TO_ESP8266("%srn",cmd);	//发送命令，需要加换行符
}

uint8_t ESP8266_RST(int timeout)
{
	MCU_Rx_ESP8266_Count=0;                    //WiFi接收数据长度变量清零                        
	memset(MCU_Rx_ESP8266_BUF,0,1024);            //清空 ESP8266_TO_MCU 接收缓冲区 
	MCU_TO_ESP8266_Cmd("AT+RST");
	while(timeout--)
	{
		delay_ms(100);
		led_shanshuo();
		if(strstr(MCU_Rx_ESP8266_BUF,"ready"))
			break;
		MCU_Tx_USART1_Data("%d ",timeout);
	}
	MCU_Tx_USART1_Data("rn");
	if(timeout<=0)return 1;
	else return 0;
}

uint8_t MCU_To_ESP8266_Control(uint8_t *Cmd,int timeout)
{
	MCU_Rx_ESP8266_Count=0;                    //WiFi接收数据长度变量清零                        
	memset(MCU_Rx_ESP8266_BUF,0,1024);            //清空 ESP8266_TO_MCU 接收缓冲区
	
	MCU_TO_ESP8266_Cmd(Cmd);
	
	while(timeout--){
		delay_ms(100);
		led_shanshuo();
		if(strstr(MCU_Rx_ESP8266_BUF,"OK"))
			break;	
		MCU_Tx_USART1_Data("%d ",timeout);
	}
	if(timeout<=0)return 1;
	else return 0;
}

uint8_t ESP8266_Cmd()
{
	MCU_Tx_USART1_Data("准备复位ESP8266rn");
	if(ESP8266_RST(50)){
		MCU_Tx_USART1_Data("复位失败，准备重新复位rn");
		return 0;
	}
	else MCU_Tx_USART1_Data("复位成功rn");
	MCU_Tx_USART1_Data("rn");
	
	MCU_Tx_USART1_Data("ESP8266设置成AP模式rn");
	if(MCU_To_ESP8266_Control("AT+CWMODE=2",50)==1){
		MCU_Tx_USART1_Data("设置失败，重新设置rn");
		return 0;
	}
	else MCU_Tx_USART1_Data("设置成功rn"); 
	MCU_Tx_USART1_Data("rn");
	
	MCU_Tx_USART1_Data("设置WIFI的名称和密码rn");
	if(MCU_To_ESP8266_Control("AT+CWSAP_DEF="CMCC-ESP8266","123456789",5,4" ,50)==1){
		MCU_Tx_USART1_Data("设置失败，重新设置rn");
		return 0;
	}
	else MCU_Tx_USART1_Data("设置成功rn");

	MCU_Tx_USART1_Data("ESP8266设置成AP模式rn");
	if(MCU_To_ESP8266_Control("AT+CWMODE=2",50)==1){
		MCU_Tx_USART1_Data("设置失败，重新设置rn");
		return 0;
	}
	else MCU_Tx_USART1_Data("设置成功rn"); 
	MCU_Tx_USART1_Data("rn");
	
	MCU_Tx_USART1_Data("设置AP的IP地址rn");
	if(MCU_To_ESP8266_Control("AT+CIPAP="192.168.10.2"" ,50)==1){
		MCU_Tx_USART1_Data("设置失败，重新设置rn");
		return 0;
	}
	else MCU_Tx_USART1_Data("设置成功rn");
	MCU_Tx_USART1_Data("WIFI名称: %srn",ESP8266_SSID);
	MCU_Tx_USART1_Data("WIFI密码: %srn",ESP8266_PASS);
	MCU_Tx_USART1_Data("WIFI IP地址: %srn",ESP8266_IP);
	MCU_Tx_USART1_Data("rn");
	
	MCU_Tx_USART1_Data("关闭透传模式rn");
	if(MCU_To_ESP8266_Control("AT+CIPMODE=0",50)==1){
		MCU_Tx_USART1_Data("设置失败，重新设置rn");
		return 0;
	}
	else MCU_Tx_USART1_Data("设置成功rn"); 
	MCU_Tx_USART1_Data("rn");
	
	MCU_Tx_USART1_Data("设置成多连接rn");
	if(MCU_To_ESP8266_Control("AT+CIPMUX=1",50)==1){
		MCU_Tx_USART1_Data("设置失败，重新设置rn");
		return 0;
	}
	else MCU_Tx_USART1_Data("设置成功rn"); 
	MCU_Tx_USART1_Data("rn");
	
	MCU_Tx_USART1_Data("设置ESP8266的端口号rn");
	if(MCU_To_ESP8266_Control("AT+CIPSERVER=1,8080",50)==1){
		MCU_Tx_USART1_Data("设置失败，重新设置rn");
		return 0;
	}
	else{
		MCU_Tx_USART1_Data("端口号为: %srn",duankouhao);
		MCU_Tx_USART1_Data("设置成功rn"); 
		 MCU_Tx_USART1_Data("rn"); 
		return 1;
	}
}









char WiFi_Get_LinkSta(void)
{
	char id_temp[10]={0};    //缓冲区，存放ID
	char sta_temp[10]={0};   //缓冲区，存放状态
	
	if(strstr(MCU_Rx_ESP8266_BUF,"CONNECT")){                 //如果接受到CONNECT表示有客户端连接	
		sscanf(MCU_Rx_ESP8266_BUF,"%[^,],%[^,]",id_temp,sta_temp);
		MCU_Tx_USART1_Data("有客户端接入，ID=%srn",id_temp);  //串口显示信息
		MCU_Rx_ESP8266_Count=0;                              //WiFi接收数据量变量清零                        
		memset(MCU_Rx_ESP8266_BUF,0,1024);        //清空WiFi接收缓冲区     
		return 1;                                      //有客户端接入
	}else if(strstr(MCU_Rx_ESP8266_BUF,"CLOSED")){            //如果接受到CLOSED表示有链接断开	
		sscanf(MCU_Rx_ESP8266_BUF,"%[^,],%[^,]",id_temp,sta_temp);
		MCU_Tx_USART1_Data("有客户端断开，ID=%srn",id_temp);        //串口显示信息
		MCU_Rx_ESP8266_Count=0;                                    //WiFi接收数据量变量清零                        
		memset(MCU_Rx_ESP8266_BUF,0,1024);              //清空WiFi接收缓冲区     
		return 2;                                            //有客户端断开
	}else return 0;                                          //无状态改变	
}










char WiFi_Get_Data(char *data, char *len, char *id)
{
	char temp[10]={0};      //缓冲区
	char *presult;

	if(strstr(MCU_Rx_ESP8266_BUF,"+IPD")){      
		delay_ms(10);                                       //延时
		sscanf(MCU_Rx_ESP8266_BUF,"%[^,],%[^,],%[^:]",temp,id,len);//截取各段数据，主要是id和数据长度	
		presult = strstr(MCU_Rx_ESP8266_BUF,":");                  //查找冒号。冒号后的是数据
		if( presult != NULL )                               //找到冒号
			sprintf((char *)data,"%s",(presult+1));         //冒号后的数据，复制到data
		MCU_Rx_ESP8266_Count=0;                                   //WiFi接收数据量变量清零                        
		memset(MCU_Rx_ESP8266_BUF,0,1024);             //清空WiFi接收缓冲区    
		return 1;                                           //有数据到来
	} else return 0;                                        //无数据到来
}













char WiFi_SendData(char id, char *databuff, int data_len, int timeout)
{    
	int i;
	
	MCU_Rx_ESP8266_Count=0;                                 //WiFi接收数据量变量清零                        
	memset(MCU_Rx_ESP8266_BUF,0,1024);           //清空WiFi接收缓冲区 
	MCU_TO_ESP8266("AT+CIPSEND=%d,%drn",id,data_len);  //发送指令	
    while(timeout--){                                 //等待超时与否	
		delay_ms(10);                                 //延时10ms
		if(strstr(MCU_Rx_ESP8266_BUF,">"))                   //如果接收到>表示成功
			break;       						      //主动跳出while循环
		MCU_Tx_USART1_Data("%d ",timeout);                     //串口输出现在的超时时间
	}
	if(timeout<=0)return 1;                                   //超时错误，返回1
	else{                                                     //没超时，正确       	
		MCU_Rx_ESP8266_Count=0;                                     //WiFi接收数据量变量清零                        
		memset(MCU_Rx_ESP8266_BUF,0,1024);               //清空WiFi接收缓冲区 	
		for(i=0;i 
esp8266.h
 
#ifndef __esp8266_H
#define __esp8266_H

#include "stm32f10x.h"                 
#include "esp8266_usart2.h"      //包含需要的头文件
#include "esp8266_usart1.h"
#include "esp8266_delay.h"	    
#include "led.h"  
   
#define ESP8266_IP   "192.168.10.2"
#define ESP8266_SSID "CMCC-EAP8266"
#define ESP8266_PASS "123456789"
#define duankouhao "8080"


uint8_t ESP8266_RST(uint16_t	timeout);
uint8_t MCU_To_ESP8266_Control(uint8_t *Cmd,uint16_t timeout);
uint8_t ESP8266_Cmd();

char WiFi_Get_LinkSta(void);
char WiFi_Get_Data(char *data, char *len, char *id);
char WiFi_SendData(char id, char *databuff, int data_len, int timeout);
int	Char_to_Hex(char *char_data, int len);

#endif

 
esp8266_usart1.c
 
#include "esp8266_usart1.h"               


unsigned int MCU_Rx_USART1_Count = 0;      //定义一个变量，记录串口1总共接收了多少字节的数据
char MCU_Rx_USART1_BUF[1024]; //定义一个数组，用于保存串口1接收到的数据   	
char MCU_Tx_USART1_BUF[1024];  
unsigned int MCU_Tx_USART1_Count=0;






void USART1_GPIO_Init()
{  	 	
  GPIO_InitTypeDef GPIO_InitStructure;     //定义GPIO结构体
	USART_InitTypeDef USART_InitStructure;   //定义串口结构体
	NVIC_InitTypeDef NVIC_InitStructure;     //定义中断结构体
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  //使能串口1时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);   //使能GPIOA时钟
	
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;              //准备设置PA9
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;      //IO速率50M
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	       //复用推挽输出，用于串口1的发送
  GPIO_Init(GPIOA, &GPIO_InitStructure);                 //设置PA9
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;             //准备设置PA10 
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  //浮空输入，用于串口1的接收
  GPIO_Init(GPIOA, &GPIO_InitStructure);                 //设置PA10
	
	USART_InitStructure.USART_BaudRate = 115200;                                    //波特率设置
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;                    //8个数据位
	USART_InitStructure.USART_StopBits = USART_StopBits_1;                         //1个停止位
	USART_InitStructure.USART_Parity = USART_Parity_No;                            //无奇偶校验位
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;	               //收发模式   
  USART_Init(USART1, &USART_InitStructure);              //初始化串口1	
	
	USART_ClearFlag(USART1, USART_FLAG_RXNE);	            //清除接收标志位
	
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);          //开启接收中断
  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;       //设置串口1中断
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0; //抢占优先级0
	NVIC_InitStructure.NVIC_IRQChannelSubPriority =0;		//子优先级0
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//中断通道使能
	NVIC_Init(&NVIC_InitStructure);	                        //设置串口1中断 
	
	USART_Cmd(USART1, ENABLE);                              //使能（开启）串口1
}







void MCU_Tx_USART1_Data(char* fmt,...) 
{  
	unsigned int i,length;
	
	va_list ap;											//定义一个指针变量
	va_start(ap,fmt);							//把多个参数的起始参数的地址放入ap中，因为ap是指针
	vsprintf(MCU_Tx_USART1_BUF,fmt,ap);//把多个变参，放入MCU_Tx_USART1_BUF数组中
	va_end(ap);	
	
	length=strlen((const char*)MCU_Tx_USART1_BUF);//计算出MCU_Tx_USART1_BUF的长度		
	while((USART1->SR&0x40)==0);
	for(i = 0;i < length;i ++)
	{			
		USART1->DR = MCU_Tx_USART1_BUF[i];//把数组MCU_Tx_USART1_BUF中的数据放入串口1的寄存器中，打印出来
		while((USART1->SR&0x40)==0);	
	}	
}

void USART1_IRQHandler(void)   
{                      
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET){  //如果USART_IT_RXNE标志置位，表示有数据到了，进入if分支
		if(USART1->DR){                                     //非零值才保存到缓冲区	
			MCU_Rx_USART1_BUF[MCU_Rx_USART1_Count]=USART1->DR;     //保存到缓冲区	
			MCU_Rx_USART1_Count ++;                            //每接收1个字节的数据，Usart2_RxCounter加1，表示接收的数据总量+1 
		}		
		MCU_Tx_USART1_Data(MCU_Rx_USART1_BUF);
	}
} 


 
esp8266_usart1.h
 
#ifndef __esp8266_usart1_H
#define __esp8266_usart1_H


#include "stm32f10x.h"           
#include "stdio.h"      //包含需要的头文件
#include "stdarg.h"		//包含需要的头文件 
#include "string.h"     //包含需要的头文件




void MCU_Tx_USART1_Data(char* fmt,...) ;
void USART1_GPIO_Init(void);




#endif


 
esp8266_usart2.c
 
#include "esp8266_usart2.h"           

char MCU_Tx_ESP8266_BUF[1024];
char MCU_Rx_ESP8266_BUF[1024];
uint16_t	MCU_Rx_ESP8266_Count=0;







void USART2_Init()
{  	 	
  GPIO_InitTypeDef GPIO_InitStructure;     //定义一个设置GPIO功能的变量
	USART_InitTypeDef USART_InitStructure;   //定义一个设置串口功能的变量
	NVIC_InitTypeDef NVIC_InitStructure;     //如果使能接收功能，定义一个设置中断的变量

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);  //使能串口2时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);   //使能GPIOA时钟
	
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;              //准备设置PA2   Tx
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;      //IO速率50M
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	       //复用推挽输出，用于串口2的发送
  GPIO_Init(GPIOA, &GPIO_InitStructure);                 //设置PA2
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;              //准备设置PA3   Rx
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  //浮空输入，用于串口2的接收
  GPIO_Init(GPIOA, &GPIO_InitStructure);                 //设置PA3
	
	USART_InitStructure.USART_BaudRate = 115200;                                    //波特率设置
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;                    //8个数据位
	USART_InitStructure.USART_StopBits = USART_StopBits_1;                         //1个停止位
	USART_InitStructure.USART_Parity = USART_Parity_No;                            //无奇偶校验位
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制

	USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;	               //收发模式  
  USART_Init(USART2, &USART_InitStructure);                                      //设置串口2	
	USART_Cmd(USART2, ENABLE);                              //使能串口2

	USART_ClearFlag(USART2, USART_FLAG_RXNE);	            //清除接收标志位
	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);          //开启接收中断
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
		
  NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;       //设置串口2中断
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0; //抢占优先级0
	NVIC_InitStructure.NVIC_IRQChannelSubPriority =0;		//子优先级0
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//中断通道使能
	NVIC_Init(&NVIC_InitStructure);	                        //设置串口2中断 
}






									



void MCU_TO_ESP8266(char* fmt,...) 
{  
	unsigned int i,length;
	va_list ap;
	va_start(ap,fmt);
	vsprintf(MCU_Tx_ESP8266_BUF,fmt,ap);
	va_end(ap);	
	
	length=strlen((const char*)MCU_Tx_ESP8266_BUF);		
	while((USART2->SR&0x40)==0);
	for(i = 0;i < length;i ++)
	{			
		USART2->DR = MCU_Tx_ESP8266_BUF[i];
		while((USART2->SR&0x40)==0);	
	}	
}







void USART2_IRQHandler(void)   
{                      
	if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET){  //如果USART_IT_RXNE标志置位，表示有数据到了，进入if分支
		if(USART2->DR){                                     //非零值才保存到缓冲区	
			MCU_Rx_ESP8266_BUF[MCU_Rx_ESP8266_Count]=USART2->DR;     //保存到缓冲区	
			MCU_Rx_ESP8266_Count ++;                            //每接收1个字节的数据，Usart2_RxCounter加1，表示接收的数据总量+1 
		}		
	}
} 
 
esp8266_usart2.h
 
#ifndef __esp8266_usart2_H
#define __esp8266_usart2_H

#include "stm32f10x.h"                 
#include "stdio.h"      //包含需要的头文件
#include "stdarg.h"		//包含需要的头文件 
#include "string.h"     //包含需要的头文件





void USART2_Init();     
void MCU_TO_ESP8266(char*,...) ;          

#endif


 
esp8266_delay.c就是正常的延时函数
 
#include "esp8266_delay.h"


void delay_us(uint32_t xus)
{
	SysTick->LOAD = 72 * xus;				//设置定时器重装值
	SysTick->VAL = 0x00;					//清空当前计数值
	SysTick->CTRL = 0x00000005;				//设置时钟源为HCLK，启动定时器
	while(!(SysTick->CTRL & 0x00010000));	//等待计数到0
	SysTick->CTRL = 0x00000004;				//关闭定时器
}


void delay_ms(uint32_t xms)
{
	while(xms--)
	{
		delay_us(1000);
	}
}
 

void delay_s(uint32_t xs)
{
	while(xs--)
	{
		delay_ms(1000);
	}
} 





 
esp8266_delay.h
 
#ifndef __esp8266_delay_H
#define __esp8266_delay_H


#include "stm32f10x.h" 
	 
void delay_us(uint32_t us);
void delay_ms(uint32_t ms);
void delay_s(uint32_t s);


#endif









 
led.c
 
#include "led.h"              
#include "esp8266_delay.h"

void led_init(void)
{

	GPIO_InitTypeDef GPIO_InitStruct;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
	
	GPIO_InitStruct.GPIO_Mode =GPIO_Mode_Out_PP ;
	GPIO_InitStruct.GPIO_Pin=GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4;
	GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz ;
	GPIO_Init(GPIOC,&GPIO_InitStruct);
	GPIO_SetBits (GPIOC,GPIO_Pin_All);
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG,ENABLE);
	GPIO_InitStruct.GPIO_Mode =GPIO_Mode_Out_PP ;
	GPIO_InitStruct.GPIO_Pin=GPIO_Pin_7;
	GPIO_InitStruct.GPIO_Speed=GPIO_Speed_50MHz ;
	GPIO_Init(GPIOG,&GPIO_InitStruct);
	GPIO_SetBits (GPIOG,GPIO_Pin_7);
}

void led_shanshuo(void)
{
	GPIO_ResetBits(GPIOC,GPIO_Pin_0);
	delay_ms(100);
	GPIO_SetBits(GPIOC,GPIO_Pin_0);
}


 
led.h
 
#ifndef __led_init_H_
#define __led_init_H_

#include "stm32f10x.h"                  // Device header



void led_init(void);
void led_shanshuo(void);
#endif