• STM32 物联网 4G CAT1 SIMCOM A7680C 源码

    基于状态机编写4G模块驱动函数

    1.  
    2. #include "bsp.h"  
    3. char LTE_TX[512],LTE_RX[512];
    4. int LTE_TX_length,LTE_RX_length;
    5. char U1_TX_data[512],U1_RX_data[512];
    6. char LTE_DATA_buf[512];
    7. char LTE_COM_buf[512];
    8. char LTE_SEND_buf[512];
    9.  
    10. unsigned char U1_TX_flag,U1_RX_flag;
    11. u16 U1_Tx_Counter,U1_Rx_Counter;
    12. char LTE_AT_state;
    13. char LTE_state;
    14. char LTE_SEND0,LTE_SEND1,LTE_SEND2,LTE_SEND3;
    15. char LTE_Connections;														//LTEÁ¬½Ó±êÖ¾    				0£ºÎ´Á¬½Ó  						
    16. char LTE_TEMP_str[32];
    17.  
    18. void UART1_Config(void)
    19. {		
    20. 	GPIO_InitTypeDef GPIO_InitStructure;
    21. 	USART_InitTypeDef USART_InitStructure;
    22. 	NVIC_InitTypeDef   NVIC_InitStructure;
    23. 	DMA_InitTypeDef    DMA_Initstructure;
    24. 	
    25. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOE, ENABLE);
    26. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 , ENABLE);
    27. 	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    28. 	RCC_APB1PeriphClockCmd( RCC_APB1Periph_TIM2 , ENABLE); 	
    29. //4G POWER	
    30. 	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOE, ENABLE);
    31. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;	
    32. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
    33. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
    34. 	GPIO_Init(GPIOE, &GPIO_InitStructure);			
    35. 	GPIO_ResetBits(GPIOE, GPIO_Pin_1);  
    36. //4G_PWRKEY	
    37. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 ;	
    38. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
    39. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
    40. 	GPIO_Init(GPIOE, &GPIO_InitStructure);
    41.   GPIO_SetBits(GPIOE, GPIO_Pin_3);             
    42. //4G_RESET		
    43. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 ;	
    44. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
    45. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
    46. 	GPIO_Init(GPIOB, &GPIO_InitStructure);
    47. 	GPIO_ResetBits(GPIOB, GPIO_Pin_1);    
    48. //4G_RELAY	
    49. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;	
    50. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
    51. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
    52. 	GPIO_Init(GPIOE, &GPIO_InitStructure);
    53.   GPIO_SetBits(GPIOE, GPIO_Pin_8);
    54. 	GPIO_SetBits(GPIOE, GPIO_Pin_9);  
    55. 	
    56. /* USART1 GPIO config */
    57. 	/* Configure USART1 Tx (PA.09) as alternate function push-pull */
    58. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    59. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    60. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    61. 	GPIO_Init(GPIOA, &GPIO_InitStructure);    
    62. 	/* Configure USART1 Rx (PA.10) as input floating */
    63. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    64. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    65. 	GPIO_Init(GPIOA, &GPIO_InitStructure);	
    66.  
    67. 	/* USART1 mode config */
    68. 	USART_InitStructure.USART_BaudRate = 115200;
    69. 	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    70. 	USART_InitStructure.USART_StopBits = USART_StopBits_1;
    71. 	USART_InitStructure.USART_Parity = USART_Parity_No ;
    72. 	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    73. 	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    74. 	USART_Init(USART1, &USART_InitStructure);
    75. 	
    76. 	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;     
    77. 	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;     
    78. 	NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;     
    79. 	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;     
    80. 	NVIC_Init(&NVIC_InitStructure);
    81. 	
    82. 	/*uart1 RX DMAÅäÖÃ*/    
    83. 	DMA_Initstructure.DMA_PeripheralBaseAddr =  (u32)(&USART1->DR);    
    84. 	DMA_Initstructure.DMA_MemoryBaseAddr     = (u32)U1_RX_data;    
    85. 	DMA_Initstructure.DMA_DIR = DMA_DIR_PeripheralSRC;    
    86. 	DMA_Initstructure.DMA_BufferSize = 512;    
    87. 	DMA_Initstructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;    
    88. 	DMA_Initstructure.DMA_MemoryInc =DMA_MemoryInc_Enable;    
    89. 	DMA_Initstructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;    
    90. 	DMA_Initstructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;    
    91. 	DMA_Initstructure.DMA_Mode = DMA_Mode_Normal;    
    92. 	DMA_Initstructure.DMA_Priority = DMA_Priority_High;    
    93. 	DMA_Initstructure.DMA_M2M = DMA_M2M_Disable;    
    94. 	DMA_Init(DMA1_Channel5,&DMA_Initstructure);       //Æô¶¯DMA    
    95. 	DMA_Cmd(DMA1_Channel5,ENABLE);
    96. 	
    97. 	USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);     
    98. 	USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);
    99. 	USART_Cmd(USART1, ENABLE);
    100. }
    101.  
    102. struct                                //×÷Òµ²ÉÑù
    103. {    
    104. 	u16 LTE_Head;           
    105. 	u16 LTE_Tail;
    106. 	u16 LTE_Lenght;
    107. 	char LTE_Buf[4][512];
    108. 	int LTE_Len[4];
    109. }LTE_Ring;
    110.  
    111. void LTE_Ring_Init(void)
    112. {
    113. 	LTE_Ring.LTE_Head=0;           
    114. 	LTE_Ring.LTE_Tail=0;
    115. 	LTE_Ring.LTE_Lenght=0;
    116. 	LTE_Ring.LTE_Len[0]=0;
    117. 	LTE_Ring.LTE_Len[1]=0;	
    118. 	LTE_Ring.LTE_Len[2]=0;	
    119. 	LTE_Ring.LTE_Len[3]=0;		
    120. }
    121. unsigned char LTE_Write_Ring(char *data,unsigned int len)
    122. {	
    123. 	if(LTE_Ring.LTE_Lenght >= 4) 
    124.  {
    125. 	return 0;
    126.  }
    127.  LTE_Ring.LTE_Len[LTE_Ring.LTE_Tail]=len;
    128.  memcpy(LTE_Ring.LTE_Buf[LTE_Ring.LTE_Tail],data,len);
    129.  LTE_Ring.LTE_Tail = (LTE_Ring.LTE_Tail+1)%4;
    130.  LTE_Ring.LTE_Lenght++;
    131.  return 1;
    132. }
    133. unsigned char LTE_Read_Ring(char *Data)
    134. {
    135.  int len;
    136.  if(LTE_Ring.LTE_Lenght == 0)
    137.  {
    138.   return 0;
    139.  }
    140.  len=LTE_Ring.LTE_Len[LTE_Ring.LTE_Head];
    141.  memcpy(Data,LTE_Ring.LTE_Buf[LTE_Ring.LTE_Head],len);
    142.  memset(LTE_Ring.LTE_Buf[LTE_Ring.LTE_Head],0,len);
    143.  LTE_Ring.LTE_Len[LTE_Ring.LTE_Head]=0;
    144.  LTE_Ring.LTE_Head = (LTE_Ring.LTE_Head+1)%4;
    145.  LTE_Ring.LTE_Lenght--;
    146.  return len;
    147. }
    148.  
    149. struct                                //×÷Òµ²ÉÑù
    150. {    
    151. 	u16 LTE_Head;           
    152. 	u16 LTE_Tail;
    153. 	u16 LTE_Lenght;
    154. 	char LTE_Buf[4][512];
    155. 	int LTE_Len[4];
    156. }LTE1_T_Ring;
    157. void LTE1_T_Ring_Init(void)
    158. {
    159. 	LTE1_T_Ring.LTE_Head=0;           
    160. 	LTE1_T_Ring.LTE_Tail=0;
    161. 	LTE1_T_Ring.LTE_Lenght=0;
    162. 	LTE1_T_Ring.LTE_Len[0]=0;
    163. 	LTE1_T_Ring.LTE_Len[1]=0;	
    164. 	LTE1_T_Ring.LTE_Len[2]=0;	
    165. 	LTE1_T_Ring.LTE_Len[3]=0;		
    166. }
    167. unsigned char LTE1_T_Write_Ring(char *data,unsigned int len)
    168. {	
    169. 	if(LTE1_T_Ring.LTE_Lenght >= 4) 
    170.  {
    171. 	return 0;
    172.  }
    173.  LTE1_T_Ring.LTE_Len[LTE1_T_Ring.LTE_Tail]=len;
    174.  memcpy(LTE1_T_Ring.LTE_Buf[LTE1_T_Ring.LTE_Tail],data,len);
    175.  LTE1_T_Ring.LTE_Tail = (LTE1_T_Ring.LTE_Tail+1)%4;
    176.  LTE1_T_Ring.LTE_Lenght++;
    177.  return 1;
    178. }
    179. unsigned char LTE1_T_Read_Ring(char *Data)
    180. {
    181.  int len;
    182.  if(LTE1_T_Ring.LTE_Lenght == 0)
    183.  {
    184.   return 0;
    185.  }
    186.  len=LTE1_T_Ring.LTE_Len[LTE1_T_Ring.LTE_Head];
    187.  memcpy(Data,LTE1_T_Ring.LTE_Buf[LTE1_T_Ring.LTE_Head],len);
    188.  memset(LTE1_T_Ring.LTE_Buf[LTE1_T_Ring.LTE_Head],0,len);
    189.  LTE1_T_Ring.LTE_Len[LTE1_T_Ring.LTE_Head]=0;
    190.  LTE1_T_Ring.LTE_Head = (LTE1_T_Ring.LTE_Head+1)%4;
    191.  LTE1_T_Ring.LTE_Lenght--;
    192.  return len;
    193. }
    194. struct                                //×÷Òµ²ÉÑù
    195. {    
    196. 	u16 LTE_Head;           
    197. 	u16 LTE_Tail;
    198. 	u16 LTE_Lenght;
    199. 	char LTE_Buf[4][512];
    200. 	int LTE_Len[4];
    201. }LTE2_T_Ring;
    202. void LTE2_T_Ring_Init(void)
    203. {
    204. 	LTE2_T_Ring.LTE_Head=0;           
    205. 	LTE2_T_Ring.LTE_Tail=0;
    206. 	LTE2_T_Ring.LTE_Lenght=0;
    207. 	LTE2_T_Ring.LTE_Len[0]=0;
    208. 	LTE2_T_Ring.LTE_Len[1]=0;	
    209. 	LTE2_T_Ring.LTE_Len[2]=0;	
    210. 	LTE2_T_Ring.LTE_Len[3]=0;		
    211. }
    212. unsigned char LTE2_T_Write_Ring(char *data,unsigned int len)
    213. {	
    214. 	if(LTE2_T_Ring.LTE_Lenght >= 4) 
    215.  {
    216. 	return 0;
    217.  }
    218.  LTE2_T_Ring.LTE_Len[LTE2_T_Ring.LTE_Tail]=len;
    219.  memcpy(LTE2_T_Ring.LTE_Buf[LTE2_T_Ring.LTE_Tail],data,len);
    220.  LTE2_T_Ring.LTE_Tail = (LTE2_T_Ring.LTE_Tail+1)%4;
    221.  LTE2_T_Ring.LTE_Lenght++;
    222.  return 1;
    223. }
    224. unsigned char LTE2_T_Read_Ring(char *Data)
    225. {
    226.  int len;
    227.  if(LTE2_T_Ring.LTE_Lenght == 0)
    228.  {
    229.   return 0;
    230.  }
    231.  len=LTE2_T_Ring.LTE_Len[LTE2_T_Ring.LTE_Head];
    232.  memcpy(Data,LTE2_T_Ring.LTE_Buf[LTE2_T_Ring.LTE_Head],len);
    233.  memset(LTE2_T_Ring.LTE_Buf[LTE2_T_Ring.LTE_Head],0,len);
    234.  LTE2_T_Ring.LTE_Len[LTE2_T_Ring.LTE_Head]=0;
    235.  LTE2_T_Ring.LTE_Head = (LTE2_T_Ring.LTE_Head+1)%4;
    236.  LTE2_T_Ring.LTE_Lenght--;
    237.  return len;
    238. }
    239. struct                                //×÷Òµ²ÉÑù
    240. {    
    241. 	u16 LTE_Head;           
    242. 	u16 LTE_Tail;
    243. 	u16 LTE_Lenght;
    244. 	char LTE_Buf[4][512];
    245. 	int LTE_Len[4];
    246. }LTE3_T_Ring;
    247. void LTE3_T_Ring_Init(void)
    248. {
    249. 	LTE3_T_Ring.LTE_Head=0;           
    250. 	LTE3_T_Ring.LTE_Tail=0;
    251. 	LTE3_T_Ring.LTE_Lenght=0;
    252. 	LTE3_T_Ring.LTE_Len[0]=0;
    253. 	LTE3_T_Ring.LTE_Len[1]=0;	
    254. 	LTE3_T_Ring.LTE_Len[2]=0;	
    255. 	LTE3_T_Ring.LTE_Len[3]=0;		
    256. }
    257. unsigned char LTE3_T_Write_Ring(char *data,unsigned int len)
    258. {	
    259. 	if(LTE3_T_Ring.LTE_Lenght >= 4) 
    260.  {
    261. 	return 0;
    262.  }
    263.  LTE3_T_Ring.LTE_Len[LTE3_T_Ring.LTE_Tail]=len;
    264.  memcpy(LTE3_T_Ring.LTE_Buf[LTE3_T_Ring.LTE_Tail],data,len);
    265.  LTE3_T_Ring.LTE_Tail = (LTE3_T_Ring.LTE_Tail+1)%4;
    266.  LTE3_T_Ring.LTE_Lenght++;
    267.  return 1;
    268. }
    269. unsigned char LTE3_T_Read_Ring(char *Data)
    270. {
    271.  int len;
    272.  if(LTE3_T_Ring.LTE_Lenght == 0)
    273.  {
    274.   return 0;
    275.  }
    276.  len=LTE3_T_Ring.LTE_Len[LTE3_T_Ring.LTE_Head];
    277.  memcpy(Data,LTE3_T_Ring.LTE_Buf[LTE3_T_Ring.LTE_Head],len);
    278.  memset(LTE3_T_Ring.LTE_Buf[LTE3_T_Ring.LTE_Head],0,len);
    279.  LTE3_T_Ring.LTE_Len[LTE3_T_Ring.LTE_Head]=0;
    280.  LTE3_T_Ring.LTE_Head = (LTE3_T_Ring.LTE_Head+1)%4;
    281.  LTE3_T_Ring.LTE_Lenght--;
    282.  return len;
    283. }
    284. void USART1_IRQHandler(void)
    285. {
    286. 	unsigned int i,j;
    287.   char *buf;
    288. 	if(USART_GetITStatus(USART1,USART_IT_IDLE) == SET)     
    289. 	{                                                 
    290. 		USART1->SR;        
    291. 		USART1->DR;
    292. 		DMA_Cmd(DMA1_Channel5,DISABLE);                        
    293. 		U1_Rx_Counter = 512 - DMA_GetCurrDataCounter(DMA1_Channel5);        
    294. 		if(buf=strstr(U1_RX_data, "RECV FROM:"))
    295. 		{
    296. 			if(buf=strstr(U1_RX_data, "114.116.6.187:10000"))
    297. 			{
    298. 				if(buf=strstr(U1_RX_data, "+IPD"))
    299. 				{
    300. 					for(i=0;i<512;i++)
    301. 					{
    302. 						if(buf[i]==0x0d)
    303. 						{
    304. 							if((buf[25]==0x70)&&(buf[26]==0x01)&&(buf[29]==0x01))  //+2µÚÒ»¸ö×Ö½Ú
    305. 							{
    306. 								for(j=0;j<30;j++)
    307. 								{
    308. 									LTE_IP[j]=buf[j+32];
    309. 								}
    310. 								LTE_PORT=(buf[62]<<8)+buf[63];
    311. 								for(j=0;j<4;j++)
    312. 								{
    313. 									local_ip[j]=buf[j+64];
    314. 								}
    315. 								for(j=0;j<4;j++)
    316. 								{
    317. 									mask_ip[j]=buf[j+68];
    318. 								}
    319. 								for(j=0;j<4;j++)
    320. 								{
    321. 									gateway_ip[j]=buf[j+72];
    322. 								}
    323. 								for(j=0;j<32;j++)
    324. 								{
    325. 									Lorawan_EUI[j]=buf[j+83];
    326. 								}
    327. 								for(j=0;j<32;j++)
    328. 								{
    329. 									Lorawan_DevAddr[j]=buf[j+115];
    330. 								}
    331. 								LTE_Connections=1;
    332. 							}
    333. 							if((buf[25]==0x70)&&(buf[26]==0x01)&&(buf[29]==0x00))
    334. 							{
    335. 								LTE_Connections=0;
    336. 							}
    337. 							break;
    338. 						}
    339. 					}
    340. 				}				
    341. 			}
    342. 			if(buf=strstr(U1_RX_data, "114.116.6.187:20000"))
    343. 			{
    344. 				if(buf=strstr(U1_RX_data, "+IPD"))
    345. 				{
    346. 					for(i=0;i<512;i++)
    347. 					{
    348. 						if(buf[i]==0x0d)
    349. 						{
    350. 							if(i==5)UART2_T_Write_Ring((buf+7),(buf[4]-0x30));//1×Ö½Ú
    351. 							if(i==6)UART2_T_Write_Ring((buf+8),(((buf[4]-0x30)*10)+(buf[5]-0x30)));//2×Ö½Ú
    352. 							if(i==7)UART2_T_Write_Ring((buf+9),(((buf[4]-0x30)*100)+((buf[5]-0x30)*10)+(buf[6]-0x30)));//3×Ö½Ú
    353. 							if(i==8)UART2_T_Write_Ring((buf+10),(((buf[4]-0x30)*1000)+((buf[5]-0x30)*100)+((buf[6]-0x30)*10)+(buf[7]-0x30)));//4×Ö½Ú
    354. 							break;
    355. 						}
    356. 					}	
    357. 				}
    358. 			}
    359. 			if(buf=strstr(U1_RX_data, "114.116.6.187:30000"))
    360. 			{
    361. 				if(buf=strstr(U1_RX_data, "+IPD"))
    362. 				{
    363. 					for(i=0;i<512;i++)
    364. 					{
    365. 						if(buf[i]==0x0d)
    366. 						{
    367. 							if(i==5)UART3_T_Write_Ring((buf+7),(buf[4]-0x30));//1×Ö½Ú
    368. 							if(i==6)UART3_T_Write_Ring((buf+8),(((buf[4]-0x30)*10)+(buf[5]-0x30)));//2×Ö½Ú
    369. 							if(i==7)UART3_T_Write_Ring((buf+9),(((buf[4]-0x30)*100)+((buf[5]-0x30)*10)+(buf[6]-0x30)));//3×Ö½Ú
    370. 							if(i==8)UART3_T_Write_Ring((buf+10),(((buf[4]-0x30)*1000)+((buf[5]-0x30)*100)+((buf[6]-0x30)*10)+(buf[7]-0x30)));//4×Ö½Ú
    371. 							break;
    372. 						}
    373. 					}	
    374. 				}
    375. 			}
    376. 			if(buf=strstr(U1_RX_data, "114.116.6.187:40000"))
    377. 			{
    378. 				if(buf=strstr(U1_RX_data, "+IPD"))
    379. 				{
    380. 					for(i=0;i<512;i++)
    381. 					{
    382. 						if(buf[i]==0x0d)
    383. 						{
    384. 							if(i==5)UART5_T_Write_Ring((buf+7),(buf[4]-0x30));//1×Ö½Ú
    385. 							if(i==6)UART5_T_Write_Ring((buf+8),(((buf[4]-0x30)*10)+(buf[5]-0x30)));//2×Ö½Ú
    386. 							if(i==7)UART5_T_Write_Ring((buf+9),(((buf[4]-0x30)*100)+((buf[5]-0x30)*10)+(buf[6]-0x30)));//3×Ö½Ú
    387. 							if(i==8)UART5_T_Write_Ring((buf+10),(((buf[4]-0x30)*1000)+((buf[5]-0x30)*100)+((buf[6]-0x30)*10)+(buf[7]-0x30)));//4×Ö½Ú
    388. 							break;
    389. 						}
    390. 					}		
    391. 				}
    392. 			}
    393. 		}
    394. 		else
    395. 		{
    396. 			LTE_Write_Ring(U1_RX_data,U1_Rx_Counter);
    397. 		}
    398. 		DMA1_Channel5->CNDTR = 512;                                    
    399. 		DMA_Cmd(DMA1_Channel5,ENABLE);                       
    400. 	}
    401. }
    402. void U1_SendString(char *buf1)		  
    403. {
    404. 	unsigned int i;
    405. 	unsigned int len;
    406. 	len=strlen(buf1);
    407.  
    408. 	for(i=0;i
    409. 	{
    410. 		while(USART_GetFlagStatus(USART1,USART_FLAG_TC)== RESET);
    411. 		USART_SendData(USART1,buf1[i]);
    412. 	}
    413. }
    414. void USART1_Send(char *buf,unsigned int len)
    415. {
    416. 	unsigned int i;
    417. 	for(i=0;i
    418. 	{
    419. 		while(USART_GetFlagStatus(USART1,USART_FLAG_TC)== RESET);
    420. 		USART_SendData(USART1,buf[i]);
    421. 	}
    422. }
    423. void LED1_OPEN(void)
    424. {
    425. 	GPIO_WriteBit(GPIOE, GPIO_Pin_13, Bit_SET);
    426. }
    427. void LED1_CLOSE(void)
    428. {
    429. 	GPIO_WriteBit(GPIOE, GPIO_Pin_13, Bit_RESET);
    430. }
    431. void LTE_ATTR(int time1,int time2,int time3,char * buf1,char * buf2,char * buf3,char * buf4,char * buf5,char * buf6,char r ,char w)
    432. {
    433.  unsigned int len;
    434. 	
    435. 	switch(LTE_AT_state)
    436. 	{
    437. 		case state_idle:
    438. 			
    439. 			if(LTE_Delay_Timer>time1)
    440. 			{
    441. 				LTE_Delay_Timer=0;
    442. 				LTE_Timeslimite++;
    443. 				len=strlen(buf1);
    444. 				USART1_Send(buf1,len);
    445. 				LTE_AT_state=state_run;
    446. 			}
    447. 			break;
    448. 		case state_run:
    449. 			LED1_OPEN();
    450. 			LTE_Delay_Timer=0;
    451. 			if(LTE_Read_Ring(LTE_DATA_buf)>0)
    452. 			{
    453. 				if((strstr(LTE_DATA_buf, buf2))&&(strlen(buf2)))  //×Ö·û´®±È½Ï²»ÄÜÓÐ00£¬¹Ø±Õ»ØÏÔ±ÜÃâÊý¾ÝÖеÄ00Ó°Ïì±È½Ï
    454. 				{
    455. 					LTE_AT_state=state_right; 
    456. 				}
    457. 				else if((strstr(LTE_DATA_buf, buf3))&&(strlen(buf3)))
    458. 				{
    459. 					LTE_AT_state=state_right; 
    460. 				} 
    461. 				else if((strstr(LTE_DATA_buf, buf4))&&(strlen(buf4)))
    462. 				{
    463. 					LTE_AT_state=state_wrong; 
    464. 				}
    465. 				else if((strstr(LTE_DATA_buf, buf5))&&(strlen(buf5)))
    466. 				{
    467. 					LTE_AT_state=state_wrong; 
    468. 				} 
    469. 				else if((strstr(LTE_DATA_buf, buf6))&&(strlen(buf6)))
    470. 				{
    471. 					LTE_AT_state=state_wrong; 
    472. 				}
    473. 			}
    474. 			if(LTE_Timeslimite>time2)
    475. 			{
    476. 				LTE_AT_state=state_wrong;
    477. 			}
    478. 			if(LTE_overtime>time3)
    479. 			{
    480. 				LTE_AT_state=state_wrong;
    481. 			}
    482. 			break;
    483. 		case state_right:
    484. 			LTE_state=r;
    485. 			LTE_AT_state=state_idle;
    486. 			LTE_Delay_Timer=0;
    487. 			LTE_overtime=0;
    488. 			LTE_Timeslimite=0;
    489. 			LED1_CLOSE();
    490. 			memset(LTE_DATA_buf,0,512);
    491. 			break;
    492. 		case state_wrong:
    493. 			LTE_state=w;
    494. 			LTE_AT_state=state_idle;
    495. 			LTE_Delay_Timer=0;
    496. 			LTE_overtime=0;
    497. 			LTE_Timeslimite=0;
    498. 			LED1_CLOSE();
    499. 			memset(LTE_DATA_buf,0,512);
    500. 			break;
    501. 		default:  
    502. 			break;
    503. 	}
    504. }
    505. void LTE_DATATR(int time1,int time2,int time3,char * buf1,int len,char * buf2,char * buf3,char * buf4,char * buf5,char * buf6,char r ,char w)
    506. {
    507. 	switch(LTE_AT_state)
    508. 	{
    509. 		case state_idle:
    510. 			
    511. 			if(LTE_Delay_Timer>time1)
    512. 			{
    513. 				LTE_Delay_Timer=0;
    514. 				LTE_Timeslimite++;
    515. 				USART1_Send(buf1,len);
    516. 				LTE_AT_state=state_run;
    517. 			}
    518. 			break;
    519. 		case state_run:
    520. 			LED1_OPEN();
    521. 			LTE_Delay_Timer=0;
    522. 			if(LTE_Read_Ring(LTE_DATA_buf)>0)
    523. 			{
    524. 				if((strstr(LTE_DATA_buf, buf2))&&(strlen(buf2)))   //×Ö·û´®±È½Ï²»ÄÜÓÐ00£¬¹Ø±Õ»ØÏÔ±ÜÃâÊý¾ÝÖеÄ00Ó°Ïì±È½Ï
    525. 				{
    526. 					LTE_AT_state=state_right; 
    527. 				}
    528. 				else if((strstr(LTE_DATA_buf, buf3))&&(strlen(buf3)))
    529. 				{
    530. 					LTE_AT_state=state_right; 
    531. 				} 
    532. 				else if((strstr(LTE_DATA_buf, buf4))&&(strlen(buf4)))
    533. 				{
    534. 					LTE_AT_state=state_wrong; 
    535. 				}
    536. 				else if((strstr(LTE_DATA_buf, buf5))&&(strlen(buf5)))
    537. 				{
    538. 					LTE_AT_state=state_wrong; 
    539. 				} 
    540. 				else if((strstr(LTE_DATA_buf, buf6))&&(strlen(buf6)))
    541. 				{
    542. 					LTE_AT_state=state_wrong; 
    543. 				}
    544. 			}
    545. 			if(LTE_Timeslimite>time2)
    546. 			{
    547. 				LTE_AT_state=state_wrong;
    548. 			}
    549. 			if(LTE_overtime>time3)
    550. 			{
    551. 				LTE_AT_state=state_wrong;
    552. 			}
    553. 			break;
    554. 		case state_right:
    555. 			LTE_state=r;
    556. 			LTE_AT_state=state_idle;
    557. 			LTE_Delay_Timer=0;
    558. 			LTE_overtime=0;
    559. 			LTE_Timeslimite=0;
    560. 			LED1_CLOSE();
    561. 			memset(LTE_DATA_buf,0,512);
    562. 			break;
    563. 		case state_wrong:
    564. 			LTE_state=w;
    565. 			LTE_AT_state=state_idle;
    566. 			LTE_Delay_Timer=0;
    567. 			LTE_overtime=0;
    568. 			LTE_Timeslimite=0;
    569. 			LED1_CLOSE();
    570. 			memset(LTE_DATA_buf,0,512);
    571. 			break;
    572. 		default:  
    573. 			break;
    574. 	}
    575. }
    576. void LTE_POWER(void)
    577. {
    578. 	int i,j;
    579. 	GPIO_WriteBit(GPIOE, GPIO_Pin_1, Bit_SET);
    580. 	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
    581. 	GPIO_WriteBit(GPIOE, GPIO_Pin_1, Bit_RESET);
    582. 	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
    583. }
    584. void LTE_KEY(void)
    585. {
    586. 	int i,j;
    587. 	GPIO_WriteBit(GPIOE, GPIO_Pin_3, Bit_RESET);
    588. 	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
    589. 	GPIO_WriteBit(GPIOE, GPIO_Pin_3, Bit_SET);
    590. 	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
    591. }
    592. void LTE_RST(void)
    593. {
    594. 	int i,j;
    595. 	GPIO_WriteBit(GPIOB, GPIO_Pin_1, Bit_RESET);
    596. 	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
    597. 	GPIO_WriteBit(GPIOB, GPIO_Pin_1, Bit_SET);
    598. 	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
    599. }
    600.  
    601. /*********************************************END OF FILE**********************/

    .h文件

    1. #ifndef __BSP_UART1_H
    2. #define	__BSP_UART1_H
    3.  
    4. void UART1_Config(void);
    5. void LTE_Ring_Init(void);
    6. unsigned char LTE_Write_Ring(char *data,unsigned int len);
    7. unsigned char LTE_Read_Ring(char *Data);
    8. void LTE1_T_Ring_Init(void);
    9. unsigned char LTE1_T_Write_Ring(char *data,unsigned int len);
    10. unsigned char LTE1_T_Read_Ring(char *Data);
    11. void LTE2_T_Ring_Init(void);
    12. unsigned char LTE2_T_Write_Ring(char *data,unsigned int len);
    13. unsigned char LTE2_T_Read_Ring(char *Data);
    14. void LTE3_T_Ring_Init(void);
    15. unsigned char LTE3_T_Write_Ring(char *data,unsigned int len);
    16. unsigned char LTE3_T_Read_Ring(char *Data);
    17. void U1_SendString(char *buf1);
    18. void USART1_Send(char *buf,unsigned int len);
    19. void LED1_OPEN(void);
    20. void LED1_CLOSE(void);
    21. void LTE_ATTR(int time1,int time2,int time3,char * buf1,char * buf2,char * buf3,char * buf4,char * buf5,char * buf6,char r ,char w);
    22. void LTE_DATATR(int time1,int time2,int time3,char * buf1,int len,char * buf2,char * buf3,char * buf4,char * buf5,char * buf6,char r ,char w);
    23. void LTE_POWER(void);
    24. void LTE_KEY(void);
    25. void LTE_RST(void);
    26. #endif /* __BSP_UART1_H */

  • 相关阅读:
    java-php-python-ssm学生宿舍管理系统计算机毕业设计
    一体式城市内涝监测站
    湖南中创教育提示你积极维权，保护自身利益
    复盘Linux期末考试【已凉凉】
    Web3 新手攻略：9 个不可或缺的 APP 助力你踏入加密领域
    AD20~PCB板图的后续制作
    爬虫基本原理介绍、实现以及问题解决
    JVM学习笔记
    突破编程_C++_面试（模板编程（3））
    SpringMVC - 详解RESTful
  • 原文地址：https://blog.csdn.net/gd1984812/article/details/132570204