标题: stm32驱动NBlot模块程序实例 [打印本页]

---

作者: WitheredLotus    时间: 2018-9-29 21:09
标题: stm32驱动NBlot模块程序实例
NBlot+stm32单片机源程序如下:

1. #include "stm32f10x.h"
   
2. #include "USART.h"
   
3. #include "dht11.h"
   
4. #include "delay.h"
   
5. #include "string.h"
   
6. 
   
7. 
   
8. char error[6]={"ERROR"};
   
9. u8 num1,num2;
   
10. int jieshou(u16 i)
    
11. {
    
12.         u16 t,n=0;
    
13.         while(1)
    
14.         {
    
15.     if(flag)
    
16.                 {               
    
17.                         if((n==0)&&(strstr(USART_RX_BUF,error)!=NULL))
    
18.       {
    
19.                             flag=0;
    
20.                             length=0;
    
21.                             return 1;
    
22.                         }           
    
23.                         for(t=0;t<length;t++)
    
24.                         {
    
25.                                 USART_SendData(USART1, USART_RX_BUF[t]);//向串口1发送数据
    
26.                                 while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
    
27.                         }
    
28.                         flag=0;
    
29.                         length=0;
    
30.                         n++;
    
31.                 }
    
32.                 if(n==i) return 0;
    
33.         }
    
34. }
    
35. void delay(int x)
    
36. {
    
37.         int y,z;
    
38.         for(z=0;z<x;z++)
    
39.           for(y=0;y<7000;y++);
    
40. }
    
41. 
    
42. //extern uint8_t ucTemp1,ucTemp2;
    
43. int main()
    
44. {
    
45.         int h=0;
    
46.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
47.         delay_init();
    
48.         uart_init(115200);         //串口初始化为115200
    
49.         usart2_init(9600);
    
50.         DHT11_Init();
    
51.   delay(6000);
    
52.         USART2_SendData("AT+MIPLCREATE=49,130031F10003F2002304001100000000000000123138332E3233302E34302E34303A35363833000131F30008C000000000,0,49,0\r\n");
    
53.         jieshou(2);
    
54.         USART2_SendData("AT+MIPLADDOBJ=0,3303,1,\"1\",1,0\r\n");
    
55.         jieshou(1);
    
56.         USART2_SendData("AT+MIPLADDOBJ=0,3304,1,\"1\",1,0\r\n");
    
57.         jieshou(1);
    
58.         USART2_SendData("AT+MIPLNOTIFY=0,0,3303,0,5700,4,4,\"29.8\",0,0\r\n");
    
59.         jieshou(1);
    
60.         USART2_SendData("AT+MIPLNOTIFY=0,0,3304,0,5700,4,4,\"29.8\",0,0\r\n");
    
61.         jieshou(1);
    
62.         
    
63.         USART2_SendData("AT+MIPLOPEN=0,3000,30\r\n");
    
64.         while(jieshou(6))
    
65.                 USART2_SendData("AT+MIPLOPEN=0,3000,30\r\n");
    
66.         k=1;        
    
67.         while(1)        
    
68.         {
    
69.                 if(DHT11_Read_Data(&num1,&num2)==0)
    
70.                 {
    
71.         usart2_send1(num1);
    
72.                           usart2_send2(num2);
    
73. 
    
74.                 }
    
75.                 for(h=0;h<5;h++)
    
76.                    delay_ms(1000);
    
77.         }
    
78.         
    
79.         
    
80.         
    
81. }
    

复制代码

1. #include "sys.h"
   
2. #include "usart.h"         
   
3. #include "string.h"
   
4. //////////////////////////////////////////////////////////////////////////////////         
   
5. //如果使用ucos,则包括下面的头文件即可.
   
6. #if SYSTEM_SUPPORT_OS
   
7. #include "includes.h"                                        //ucos 使用         
   
8. #endif
   
9. 
   
10. //加入以下代码,支持printf函数,而不需要选择use MicroLIB         
    
11. #if 1
    
12. #pragma import(__use_no_semihosting)            
    
13. //标准库需要的支持函数                 
    
14. struct __FILE
    
15. {
    
16.         int handle;
    
17. 
    
18. };
    
19. 
    
20. FILE __stdout;      
    
21. //定义_sys_exit()以避免使用半主机模式   
    
22. _sys_exit(int x)
    
23. {
    
24.         x = x;
    
25. }
    
26. //重定义fputc函数
    
27. int fputc(int ch, FILE *f)
    
28. {      
    
29.         while((USART2->SR&0X40)==0);//循环发送,直到发送完毕   
    
30.     USART2->DR = (u8) ch;      
    
31.         return ch;
    
32. }
    
33. #endif
    
34. 
    
35. #if EN_USART1_RX   //如果使能了接收
    
36. //串口1中断服务程序
    
37. //注意,读取USARTx->SR能避免莫名其妙的错误           
    
38. char USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
    
39. 
    
40. u16 USART_RX_STA=0;       //接收状态标记         
    
41. u16 length=0,len;
    
42. u8 flag=0;
    
43. u8 k=0;
    
44. char ok[3]={"OK"};
    
45. void uart_init(u32 bound){
    
46.   //GPIO端口设置
    
47.   GPIO_InitTypeDef GPIO_InitStructure;
    
48.         USART_InitTypeDef USART_InitStructure;
    
49.         NVIC_InitTypeDef NVIC_InitStructure;
    
50.          
    
51.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    
52.   
    
53.         //USART1_TX   GPIOA.9
    
54.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    
55.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
56.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
    
57.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
    
58.    
    
59.   //USART1_RX          GPIOA.10初始化
    
60.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    
61.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    
62.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  
    
63. 
    
64.   //Usart1 NVIC 配置
    
65.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
66.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;//抢占优先级3
    
67.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
    
68.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
    
69.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
    
70.   
    
71.    //USART 初始化设置
    
72. 
    
73.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
    
74.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    
75.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    
76.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    
77.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    
78.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式
    
79. 
    
80.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
    
81.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    
82.         USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);
    
83. 
    
84.   USART_Cmd(USART1, ENABLE);                    //使能串口1
    
85. 
    
86. }
    
87. 
    
88. void usart2_init(u32 bound)
    
89. {
    
90.                 NVIC_InitTypeDef NVIC_InitStructure;
    
91.                 USART_InitTypeDef USART2_InitStructure;
    
92.                 GPIO_InitTypeDef GPIO_InitStructure;
    
93.         
    
94.                 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);//打开串口2时钟
    
95.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//打开GPIOA时钟
    
96.         
    
97. //初始化USART2-TX        
    
98.         
    
99.                 GPIO_InitStructure.GPIO_Pin=GPIO_Pin_2;
    
100.                 GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;
     
101.                 GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
     
102.         
     
103.                 GPIO_Init(GPIOA, &GPIO_InitStructure);
     
104.         
     
105. //初始化USART2-RX               
     
106.         
     
107.                 GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3;
     
108.                 GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
     
109.                 GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
     
110.         
     
111.                 GPIO_Init(GPIOA, &GPIO_InitStructure);
     
112. 
     
113. //USART2中断优先级设置
     
114. 
     
115.         NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
     
116.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;//抢占优先级3
     
117.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;                //子优先级3
     
118.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
     
119.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
     
120. 
     
121. //USART2——初始化设置
     
122. 
     
123.         USART2_InitStructure.USART_BaudRate=bound;
     
124.         USART2_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
     
125.         USART2_InitStructure.USART_Parity=USART_Parity_No;
     
126.         USART2_InitStructure.USART_StopBits=USART_StopBits_1;
     
127.         USART2_InitStructure.USART_WordLength=USART_WordLength_8b;
     
128.         USART2_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
     
129.         
     
130.         USART_Init(USART2, &USART2_InitStructure);
     
131.         
     
132.   USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启接收中断
     
133.         USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);//开启空闲中断
     
134.   USART_Cmd(USART2, ENABLE);                    //使能串口
     
135. 
     
136. while(USART_GetFlagStatus(USART2,USART_FLAG_TC)==RESET);
     
137. 
     
138. }
     
139. 
     
140. 
     
141. void USART2_SendData(char* buf)
     
142. {
     
143.         u8 i;
     
144.         i=strlen((char *)buf);
     
145. 
     
146.         for(;i>0;i--)
     
147.         {
     
148.                 while(USART_GetFlagStatus(USART2,USART_FLAG_TC)==RESET);
     
149.                 USART_SendData(USART2,*buf++);
     
150.         }
     
151. }
     
152. 
     
153. 
     
154. void Usart_SendByte(USART_TypeDef * pUSARTX,uint8_t ch)
     
155. {
     
156.         USART_SendData(pUSARTX,ch);
     
157.         while(USART_GetFlagStatus(pUSARTX,USART_FLAG_TXE)==RESET);   //等待发送寄存器为空
     
158. }
     
159. 
     
160. void Usart_SendString(USART_TypeDef * pUSARTX,char *str)
     
161. {
     
162.         unsigned int k=0;
     
163.         while(*(str+k)!='\0')
     
164.         {
     
165.            Usart_SendByte(pUSARTX,*(str+k));
     
166.                 k++;
     
167.         }
     
168.         while(USART_GetFlagStatus(pUSARTX,USART_FLAG_TC)==RESET);
     
169. }
     
170. 
     
171. void USART2_IRQHandler(void)   
     
172. {
     
173.           u8 Res;
     
174.                 if(USART_GetITStatus(USART2,USART_IT_RXNE)==!RESET)
     
175.                 {
     
176.                
     
177.                         USART_RX_BUF[length++]=USART2->DR;
     
178.                         USART_ClearITPendingBit(USART2,USART_IT_RXNE);
     
179.                
     
180.                 }
     
181.                 if(USART_GetITStatus(USART2,USART_IT_IDLE)!=RESET)
     
182.                 {
     
183.                         Res=Res;
     
184.                         Res=USART2->SR;  //状态寄存器
     
185.                         Res=USART2->DR;
     
186.                         flag=1;               
     
187.                 }
     
188.           if(k!=0)
     
189.                 {
     
190.                         if(flag)
     
191.                         {               
     
192.                                         for(len=0;len<length;len++)
     
193.                                         {
     
194.                                         USART_SendData(USART1, USART_RX_BUF[len]);//向串口1发送数据
     
195.                                         while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
     
196.                                         }
     
197.                                         flag=0;
     
198.                                         length=0;
     
199.                                 
     
200.                         }
     
201.                 }
     
202.         
     
203. }
     
204. 
     
205. void usart2_send1(u8 y)
     
206. {
     
207.           u8 ge,shi;
     
208.     ge=y%10+48;
     
209.           shi=y/10+48;
     
210.                 Usart_SendString(USART2,"\r\nAT+MIPLNOTIFY=0,0,3303,0,5700,4,4,\"");        
     
211.                 Usart_SendByte(USART2,shi);
     
212.           Usart_SendByte(USART2,ge);
     
213.                 Usart_SendString(USART2,"\",0,0\r\n");
     
214. }
     
215. 
     
216. void usart2_send2(u8 y)
     
217. {
     
218.           u8 ge,shi;
     
219.     ge=y%10+48;
     
220.           shi=y/10+48;
     
221.                 Usart_SendString(USART2,"\r\nAT+MIPLNOTIFY=0,0,3304,0,5700,4,4,\"");        
     
222.                 Usart_SendByte(USART2,shi);
     
223.           Usart_SendByte(USART2,ge);
     
224.                 Usart_SendString(USART2,"\",0,0\r\n");
     
225. }
     
226. 
     
227. #endif        
     

复制代码

所有资料51hei提供下载:
NB IOT 串口.rar (371.74 KB, 下载次数: 61)

2018-9-29 23:21 上传

点击文件名下载附件
下载积分: 黑币 -5

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1