STM32 物联网 4G CAT1 SIMCOM A7680C 源码

最新推荐文章于 2024-09-06 22:46:06 发布
最新推荐文章于 2024-09-06 22:46:06 发布
阅读量1.9k 收藏 3
点赞数
文章标签： stm32 物联网 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gd1984812/article/details/132570204
版权

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


#include "bsp.h"  
char LTE_TX[512],LTE_RX[512];
int LTE_TX_length,LTE_RX_length;
char U1_TX_data[512],U1_RX_data[512];
char LTE_DATA_buf[512];
char LTE_COM_buf[512];
char LTE_SEND_buf[512];

unsigned char U1_TX_flag,U1_RX_flag;
u16 U1_Tx_Counter,U1_Rx_Counter;
char LTE_AT_state;
char LTE_state;
char LTE_SEND0,LTE_SEND1,LTE_SEND2,LTE_SEND3;
char LTE_Connections;														//LTEÁ¬½Ó±êÖ¾    				0£ºÎ´Á¬½Ó  						
char LTE_TEMP_str[32];

void UART1_Config(void)
{		
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef   NVIC_InitStructure;
	DMA_InitTypeDef    DMA_Initstructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOE, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 , ENABLE);
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
	RCC_APB1PeriphClockCmd( RCC_APB1Periph_TIM2 , ENABLE); 	
//4G POWER	
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOE, ENABLE);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOE, &GPIO_InitStructure);			
	GPIO_ResetBits(GPIOE, GPIO_Pin_1);  
//4G_PWRKEY	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 ;	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOE, &GPIO_InitStructure);
  GPIO_SetBits(GPIOE, GPIO_Pin_3);             
//4G_RESET		
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 ;	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	GPIO_ResetBits(GPIOB, GPIO_Pin_1);    
//4G_RELAY	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOE, &GPIO_InitStructure);
  GPIO_SetBits(GPIOE, GPIO_Pin_8);
	GPIO_SetBits(GPIOE, GPIO_Pin_9);  
	
/* USART1 GPIO config */
	/* Configure USART1 Tx (PA.09) as alternate function push-pull */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);    
	/* Configure USART1 Rx (PA.10) as input floating */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &GPIO_InitStructure);	

	/* USART1 mode config */
	USART_InitStructure.USART_BaudRate = 115200;
	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_Init(USART1, &USART_InitStructure);
	
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;     
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;     
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;     
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;     
	NVIC_Init(&NVIC_InitStructure);
	
	/*uart1 RX DMAÅäÖÃ*/    
	DMA_Initstructure.DMA_PeripheralBaseAddr =  (u32)(&USART1->DR);    
	DMA_Initstructure.DMA_MemoryBaseAddr     = (u32)U1_RX_data;    
	DMA_Initstructure.DMA_DIR = DMA_DIR_PeripheralSRC;    
	DMA_Initstructure.DMA_BufferSize = 512;    
	DMA_Initstructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;    
	DMA_Initstructure.DMA_MemoryInc =DMA_MemoryInc_Enable;    
	DMA_Initstructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;    
	DMA_Initstructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;    
	DMA_Initstructure.DMA_Mode = DMA_Mode_Normal;    
	DMA_Initstructure.DMA_Priority = DMA_Priority_High;    
	DMA_Initstructure.DMA_M2M = DMA_M2M_Disable;    
	DMA_Init(DMA1_Channel5,&DMA_Initstructure);       //Æô¶¯DMA    
	DMA_Cmd(DMA1_Channel5,ENABLE);
	
	USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);     
	USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);
	USART_Cmd(USART1, ENABLE);
}

struct                                //×÷Òµ²ÉÑù
{    
	u16 LTE_Head;           
	u16 LTE_Tail;
	u16 LTE_Lenght;
	char LTE_Buf[4][512];
	int LTE_Len[4];
}LTE_Ring;

void LTE_Ring_Init(void)
{
	LTE_Ring.LTE_Head=0;           
	LTE_Ring.LTE_Tail=0;
	LTE_Ring.LTE_Lenght=0;
	LTE_Ring.LTE_Len[0]=0;
	LTE_Ring.LTE_Len[1]=0;	
	LTE_Ring.LTE_Len[2]=0;	
	LTE_Ring.LTE_Len[3]=0;		
}
unsigned char LTE_Write_Ring(char *data,unsigned int len)
{	
	if(LTE_Ring.LTE_Lenght >= 4) 
 {
	return 0;
 }
 LTE_Ring.LTE_Len[LTE_Ring.LTE_Tail]=len;
 memcpy(LTE_Ring.LTE_Buf[LTE_Ring.LTE_Tail],data,len);
 LTE_Ring.LTE_Tail = (LTE_Ring.LTE_Tail+1)%4;
 LTE_Ring.LTE_Lenght++;
 return 1;
}
unsigned char LTE_Read_Ring(char *Data)
{
 int len;
 if(LTE_Ring.LTE_Lenght == 0)
 {
  return 0;
 }
 len=LTE_Ring.LTE_Len[LTE_Ring.LTE_Head];
 memcpy(Data,LTE_Ring.LTE_Buf[LTE_Ring.LTE_Head],len);
 memset(LTE_Ring.LTE_Buf[LTE_Ring.LTE_Head],0,len);
 LTE_Ring.LTE_Len[LTE_Ring.LTE_Head]=0;
 LTE_Ring.LTE_Head = (LTE_Ring.LTE_Head+1)%4;
 LTE_Ring.LTE_Lenght--;
 return len;
}

struct                                //×÷Òµ²ÉÑù
{    
	u16 LTE_Head;           
	u16 LTE_Tail;
	u16 LTE_Lenght;
	char LTE_Buf[4][512];
	int LTE_Len[4];
}LTE1_T_Ring;
void LTE1_T_Ring_Init(void)
{
	LTE1_T_Ring.LTE_Head=0;           
	LTE1_T_Ring.LTE_Tail=0;
	LTE1_T_Ring.LTE_Lenght=0;
	LTE1_T_Ring.LTE_Len[0]=0;
	LTE1_T_Ring.LTE_Len[1]=0;	
	LTE1_T_Ring.LTE_Len[2]=0;	
	LTE1_T_Ring.LTE_Len[3]=0;		
}
unsigned char LTE1_T_Write_Ring(char *data,unsigned int len)
{	
	if(LTE1_T_Ring.LTE_Lenght >= 4) 
 {
	return 0;
 }
 LTE1_T_Ring.LTE_Len[LTE1_T_Ring.LTE_Tail]=len;
 memcpy(LTE1_T_Ring.LTE_Buf[LTE1_T_Ring.LTE_Tail],data,len);
 LTE1_T_Ring.LTE_Tail = (LTE1_T_Ring.LTE_Tail+1)%4;
 LTE1_T_Ring.LTE_Lenght++;
 return 1;
}
unsigned char LTE1_T_Read_Ring(char *Data)
{
 int len;
 if(LTE1_T_Ring.LTE_Lenght == 0)
 {
  return 0;
 }
 len=LTE1_T_Ring.LTE_Len[LTE1_T_Ring.LTE_Head];
 memcpy(Data,LTE1_T_Ring.LTE_Buf[LTE1_T_Ring.LTE_Head],len);
 memset(LTE1_T_Ring.LTE_Buf[LTE1_T_Ring.LTE_Head],0,len);
 LTE1_T_Ring.LTE_Len[LTE1_T_Ring.LTE_Head]=0;
 LTE1_T_Ring.LTE_Head = (LTE1_T_Ring.LTE_Head+1)%4;
 LTE1_T_Ring.LTE_Lenght--;
 return len;
}
struct                                //×÷Òµ²ÉÑù
{    
	u16 LTE_Head;           
	u16 LTE_Tail;
	u16 LTE_Lenght;
	char LTE_Buf[4][512];
	int LTE_Len[4];
}LTE2_T_Ring;
void LTE2_T_Ring_Init(void)
{
	LTE2_T_Ring.LTE_Head=0;           
	LTE2_T_Ring.LTE_Tail=0;
	LTE2_T_Ring.LTE_Lenght=0;
	LTE2_T_Ring.LTE_Len[0]=0;
	LTE2_T_Ring.LTE_Len[1]=0;	
	LTE2_T_Ring.LTE_Len[2]=0;	
	LTE2_T_Ring.LTE_Len[3]=0;		
}
unsigned char LTE2_T_Write_Ring(char *data,unsigned int len)
{	
	if(LTE2_T_Ring.LTE_Lenght >= 4) 
 {
	return 0;
 }
 LTE2_T_Ring.LTE_Len[LTE2_T_Ring.LTE_Tail]=len;
 memcpy(LTE2_T_Ring.LTE_Buf[LTE2_T_Ring.LTE_Tail],data,len);
 LTE2_T_Ring.LTE_Tail = (LTE2_T_Ring.LTE_Tail+1)%4;
 LTE2_T_Ring.LTE_Lenght++;
 return 1;
}
unsigned char LTE2_T_Read_Ring(char *Data)
{
 int len;
 if(LTE2_T_Ring.LTE_Lenght == 0)
 {
  return 0;
 }
 len=LTE2_T_Ring.LTE_Len[LTE2_T_Ring.LTE_Head];
 memcpy(Data,LTE2_T_Ring.LTE_Buf[LTE2_T_Ring.LTE_Head],len);
 memset(LTE2_T_Ring.LTE_Buf[LTE2_T_Ring.LTE_Head],0,len);
 LTE2_T_Ring.LTE_Len[LTE2_T_Ring.LTE_Head]=0;
 LTE2_T_Ring.LTE_Head = (LTE2_T_Ring.LTE_Head+1)%4;
 LTE2_T_Ring.LTE_Lenght--;
 return len;
}
struct                                //×÷Òµ²ÉÑù
{    
	u16 LTE_Head;           
	u16 LTE_Tail;
	u16 LTE_Lenght;
	char LTE_Buf[4][512];
	int LTE_Len[4];
}LTE3_T_Ring;
void LTE3_T_Ring_Init(void)
{
	LTE3_T_Ring.LTE_Head=0;           
	LTE3_T_Ring.LTE_Tail=0;
	LTE3_T_Ring.LTE_Lenght=0;
	LTE3_T_Ring.LTE_Len[0]=0;
	LTE3_T_Ring.LTE_Len[1]=0;	
	LTE3_T_Ring.LTE_Len[2]=0;	
	LTE3_T_Ring.LTE_Len[3]=0;		
}
unsigned char LTE3_T_Write_Ring(char *data,unsigned int len)
{	
	if(LTE3_T_Ring.LTE_Lenght >= 4) 
 {
	return 0;
 }
 LTE3_T_Ring.LTE_Len[LTE3_T_Ring.LTE_Tail]=len;
 memcpy(LTE3_T_Ring.LTE_Buf[LTE3_T_Ring.LTE_Tail],data,len);
 LTE3_T_Ring.LTE_Tail = (LTE3_T_Ring.LTE_Tail+1)%4;
 LTE3_T_Ring.LTE_Lenght++;
 return 1;
}
unsigned char LTE3_T_Read_Ring(char *Data)
{
 int len;
 if(LTE3_T_Ring.LTE_Lenght == 0)
 {
  return 0;
 }
 len=LTE3_T_Ring.LTE_Len[LTE3_T_Ring.LTE_Head];
 memcpy(Data,LTE3_T_Ring.LTE_Buf[LTE3_T_Ring.LTE_Head],len);
 memset(LTE3_T_Ring.LTE_Buf[LTE3_T_Ring.LTE_Head],0,len);
 LTE3_T_Ring.LTE_Len[LTE3_T_Ring.LTE_Head]=0;
 LTE3_T_Ring.LTE_Head = (LTE3_T_Ring.LTE_Head+1)%4;
 LTE3_T_Ring.LTE_Lenght--;
 return len;
}
void USART1_IRQHandler(void)
{
	unsigned int i,j;
  char *buf;
	if(USART_GetITStatus(USART1,USART_IT_IDLE) == SET)     
	{                                                 
		USART1->SR;        
		USART1->DR;
		DMA_Cmd(DMA1_Channel5,DISABLE);                        
		U1_Rx_Counter = 512 - DMA_GetCurrDataCounter(DMA1_Channel5);        
		if(buf=strstr(U1_RX_data, "RECV FROM:"))
		{
			if(buf=strstr(U1_RX_data, "114.116.6.187:10000"))
			{
				if(buf=strstr(U1_RX_data, "+IPD"))
				{
					for(i=0;i<512;i++)
					{
						if(buf[i]==0x0d)
						{
							if((buf[25]==0x70)&&(buf[26]==0x01)&&(buf[29]==0x01))  //+2µÚÒ»¸ö×Ö½Ú
							{
								for(j=0;j<30;j++)
								{
									LTE_IP[j]=buf[j+32];
								}
								LTE_PORT=(buf[62]<<8)+buf[63];
								for(j=0;j<4;j++)
								{
									local_ip[j]=buf[j+64];
								}
								for(j=0;j<4;j++)
								{
									mask_ip[j]=buf[j+68];
								}
								for(j=0;j<4;j++)
								{
									gateway_ip[j]=buf[j+72];
								}
								for(j=0;j<32;j++)
								{
									Lorawan_EUI[j]=buf[j+83];
								}
								for(j=0;j<32;j++)
								{
									Lorawan_DevAddr[j]=buf[j+115];
								}
								LTE_Connections=1;
							}
							if((buf[25]==0x70)&&(buf[26]==0x01)&&(buf[29]==0x00))
							{
								LTE_Connections=0;
							}
							break;
						}
					}
				}				
			}
			if(buf=strstr(U1_RX_data, "114.116.6.187:20000"))
			{
				if(buf=strstr(U1_RX_data, "+IPD"))
				{
					for(i=0;i<512;i++)
					{
						if(buf[i]==0x0d)
						{
							if(i==5)UART2_T_Write_Ring((buf+7),(buf[4]-0x30));//1×Ö½Ú
							if(i==6)UART2_T_Write_Ring((buf+8),(((buf[4]-0x30)*10)+(buf[5]-0x30)));//2×Ö½Ú
							if(i==7)UART2_T_Write_Ring((buf+9),(((buf[4]-0x30)*100)+((buf[5]-0x30)*10)+(buf[6]-0x30)));//3×Ö½Ú
							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×Ö½Ú
							break;
						}
					}	
				}
			}
			if(buf=strstr(U1_RX_data, "114.116.6.187:30000"))
			{
				if(buf=strstr(U1_RX_data, "+IPD"))
				{
					for(i=0;i<512;i++)
					{
						if(buf[i]==0x0d)
						{
							if(i==5)UART3_T_Write_Ring((buf+7),(buf[4]-0x30));//1×Ö½Ú
							if(i==6)UART3_T_Write_Ring((buf+8),(((buf[4]-0x30)*10)+(buf[5]-0x30)));//2×Ö½Ú
							if(i==7)UART3_T_Write_Ring((buf+9),(((buf[4]-0x30)*100)+((buf[5]-0x30)*10)+(buf[6]-0x30)));//3×Ö½Ú
							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×Ö½Ú
							break;
						}
					}	
				}
			}
			if(buf=strstr(U1_RX_data, "114.116.6.187:40000"))
			{
				if(buf=strstr(U1_RX_data, "+IPD"))
				{
					for(i=0;i<512;i++)
					{
						if(buf[i]==0x0d)
						{
							if(i==5)UART5_T_Write_Ring((buf+7),(buf[4]-0x30));//1×Ö½Ú
							if(i==6)UART5_T_Write_Ring((buf+8),(((buf[4]-0x30)*10)+(buf[5]-0x30)));//2×Ö½Ú
							if(i==7)UART5_T_Write_Ring((buf+9),(((buf[4]-0x30)*100)+((buf[5]-0x30)*10)+(buf[6]-0x30)));//3×Ö½Ú
							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×Ö½Ú
							break;
						}
					}		
				}
			}
		}
		else
		{
			LTE_Write_Ring(U1_RX_data,U1_Rx_Counter);
		}
		DMA1_Channel5->CNDTR = 512;                                    
		DMA_Cmd(DMA1_Channel5,ENABLE);                       
	}
}
void U1_SendString(char *buf1)		  
{
	unsigned int i;
	unsigned int len;
	len=strlen(buf1);

	for(i=0;i<len;i++)
	{
		while(USART_GetFlagStatus(USART1,USART_FLAG_TC)== RESET);
		USART_SendData(USART1,buf1[i]);
	}
}
void USART1_Send(char *buf,unsigned int len)
{
	unsigned int i;
	for(i=0;i<len;i++)
	{
		while(USART_GetFlagStatus(USART1,USART_FLAG_TC)== RESET);
		USART_SendData(USART1,buf[i]);
	}
}
void LED1_OPEN(void)
{
	GPIO_WriteBit(GPIOE, GPIO_Pin_13, Bit_SET);
}
void LED1_CLOSE(void)
{
	GPIO_WriteBit(GPIOE, GPIO_Pin_13, Bit_RESET);
}
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)
{
 unsigned int len;
	
	switch(LTE_AT_state)
	{
		case state_idle:
			
			if(LTE_Delay_Timer>time1)
			{
				LTE_Delay_Timer=0;
				LTE_Timeslimite++;
				len=strlen(buf1);
				USART1_Send(buf1,len);
				LTE_AT_state=state_run;
			}
			break;
		case state_run:
			LED1_OPEN();
			LTE_Delay_Timer=0;
			if(LTE_Read_Ring(LTE_DATA_buf)>0)
			{
				if((strstr(LTE_DATA_buf, buf2))&&(strlen(buf2)))  //×Ö·û´®±È½Ï²»ÄÜÓÐ00£¬¹Ø±Õ»ØÏÔ±ÜÃâÊý¾ÝÖеÄ00Ó°Ïì±È½Ï
				{
					LTE_AT_state=state_right; 
				}
				else if((strstr(LTE_DATA_buf, buf3))&&(strlen(buf3)))
				{
					LTE_AT_state=state_right; 
				} 
				else if((strstr(LTE_DATA_buf, buf4))&&(strlen(buf4)))
				{
					LTE_AT_state=state_wrong; 
				}
				else if((strstr(LTE_DATA_buf, buf5))&&(strlen(buf5)))
				{
					LTE_AT_state=state_wrong; 
				} 
				else if((strstr(LTE_DATA_buf, buf6))&&(strlen(buf6)))
				{
					LTE_AT_state=state_wrong; 
				}
			}
			if(LTE_Timeslimite>time2)
			{
				LTE_AT_state=state_wrong;
			}
			if(LTE_overtime>time3)
			{
				LTE_AT_state=state_wrong;
			}
			break;
		case state_right:
			LTE_state=r;
			LTE_AT_state=state_idle;
			LTE_Delay_Timer=0;
			LTE_overtime=0;
			LTE_Timeslimite=0;
			LED1_CLOSE();
			memset(LTE_DATA_buf,0,512);
			break;
		case state_wrong:
			LTE_state=w;
			LTE_AT_state=state_idle;
			LTE_Delay_Timer=0;
			LTE_overtime=0;
			LTE_Timeslimite=0;
			LED1_CLOSE();
			memset(LTE_DATA_buf,0,512);
			break;
		default:  
			break;
	}
}
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)
{
	switch(LTE_AT_state)
	{
		case state_idle:
			
			if(LTE_Delay_Timer>time1)
			{
				LTE_Delay_Timer=0;
				LTE_Timeslimite++;
				USART1_Send(buf1,len);
				LTE_AT_state=state_run;
			}
			break;
		case state_run:
			LED1_OPEN();
			LTE_Delay_Timer=0;
			if(LTE_Read_Ring(LTE_DATA_buf)>0)
			{
				if((strstr(LTE_DATA_buf, buf2))&&(strlen(buf2)))   //×Ö·û´®±È½Ï²»ÄÜÓÐ00£¬¹Ø±Õ»ØÏÔ±ÜÃâÊý¾ÝÖеÄ00Ó°Ïì±È½Ï
				{
					LTE_AT_state=state_right; 
				}
				else if((strstr(LTE_DATA_buf, buf3))&&(strlen(buf3)))
				{
					LTE_AT_state=state_right; 
				} 
				else if((strstr(LTE_DATA_buf, buf4))&&(strlen(buf4)))
				{
					LTE_AT_state=state_wrong; 
				}
				else if((strstr(LTE_DATA_buf, buf5))&&(strlen(buf5)))
				{
					LTE_AT_state=state_wrong; 
				} 
				else if((strstr(LTE_DATA_buf, buf6))&&(strlen(buf6)))
				{
					LTE_AT_state=state_wrong; 
				}
			}
			if(LTE_Timeslimite>time2)
			{
				LTE_AT_state=state_wrong;
			}
			if(LTE_overtime>time3)
			{
				LTE_AT_state=state_wrong;
			}
			break;
		case state_right:
			LTE_state=r;
			LTE_AT_state=state_idle;
			LTE_Delay_Timer=0;
			LTE_overtime=0;
			LTE_Timeslimite=0;
			LED1_CLOSE();
			memset(LTE_DATA_buf,0,512);
			break;
		case state_wrong:
			LTE_state=w;
			LTE_AT_state=state_idle;
			LTE_Delay_Timer=0;
			LTE_overtime=0;
			LTE_Timeslimite=0;
			LED1_CLOSE();
			memset(LTE_DATA_buf,0,512);
			break;
		default:  
			break;
	}
}
void LTE_POWER(void)
{
	int i,j;
	GPIO_WriteBit(GPIOE, GPIO_Pin_1, Bit_SET);
	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
	GPIO_WriteBit(GPIOE, GPIO_Pin_1, Bit_RESET);
	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
}
void LTE_KEY(void)
{
	int i,j;
	GPIO_WriteBit(GPIOE, GPIO_Pin_3, Bit_RESET);
	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
	GPIO_WriteBit(GPIOE, GPIO_Pin_3, Bit_SET);
	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
}
void LTE_RST(void)
{
	int i,j;
	GPIO_WriteBit(GPIOB, GPIO_Pin_1, Bit_RESET);
	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
	GPIO_WriteBit(GPIOB, GPIO_Pin_1, Bit_SET);
	for(i=0;i<1000;i++)for(j=0;j<1000;j++);
}

/*********************************************END OF FILE**********************/

.h文件

#ifndef __BSP_UART1_H
#define	__BSP_UART1_H

void UART1_Config(void);
void LTE_Ring_Init(void);
unsigned char LTE_Write_Ring(char *data,unsigned int len);
unsigned char LTE_Read_Ring(char *Data);
void LTE1_T_Ring_Init(void);
unsigned char LTE1_T_Write_Ring(char *data,unsigned int len);
unsigned char LTE1_T_Read_Ring(char *Data);
void LTE2_T_Ring_Init(void);
unsigned char LTE2_T_Write_Ring(char *data,unsigned int len);
unsigned char LTE2_T_Read_Ring(char *Data);
void LTE3_T_Ring_Init(void);
unsigned char LTE3_T_Write_Ring(char *data,unsigned int len);
unsigned char LTE3_T_Read_Ring(char *Data);
void U1_SendString(char *buf1);
void USART1_Send(char *buf,unsigned int len);
void LED1_OPEN(void);
void LED1_CLOSE(void);
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);
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);
void LTE_POWER(void);
void LTE_KEY(void);
void LTE_RST(void);
#endif /* __BSP_UART1_H */

gd1984812
关注
SIMCom芯讯通A7680C环境搭建:二次开发初步体验；log过滤；通过dump看更多log解决复位和死机等异常问题
cheng___yi的博客
08-15 296
SIMCom芯讯通A7680C:二次开发初步体验
SIMCom芯讯通A7680C代码:虚拟串口响应流程；UI串口硬件和代码分析；GPIO输出实操；定时器时基
cheng___yi的博客
08-20 91
SIMCom芯讯通A7680C代码:虚拟串口响应流程
STM32F103驱动4G模块EC800M源码
最新发布
gitblog_09815的博客
09-06 488
STM32F103驱动4G模块EC800M源码 项目地址:https://gitcode.com/open-source-toolkit/96273 项目介绍 本项目提供了基于STM32F103微控制器驱动4G模块EC800M的源码。通过该源码，您可以轻松实现STM32F103与EC800M模块之间的通信，从而实现4G网络的连接与数据传输。 功能特点 硬件平台：STM32F103微控制器 通信模...
芯讯通SIMCOM A7680C （4G Cat.1 通信模组）AT指令测试 TCP通信过程
weixin_56565733的博客
04-24 8953
一、A7680C TCP通信 1、文档准备
STM32开发 | 移远4G-Cat.1模组EC200N-CN开发
gd1984812的博客
08-26 3370
透传模式下，相对应的串口（比如 UART 口、USB Modem 口等）会进入独占模式，通过 COM 口接收的数据会直接发送到网络端，从网络接收到的数据会从 COM 口直接输出。文章来源地址https://www.yii666.com/blog/326636.html。文章地址https://www.yii666.com/blog/326636.html。被当成数据发送，实际操作时必须遵循以下步骤：网址:yii666.com<返回 OK 后，访问模式就会切换到缓存模式，如需切换回透传模式，可使用。
A7680C 4G模块AT指令连接MQTT服务器和GET HTTP数据
weixin_55944697的博客
03-22 1121
A7680C 4G模块AT指令连接MQTT服务器
使用stm32F4的usb驱动4G模块
05-05
使用stm32F4的usb驱动4G模块，实现了通过USB虚拟出的串口，通过AT命令控制4G模块
SIMCom芯讯通CAT1模块A7680C（ASR1606、ASR1602）完整资料包
11-10
A7680C是一款基于ASR1606(R2)、ASR1602（R5）平台，面向中国市场的超小、超薄的LTE Cat 1模块，支持LTE-TDD/LTE-FDD无线通信制式。该产品支持最大下行速率10Mbps和最大上行速率5Mbps。 A7680C采用了芯讯通以往经典的...
SIMCOM A7670 模组（4G Cat.1 通信模组）AT指令测试 TCP/UDP 通信过程
Mculover666的博客（嵌入式）
11-18 1万+
SIMCOM A7670C 4G Cat.1 模组 SIMCOM A7670C 是一款支持多频段 LTE-TDD/LTE-FDD/GSM/GPRS/EDGE LTE CAT1 模块。 它可以支持最高 10Mbps 下载速率和 5 Mbps 上传速率。 A7670C具有强大的扩展能力，包括UART，I2C，GPIO等丰富的接口。该模块为客户的应用提供了极大的灵活性和易集成性， A7670C的封装形式是LGA，与SIM7070系列模块封装兼容，可以尽可能减少客户研发投入并缩短上市时间。它专为各种高吞吐量无线数
SIMCom芯讯通CAT1模块A7630C（ASR1606、ASR1602）完整资料包
11-10
A7630C 是一款面向中国市场的，基于最新芯片平台的高性价比的LTE Cat 1模块，支持LTE-TDD/LTE-FDD无线通信制式。该产品支持最大下行速率10Mbps和最大上行速率5Mbps。 A7630C采用了主流尺寸的LGA+LCC封装形式实现了...
SIMCom芯讯通CAT1模块SIM7670X（QCX216平台）完整资料包.zip
11-16
SIM7670X 是一款面向中国市场的，基于最新高通QCX216平台的高性价比的LTE Cat 1模块，支持LTE-TDD/LTE-FDD无线通信制式。该产品支持最大下行速率10Mbps和最大上行速率5Mbps。 SIM7670X采用了主流尺寸的LGA+LCC封装...
4G模块发短信源码
10-14
使用4G模块发短信的实现。4G模块会被识别成多个ttyUSB设备文件，利用其中的一个ttyUSB设备就可以实现发短信功能。具体的代码参考附件。
移远EC20的4G模块驱动程序源码
03-20
移远EC20的4G模块驱动程序源码，包含说明文件，支持USB,GobiNet,CMUX等接口，支持linux，android平台
SIMCOM Sim5218A/Sim5215E WCDMA3G模块驱动
09-16
simcom公司SIM5218和SIM5215模块驱动，WCDMA协议3G模块驱动，每个模块映射出多个设备，包括三个COM口，一个Modem，一个Net口
simcom_wwan.rar_SIM7600E-RU驱动_simcom linux_simcom_wwan_tonet4v_w
07-15
SIM7500_SIM7600 系列 Linux_NDIS驱动_V2.00
A7680C硬件设计手册_V1.00.pdf
05-31
A7680C是一款CAT 1模块兼容SIM800C和SIM868，可以缩短客户开发时间
STM32+3G4G.rar
05-08
在“STM32+3G4G硬件开发案例教程”中，我们将深入探讨如何将STM32与3G/4G通信模块结合，构建具有无线通讯功能的智能硬件系统。 首先，STM32微控制器提供了多种型号，如STM32F103、STM32F407等，它们具有不同的处理...
LTE Cat 1 STM32 4G ML302
gd1984812的博客
06-10 3848
从目前蜂窝物联网发展的态势看，LTE Cat 1承担4G物联网连接主力的时机已经开启。其中，Category 1作为最低版参数配置的用户终端等级，让业界能够低成本地设计“低配版”的4G终端，一般简称Cat 1。因此，发展Cat 1网络及相关产业，对于补齐物联网主要场景需求很有意义。不过，目前NB-IoT产业生态已准备就绪，若Cat 1目前能够发力，则确实是一个较好的机会来推动蜂窝物联网代际迁移。 GSMA未来网络专家曾多次在行业峰会上提醒业界：虽然5G备受关注，但直到2025年，4G依然占据最大份额。对于
嵌入式开发|基于STM32+移远EC200S（Cat.1 4G模组）AT指令实现多路MQTT和TCP同时连接
热门推荐
SunnyBit的博客
03-14 2万+
123
SIMCOM A7670C C语言驱动程序
05-13
首先，需要了解SIMCOM A7670C是一款基于3G网络的通信模块，需要使用串口进行通信。因此，我们需要编写一个C语言的串口驱动程序来控制SIMCOM A7670C模块。 以下是一个简单的串口驱动程序示例： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <fcntl.h> #include <termios.h> #define BAUDRATE B115200 #define MODEMDEVICE "/dev/ttyUSB0" #define _POSIX_SOURCE 1 int open_serial_port() { int fd; struct termios newtio; fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY); if (fd < 0) { perror("open_serial_port: Unable to open serial port"); exit(1); } memset(&newtio, 0, sizeof(newtio)); newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD; newtio.c_iflag = IGNPAR; newtio.c_oflag = 0; newtio.c_lflag = 0; newtio.c_cc[VTIME] = 0; newtio.c_cc[VMIN] = 1; tcflush(fd, TCIFLUSH); tcsetattr(fd, TCSANOW, &newtio); return fd; } void write_serial_port(int fd, char *data) { int len = strlen(data); write(fd, data, len); } void read_serial_port(int fd, char *buffer, int buffer_size) { int bytes_read = read(fd, buffer, buffer_size); buffer[bytes_read] = '\0'; } int main() { int fd = open_serial_port(); char *command = "AT\r\n"; write_serial_port(fd, command); char response[256]; read_serial_port(fd, response, sizeof(response)); printf("Response: %s\n", response); close(fd); return 0; } ``` 这个驱动程序打开了一个串口设备文件，设置了波特率和其他串口参数，然后可以通过write_serial_port函数写入AT指令，通过read_serial_port函数读取SIMCOM A7670C模块的响应。 这只是一个简单的示例，你需要根据具体的需求来修改和完善代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值