devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于Lora实现的屋内火灾报警系统_(1)选择一种无线通信技术,实现火灾报警系统在室内的连接,说明理由并画出组网示意

作者：盐析白兔 | 2024-06-04 18:54:29

赞

踩

(1)选择一种无线通信技术,实现火灾报警系统在室内的连接,说明理由并画出组网示意

1.功能设计

  本项目设计一种基于LORA无线通信的屋内火灾报警控制系统，采用DH11温湿度传感器跟MQ-2烟雾传感器作为火警安防系统，对房内温度，湿度，还有环境可燃气体，烟雾等实时检测，LORA通信为通信报警方法，LED跟蜂鸣器为声光报警，SG90舵机做为应急措施的开关。当温度湿度传感部分采集到超过限定温度值和低于限定湿度值时，会将信号发给相对应的传感检测部分，然后传感检测部分将信号发给核心处理器单片机，STM32F103RCT6核心处理单片机引脚电平转换，驱动声光报警系统和应急措施，同时启动LORA通信发送给业主和物业，让救援人员来时了解到大致情况做好充足准备。

 （1） 检测项目：当环境温度≥45℃，湿度≤10%就可被判定为火灾，或者可燃气体甲烷浓度≥5%也可被判定为火灾可能发生，实施报警，并且采取应急措施。烟雾浓度≥5%被认定为有毒害，实施报警。

 

（2） 报警方式：声光报警，小区物业报警，户主报警。

（3） 应急措施：通过舵机控制阻燃气体的发射。

2.硬件设计

  本系统由电源电路、主控制器、温度，湿度检测电路、烟雾可燃气体检测电路，LORA模块收发电路，应急措施电路，信息显示电路，声光报警电路等8个部分组成。

 

3.软件设计

 

 

其余介绍看，评论区报告链接，硬件设备工作流程图，以及步骤介绍等等。。。

程序分享

1.main.c

  1. #include "led.h"
  2. #include "sys.h"
  3. #include "usart.h"
  4. #include "lcd.h"
  5. #include "dh11.h"   
  6. #include "adc.h"  
  7. #include "sys.h"
  8. #include "delay.h"
  9. #include "pwm.h"
  10. #include "beep.h"
  11. #include "lora.h"
  12. #include "usart1.h"
  13. #include "usart3.h"
  14. char lora_tx_data[100];
  15. char lora_rx_data[100];
  16.  int main(void)
  17.  { 
  18. 	u16 ADC_SHIDU ;
  19. 	u8 t=0;			 
  20. 	u8 temp;   
  21. 	u8 humi;
  22. 	 
  23. 	delay_init();	    	 //延时函数初始化	  
  24.   Adc_Init();   	 //延时函数初始化	  
  25. 	uart_init(115200);	 	//串口初始化为9600
  26. 	LED_Init();		  		//初始化与LED连接的硬件接口
  27.  	LCD_Init();
  28. 	Beep_Init();//蜂鸣器初始化 
  29.   SystemInit();	//配置系统时钟为 72M  
  30. 	USART1_Config();
  31. 	TIM3_PWM_Init(899,0);//不分频。PWM频率=72000/(899+1)=80Khz 
  32. 	USART3_Config(115200); //USART3 配置 		
  33. 	LORA_Init();
  34. 	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
  35. 	 
  36. 	 
  37.  	POINT_COLOR=BLUE;//设置字体为蓝色 
  38. 	LCD_ShowString(60,50,200,16,16,"GHB");	
  39. 	LCD_ShowString(60,70,200,16,16,"GXW");	
  40. 	LCD_ShowString(60,90,200,16,16,"LX");
  41. 	LCD_ShowString(60,110,200,16,16,"2021/12/6");		  
  42. 	LCD_ShowString(60,130,200,16,16,"DHT11 OK");
  43. 	LCD_ShowString(60,150,200,16,16,"QCM2  OK");
  44. 	POINT_COLOR=BLUE;//设置字体为蓝色 
  45.  	LCD_ShowString(60,170,200,16,16,"Temp:   . C");	 
  46. 	LCD_ShowString(60,190,200,16,16,"Humi:   %");	 
  47. 	LCD_ShowString(60,210,200,16,16,"Qtzl:   %");
  48. 	
  49.  
  50. 	while(DHT11_Init())	//DHT11初始化	
  51. 	{
  52. 		LCD_ShowString(60,130,200,16,16,"DHT11 Error");
  53. 		delay_ms(200);
  54. 		LCD_Fill(60,130,239,130+16,WHITE);
  55.  		delay_ms(200);
  56. 	}								   
  57. 	while(1)
  58. 	{	    	   
  59.    ADC_SHIDU=ADC_Get_aveg(ADC_Channel_1,10);
  60. 	 ADC_SHIDU = (float)(ADC_SHIDU/4096.0)*100;   
  61.  
  62. 		{		
  63. 			
  64.        DHT11_Read_Data(&temp,&humi);	//读取温湿度值	
  65.        LCD_ShowNum(60+40+4,170,temp,2,16);	//显示温度		
  66.        LCD_ShowNum(60+40+28,170,temp%10,1,16);	//显示温度				
  67. 	     LCD_ShowNum(60+40+6,190,humi,2,16);		//显示湿度	 			
  68.        LCD_ShowNum(60+40+6,210,ADC_SHIDU,2,16);	
  69. 				delay_ms(100);
  70. 		}
  71. 	 	delay_ms(10);
  72. 		t++;
  73. 		if(t==20)
  74. 		{
  75. 			t=0;
  76. 			LED1=!LED1;
  77. 		}
  78. 		
  79. 		if(temp>30)
  80. 		{
  81. 			
  82. 			delay_ms(100);
  83. 		LED0=!LED0;
  84. 		delay_ms(100);
  85. 		LED1=!LED1;
  86. 		GPIO_ResetBits(GPIOA, GPIO_Pin_8);//输出低电平
  87. 		delay_ms(100);		
  88. 		GPIO_SetBits(GPIOA, GPIO_Pin_8);//输出高电平
  89. 		delay_ms(100);			//延时100毫秒
  90. 		TIM_SetCompare1(TIM3, 195);//0度
  91. 		delay_ms(100);
  92. 		TIM_SetCompare1(TIM3, 190);//45度
  93. 		delay_ms(100);	
  94. 	 sprintf((char*)lora_tx_data,"温度：%d‰\r\n烟雾：%d %$", temp,  ADC_SHIDU);
  95. 		lora_transmit(lora_tx_data);	
  96. 		delay_ms(100);	
  97. 		}
  98. 		if(ADC_SHIDU>40)
  99. 		{
  100. 			
  101. 		delay_ms(100);
  102. 		LED0=!LED0;
  103. 		delay_ms(100);
  104. 		LED1=!LED1;
  105. 		GPIO_ResetBits(GPIOA, GPIO_Pin_8);//输出低电平
  106. 		delay_ms(100);		
  107. 		GPIO_SetBits(GPIOA, GPIO_Pin_8);//输出高电平
  108. 		delay_ms(100);			//延时100毫秒
  109. 		TIM_SetCompare1(TIM3, 195);//0度
  110. 		delay_ms(100);
  111. 		TIM_SetCompare1(TIM3, 190);//45度
  112. 		delay_ms(100);	
  113. 	 sprintf((char*)lora_tx_data,"温度：%d‰\r\n烟雾：%d %$", temp,  ADC_SHIDU);
  114. 		lora_transmit(lora_tx_data);	
  115. 		delay_ms(100);
  116. 		}
  117. 		
  118. 	}
  119. }

2. LORA.C

  1. #include "lora.h"
  2. //#include "usart.h"
  3. #include "usart1.h"
  4. #include "usart3.h"
  5. #include "delay.h"
  6. #include "led.h"
  7.  
  8. void MD0_Config(void)	
  9. {
  10.   GPIO_InitTypeDef GPIO_InitStructure;
  11.   RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE); // 使能PC端口时钟  
  12.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;	//选择对应的引脚
  13.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;       
  14.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  15.   GPIO_Init(GPIOA, &GPIO_InitStructure);  //初始化PC端口
  16.   GPIO_ResetBits(GPIOA, GPIO_Pin_11 );	 //拉低
  17. }
  18.  
  19. void AUX_Config(void)
  20. {
  21. 	GPIO_InitTypeDef GPIO_InitStructure;
  22.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE); //开启按键端口PA的时钟
  23. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; 
  24. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz; 
  25. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //端口配置为下拉输入
  26. 	GPIO_Init(GPIOA, &GPIO_InitStructure);	//初始化端口
  27. 	GPIO_ResetBits(GPIOA, GPIO_Pin_4 );	 // 关闭所有LED
  28. }
  29.  
  30. int AUX(void) 
  31. {
  32. 		if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_4) == 1)
  33. 			return 1;
  34. 		else
  35. 			return 0;
  36. }					
  37. void lora_check(void)
  38. {
  39. 	int OK_state = 0;
  40. 	while(AUX())//检测模块是否在忙
  41. 	{
  42. 		 UART1TX("Lora正忙1");
  43. 		 delay_ms(500);
  44. 	}
  45. 	MD0(1);
  46. 	delay_ms(40);
  47. 	UART1TX("LORA检测中......");
  48. 	while(!OK_state)//模块检测成功
  49. 	{
  50. 		UART3TX("AT");
  51. 		UART3Test(&OK_state);	
  52. 	}
  53. 	UART1TX("LORA检测成功");
  54. 	UART1TX("   ");
  55. }
  56.  
  57. void lora_set(void)
  58. {
  59. 	/*#####设置地址#########*/
  60. 	int OK_state = 0;
  61. 	char addr[20] = {0};int t1 = 0,t2 = 0;
  62. 	unsigned char i = 0;
  63. 	while(AUX())//等待模块空闲
  64. 	{
  65. 		 UART1TX("Lora正忙2");
  66. 	}
  67. 	MD0(1);
  68. 	delay_ms(40);
  69. 	while(!OK_state)//模块检测成功
  70. 	{
  71. 		UART3TX("AT+ADDR=00,00");
  72. 		UART3Test(&OK_state);
  73. 		UART1TX("地址设置中......");
  74. 	}
  75. 	UART1TX("地址为：");
  76. 	UART3TX("AT+ADDR?");
  77. 	while(1)
  78. 	{
  79. 			UART3GetByte(&i);
  80. 			if(i==':')
  81. 			{
  82. 				while(1)
  83. 				{
  84. 					if(UART3GetByte(&i) == 1 && i!='O')
  85. 					{
  86. 						addr[t1++]=i;
  87. 					}
  88. 					else if(i=='O')
  89. 						break;	 
  90. 				}
  91. 				while(1)
  92. 				{
  93. 						UART1SendByte(addr[t2++]);
  94. 						if(t1 == t2)
  95. 							break;
  96. 				}
  97. 				break;
  98. 			} 
  99. 	}
  100. 	UART1TX("  ");
  101. 	/*#################设置信道和速率###############*/
  102. 	OK_state = 0; 
  103. 	t1 = 0;
  104. 	t2 = 0;
  105. 	
  106. 	while(!OK_state)//模块检测成功
  107. 	{
  108. 		UART3TX("AT+WLRATE=23,5");
  109. 		UART3Test(&OK_state);
  110. 		UART1TX("信道速率设置中......");
  111. 	}
  112. 	UART1TX("信道，速率为：");
  113. 	UART3TX("AT+WLRATE?");
  114. 	while(1)
  115. 	{
  116. 			UART3GetByte(&i);
  117. 			if(i==':')
  118. 			{
  119. 				while(1)
  120. 				{
  121. 					if(UART3GetByte(&i) == 1 && i!='O')
  122. 					{
  123. 						addr[t1++]=i;
  124. 					}
  125. 					else if(i=='O')
  126. 						break;	 
  127. 				}
  128. 				while(1)
  129. 				{
  130. 						UART1SendByte(addr[t2++]);
  131. 						if(t1 == t2)
  132. 							break;
  133. 				}
  134. 				break;
  135. 			} 
  136. 	}
  137. 	UART1TX("  ");	
  138. /*#############发射功率##############*/
  139. 	OK_state = 0; 
  140. 	t1 = 0;
  141. 	t2 = 0;
  142. 	
  143. 	while(!OK_state)//模块检测成功
  144. 	{
  145. 		UART3TX("AT+TPOWER=3");
  146. 		UART3Test(&OK_state);
  147. 		UART1TX("发射功率设置中......");
  148. 	}
  149. 	UART1TX("发射功率为：");
  150. 	UART3TX("AT+TPOWER?");
  151. 	while(1)
  152. 	{
  153. 			UART3GetByte(&i);
  154. 			if(i==':')
  155. 			{
  156. 				while(1)
  157. 				{
  158. 					if(UART3GetByte(&i) == 1 && i!='O')
  159. 					{
  160. 						addr[t1++]=i;
  161. 					}
  162. 					else if(i=='O')
  163. 						break;	 
  164. 				}
  165. 				while(1)
  166. 				{
  167. 						UART1SendByte(addr[t2++]);
  168. 						if(t1 == t2)
  169. 							break;
  170. 				}
  171. 				break;
  172. 			} 
  173. 	}
  174. 	UART1TX("  ");	
  175. /*#################工作模式###################*/
  176. 	OK_state = 0; 
  177. 	t1 = 0;
  178. 	t2 = 0;
  179. 	
  180. 	while(!OK_state)//模块检测成功
  181. 	{
  182. 		UART3TX("AT+CWMODE=0");
  183. 		UART3Test(&OK_state);
  184. 		UART1TX("工作模式设置中......");
  185. 	}
  186. 	UART1TX("工作模式为：");
  187. 	UART3TX("AT+CWMODE?");
  188. 	while(1)
  189. 	{
  190. 			UART3GetByte(&i);
  191. 			if(i==':')
  192. 			{
  193. 				while(1)
  194. 				{
  195. 					if(UART3GetByte(&i) == 1 && i!='O')
  196. 					{
  197. 						addr[t1++]=i;
  198. 					}
  199. 					else if(i=='O')
  200. 						break;	 
  201. 				}
  202. 				while(1)
  203. 				{
  204. 						UART1SendByte(addr[t2++]);
  205. 						if(t1 == t2)
  206. 							break;
  207. 				}
  208. 				break;
  209. 			} 
  210. 	}
  211. 	UART1TX("  ");		
  212. /*#################发送状态#################*/
  213. 	OK_state = 0; 
  214. 	t1 = 0;
  215. 	t2 = 0;
  216. 	
  217. 	while(!OK_state)//模块检测成功
  218. 	{
  219. 		UART3TX("AT+TMODE=0");//0：透明传输，1：定向传输
  220. 		UART3Test(&OK_state);
  221. 		UART1TX("发送状态设置中......");
  222. 	}
  223. 	UART1TX("发送状态为：");
  224. 	UART3TX("AT+TMODE?");
  225. 	while(1)
  226. 	{
  227. 			UART3GetByte(&i);
  228. 			if(i==':')
  229. 			{
  230. 				while(1)
  231. 				{
  232. 					if(UART3GetByte(&i) == 1 && i!='O')
  233. 					{
  234. 						addr[t1++]=i;
  235. 					}
  236. 					else if(i=='O')
  237. 						break;	 
  238. 				}
  239. 				while(1)
  240. 				{
  241. 						UART1SendByte(addr[t2++]);
  242. 						if(t1 == t2)
  243. 							break;
  244. 				}
  245. 				break;
  246. 			} 
  247. 	}
  248. 	UART1TX("  ");	
  249. /*#############睡眠时间#################*/
  250. 	OK_state = 0; 
  251. 	t1 = 0;
  252. 	t2 = 0;
  253. 	
  254. 	while(!OK_state)//模块检测成功
  255. 	{
  256. 		UART3TX("AT+WLTIME=0");
  257. 		UART3Test(&OK_state);
  258. 		UART1TX("睡眠时间设置中......");
  259. 	}
  260. 	UART1TX("睡眠时间为：");
  261. 	UART3TX("AT+WLTIME?");
  262. 	while(1)
  263. 	{
  264. 			UART3GetByte(&i);
  265. 			if(i==':')
  266. 			{
  267. 				while(1)
  268. 				{
  269. 					if(UART3GetByte(&i) == 1 && i!='O')
  270. 					{
  271. 						addr[t1++]=i;
  272. 					}
  273. 					else if(i=='O')
  274. 						break;	 
  275. 				}
  276. 				while(1)
  277. 				{
  278. 						UART1SendByte(addr[t2++]);
  279. 						if(t1 == t2)
  280. 							break;
  281. 				}
  282. 				break;
  283. 			} 
  284. 	}
  285. 	UART1TX("  ");	
  286. /*################波特率，数据校验位####################*/
  287. 	OK_state = 0; 
  288. 	t1 = 0;
  289. 	t2 = 0;
  290. 	
  291. 	while(!OK_state)//模块检测成功
  292. 	{
  293. 		UART3TX("AT+UART=3,0");
  294. 		UART3Test(&OK_state);
  295. 		UART1TX("波特率，数据校验位设置中......");
  296. 	}
  297. 	UART1TX("波特率，数据校验位为：");
  298. 	UART3TX("AT+UART?");
  299. 	while(1)
  300. 	{
  301. 			UART3GetByte(&i);
  302. 			if(i==':')
  303. 			{
  304. 				while(1)
  305. 				{
  306. 					if(UART3GetByte(&i) == 1 && i!='O')
  307. 					{
  308. 						addr[t1++]=i;
  309. 					}
  310. 					else if(i=='O')
  311. 						break;	 
  312. 				}
  313. 				while(1)
  314. 				{
  315. 						UART1SendByte(addr[t2++]);
  316. 						if(t1 == t2)
  317. 							break;
  318. 				}
  319. 				break;
  320. 			} 
  321. 	}
  322. 	UART1TX("  ");	
  323. 	MD0(0);
  324. 	delay_ms(40);
  325. 	while(AUX());
  326. 	USART3_Config(9600); //USART3 配置 
  327. 	
  328. 	
  329. 	UART1TX("LORA配置完成######################");
  330. }
  331.  
  332.  
  333.  
  334. void lora_transmit(char* a)
  335. {
  336. 		int i = 0;
  337. 		UART3SendByte('#');//起始符
  338. 		while(a[i] != '$')
  339. 		{
  340. 				UART3SendByte(a[i]);
  341. 				i++;
  342. 		}
  343. 		UART3SendByte('$');//结束符
  344. 		UART3SendByte('\r');
  345. 		UART3SendByte('\n');
  346. 		
  347. }
  348.  
  349.  
  350. void lora_receive(void)
  351. {
  352. 	unsigned char i = 0;
  353. 	extern unsigned char lora_rx_data[100];
  354. //		extern char lora_rx_data[9];
  355. 	int t1 = 0,t2 = 0;
  356. 	while(1)
  357. 	{
  358. 			UART3GetByte(&i);
  359. 			if(i=='#')
  360. 			{
  361. 				while(1)
  362. 				{
  363. 					if(UART3GetByte(&i) == 1 && i!='$')
  364. 					{
  365. 						lora_rx_data[t1++]=i;
  366. 					}
  367. 					else if(i=='$')
  368. 						break;	 
  369. 				}
  370. 				while(1)
  371. 				{
  372. 						UART1SendByte(lora_rx_data[t2++]);
  373. 						if(t1 == t2)
  374. 						{
  375. 							UART1SendByte('\r');
  376. 							UART1SendByte('\n');
  377. 							break;
  378. 						}
  379. 				}
  380. 				break;
  381. 			}
  382. 	}
  383. 				
  384. }
  385.  
  386. void LORA_Init(void)
  387. {
  388. 		MD0_Config(); //初始化MD0 
  389. 		AUX_Config();
  390. //		LED_Config();
  391. 		lora_check();
  392. 		lora_set();   //配置LORA
  393.  
  394.  
  395. }

3. DHC11.C

  1. #include "dh11.h"
  2. #include "delay.h"
  3.       
  4. //复位DHT11
  5. void DHT11_Rst(void)	   
  6. {                 
  7. 	DHT11_IO_OUT(); 	//SET OUTPUT
  8.     DHT11_DQ_OUT=0; 	//拉低DQ
  9.     delay_ms(20);    	//拉低至少18ms
  10.     DHT11_DQ_OUT=1; 	//DQ=1 
  11. 	delay_us(50);     	//主机拉高20~40us
  12. }
  13. //等待DHT11的回应
  14. //返回1:未检测到DHT11的存在
  15. //返回0:存在
  16. u8 DHT11_Check(void) 	   
  17. {   
  18. 	u8 retry=0;
  19. 	DHT11_IO_IN();//SET INPUT	 
  20.     while (DHT11_DQ_IN&&retry<100)//DHT11会拉低40~80us
  21. 	{
  22. 		retry++;
  23. 		delay_us(1);
  24. 	};	 
  25. 	if(retry>=100)return 1;
  26. 	else retry=0;
  27.     while (!DHT11_DQ_IN&&retry<100)//DHT11拉低后会再次拉高40~80us
  28. 	{
  29. 		retry++;
  30. 		delay_us(1);
  31. 	};
  32. 	if(retry>=100)return 1;	    
  33. 	return 0;
  34. }
  35. //从DHT11读取一个位
  36. //返回值：1/0
  37. u8 DHT11_Read_Bit(void) 			 
  38. {
  39.  	u8 retry=0;
  40. 	while(DHT11_DQ_IN&&retry<100)//等待变为低电平
  41. 	{
  42. 		retry++;
  43. 		delay_us(1);
  44. 	}
  45. 	retry=0;
  46. 	while(!DHT11_DQ_IN&&retry<100)//等待变高电平
  47. 	{
  48. 		retry++;
  49. 		delay_us(1);
  50. 	}
  51. 	delay_us(40);//等待40us
  52. 	if(DHT11_DQ_IN)return 1;
  53. 	else return 0;		   
  54. }
  55. //从DHT11读取一个字节
  56. //返回值：读到的数据
  57. u8 DHT11_Read_Byte(void)    
  58. {        
  59.     u8 i,dat;
  60.     dat=0;
  61. 	for (i=0;i<8;i++) 
  62. 	{
  63.    		dat<<=1; 
  64. 	    dat|=DHT11_Read_Bit();
  65.     }						    
  66.     return dat;
  67. }
  68. //从DHT11读取一次数据
  69. //temp:温度值(范围:0~50°)
  70. //humi:湿度值(范围:20%~90%)
  71. //返回值：0,正常;1,读取失败
  72. u8 DHT11_Read_Data(u8 *temp,u8 *humi)    
  73. {        
  74.  	u8 buf[5];
  75. 	u8 i;
  76. 	DHT11_Rst();
  77. 	if(DHT11_Check()==0)
  78. 	{
  79. 		for(i=0;i<5;i++)//读取40位数据
  80. 		{
  81. 			buf[i]=DHT11_Read_Byte();
  82. 		}
  83. 		if((buf[0]+buf[1]+buf[2]+buf[3])==buf[4])
  84. 		{
  85. 			*humi=buf[0];
  86. 			*temp=buf[2];
  87. 		}
  88. 	}else return 1;
  89. 	return 0;	    
  90. }
  91. //初始化DHT11的IO口 DQ 同时检测DHT11的存在
  92. //返回1:不存在
  93. //返回0:存在    	 
  94. u8 DHT11_Init(void)
  95. {	 
  96.  
  97. 	DHT11_Rst();  //复位DHT11
  98. 	return DHT11_Check();//等待DHT11的回应
  99. }

4. PWM.C

  1. #include "pwm.h"
  2. //PWM输出初始化
  3. //arr：自动重装值
  4. //psc：时钟预分频数
  5. void TIM3_PWM_Init(u16 arr,u16 psc)
  6. {  
  7. 	 GPIO_InitTypeDef GPIO_InitStructure;
  8. 	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  9. 	TIM_OCInitTypeDef  TIM_OCInitStructure;
  10.  
  11. 	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);// 
  12.  	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);  //使能GPIO外设时钟使能
  13. 	                                                                     	
  14.  
  15.    //设置该引脚为复用输出功能,输出TIM1 CH1的PWM脉冲波形
  16. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; //TIM_CH1
  17. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //复用推挽输出
  18. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  19. 	GPIO_Init(GPIOA, &GPIO_InitStructure);
  20.  
  21. 	
  22. 	TIM_TimeBaseStructure.TIM_Period = 199; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值	 80K
  23. 	TIM_TimeBaseStructure.TIM_Prescaler =7199; //设置用来作为TIMx时钟频率除数的预分频值  
  24. 	TIM_TimeBaseStructure.TIM_ClockDivision = 0; //设置时钟分割:TDTS = Tck_tim
  25. 	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
  26. 	TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
  27.  
  28.  
  29. 	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2; //选择定时器模式:TIM脉冲宽度调制模式2
  30. 	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; //比较输出使能
  31. 	TIM_OCInitStructure.TIM_Pulse = 0; //设置待装入捕获比较寄存器的脉冲值
  32. 	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High; //输出极性:TIM输出比较极性高
  33. 	TIM_OC1Init(TIM3, &TIM_OCInitStructure);  //根据TIM_OCInitStruct中指定的参数初始化外设TIMx
  34.  
  35.   TIM_CtrlPWMOutputs(TIM3,ENABLE);	//MOE 主输出使能	
  36.  
  37. 	TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);  //CH1预装载使能	 
  38. 	
  39. 	TIM_ARRPreloadConfig(TIM3, ENABLE); //使能TIMx在ARR上的预装载寄存器
  40. 	
  41. 	TIM_Cmd(TIM3, ENABLE);  //使能TIM1
  42.  
  43.    
  44. }

5.ADC.C

  1. #include "adc.h"
  2. void Adc_Init(void)
  3. {
  4.  
  5.     ADC_InitTypeDef ADC_InitStructure;
  6.     GPIO_InitTypeDef GPIO_InitStructure;
  7.  
  8.    
  9.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA, ENABLE);
  10.  
  11.     RCC_ADCCLKConfig(RCC_PCLK2_Div6);//12MHZ 
  12.     
  13.   
  14.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
  15.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  16.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  17.     
  18.   ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  19.   ADC_InitStructure.ADC_ScanConvMode = DISABLE;
  20.   ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
  21.   ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
  22.   ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  23.   ADC_InitStructure.ADC_NbrOfChannel = 1;
  24.   ADC_Init(ADC1, &ADC_InitStructure);
  25.     
  26.  
  27.   ADC_Cmd(ADC1, ENABLE);
  28.  
  29.  
  30.   ADC_ResetCalibration(ADC1);
  31.  
  32.   while(ADC_GetResetCalibrationStatus(ADC1));
  33.  
  34.  
  35.   ADC_StartCalibration(ADC1);
  36.  
  37.   while(ADC_GetCalibrationStatus(ADC1));
  38. }
  39.  
  40. u16 Get_val(u8 ch)
  41. {
  42.     u16 DataValue; 
  43.  
  44.   ADC_RegularChannelConfig(ADC1, ch, 1, ADC_SampleTime_239Cycles5);
  45.     
  46.   
  47.   ADC_SoftwareStartConvCmd(ADC1, ENABLE);
  48.     
  49.  
  50.     while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
  51.     
  52.  DataValue = ADC_GetConversionValue(ADC1); 
  53. return DataValue; 
  54. } 
  55.  
  56. u16 ADC_Get_aveg(u8 ch,u8 n) 
  57. { 
  58. 	u32 ad_sum = 0; 
  59. 	u8 i; 
  60. 	for(i=0;i<n;i++) 
  61. 	{ 
  62. 	ad_sum += Get_val(ch);
  63. 	 delay_ms(5); 
  64. 	} 
  65. 	return (ad_sum / n);
  66.  }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/673083
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号