通过AT指令配置CAT1 4G模组

最新推荐文章于 2024-05-31 11:24:17 发布
最新推荐文章于 2024-05-31 11:24:17 发布
阅读量713 收藏 1
点赞数 1
分类专栏： 嵌入式软件开发代码库 文章标签： 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianshang52013/article/details/132590750
版权

CAT1是一款网口转串口的模组，支持socket连接。

真正在使用的过程中，需要对其进行配置。【通过AT指令】

因此便在程序中写了一套配置流程，仅供参考。【因为我懒得整理了，拿来记录一下大致思路就可以了】

基本顺序很简单：发送查询->判断接收->配置->查询 如此往复

config.h

#ifndef __CONFIGCAT_H
#define __CONFIGCAT_H

#include "gd32f30x.h"
#include <stdbool.h>

typedef struct {
	bool configdefault;
	//config OK flag
	bool ConfigInitFlag;
	//status flag
	bool ConfigMode;
	//timer count
	uint32_t ConfigDefaultTime;
	//config step control
	uint8_t ConfigDefaultCount;
	//recieve process
	bool configrecieveflag;
	uint32_t RecieveBufferLength;
	uint8_t RecieveBuffer[128];
}Cat1_Config_struct;

typedef struct {
		char *readbuf;
		char *recievebuf;
		char *configbuf;
}Cat1_Config_Data_struct;

bool bconfigcatInit(void);

bool vconfigcatDefaultConfigInit(void);


#endif   //__CONFIGCAT_H

configcat.c

#include "main.h"
#include "../User/BSP/ASHINING/ashining.h"
#include "../User/FUN/config/configcat.h"
#include "../User/FUN/inforeport/inforeport.h"
#include "../User/FUN/config/configfunction.h"

//main.c
extern Authority_union Authority;
//buzzer.c
extern Buzzer_Struct Buzzer;
//DataStorage
extern ControllerFun_union ControllerFun;
//timer.c
extern Timer_struct FlechazoTimer;

extern uint8_t heartpackagebuffer[28];

//config cat1
Cat1_Config_struct Cat1_Config;

//----------------------------------//
const char configCat_1[] = "+++";
const char configCat_2[] = "AT\r\n";
const char configCat_1_r[] = "\r\n+OK\r\n";
const char configCat_exit[] = "AT+EXAT\r\n\r\n";
const char configCat_rebt[] = "AT+REBT\r\n\r\n";
//----------------------------------//
//----------------------------------//
#define CAT1_CONFIG_DATA_STRUCT_GROUP 12

uint8_t configcount;
bool sendorrecieveflag;
Cat1_Config_Data_struct Cat1_Config_Data[CAT1_CONFIG_DATA_STRUCT_GROUP];


#if (USE_BIT_4_CONTROLLER_ID==1)
char socketheartbeat[8][128]={"\r\n+OK=0,\"regist\",1,3,1,FB006000010000CCCC0000000000042307EBA1FE,0\r\n",\
			"\r\n+OK=1,\"regist\",1,3,1,FB006000010000CCCC0000000000042307EBA1FE,0\r\n",\
			"\r\n+OK=2,\"regist\",1,3,1,FB006000010000CCCC0000000000042307EBA1FE,0\r\n",\
			"\r\n+OK=3,\"regist\",1,3,1,FB006000010000CCCC0000000000042307EBA1FE,0\r\n",\
			"AT+SOCK=0,\"regist\",1,3,1,FB006000010000CCCC0000000000042307EBA1FE,0\r\n",\
			"AT+SOCK=1,\"regist\",1,3,1,FB006000010000CCCC0000000000042307EBA1FE,0\r\n",\
			"AT+SOCK=2,\"regist\",1,3,1,FB006000010000CCCC0000000000042307EBA1FE,0\r\n",\
			"AT+SOCK=3,\"regist\",1,3,1,FB006000010000CCCC0000000000042307EBA1FE,0\r\n"};
#else //(USE_BIT_4_CONTROLLER_ID==1)
char socketheartbeat[8][128]={"\r\n+OK=0,\"regist\",1,3,1,FB006000010000CCCCCCCCCCCC000000000000000000000000EBA1FE,0\r\n",\
			"\r\n+OK=1,\"regist\",1,3,1,FB006000010000CCCCCCCCCCCC000000000000000000000000EBA1FE,0\r\n",\
			"\r\n+OK=2,\"regist\",1,3,1,FB006000010000CCCCCCCCCCCC000000000000000000000000EBA1FE,0\r\n",\
			"\r\n+OK=3,\"regist\",1,3,1,FB006000010000CCCCCCCCCCCC000000000000000000000000EBA1FE,0\r\n",\
			"AT+SOCK=0,\"regist\",1,3,1,FB006000010000CCCCCCCCCCCC000000000000000000000000EBA1FE,0\r\n",\
			"AT+SOCK=1,\"regist\",1,3,1,FB006000010000CCCCCCCCCCCC000000000000000000000000EBA1FE,0\r\n",\
			"AT+SOCK=2,\"regist\",1,3,1,FB006000010000CCCCCCCCCCCC000000000000000000000000EBA1FE,0\r\n",\
			"AT+SOCK=3,\"regist\",1,3,1,FB006000010000CCCCCCCCCCCC000000000000000000000000EBA1FE,0\r\n"};
#endif //(USE_BIT_4_CONTROLLER_ID==1)

char socketheartbeat_f[64];
/***********************************************************
*@fuction	:bconfigcatInit
*@brief		:
*@param		:--
*@return	:void
*@author	:flechazo
*@date		:2023-07-13
***********************************************************/
bool bconfigcatInit(void){
	
	Cat1_Config_Data[0].readbuf = "AT+SOCK=0,\"base\"?\r\n";
	Cat1_Config_Data[0].recievebuf = "\r\n+OK=0,\"base\",1,0,1,0,118.89.116.58,8090\r\n";
	Cat1_Config_Data[0].configbuf = "AT+SOCK=0,\"base\",1,0,1,0,118.89.116.58,8090\r\n";
	
	Cat1_Config_Data[1].readbuf = "AT+SOCK=1,\"base\"?\r\n";
	Cat1_Config_Data[1].recievebuf = "\r\n+OK=1,\"base\",1,0,1,0,139.196.207.98,3866\r\n";
	Cat1_Config_Data[1].configbuf = "AT+SOCK=1,\"base\",1,0,1,0,139.196.207.98,3866\r\n";
	
	Cat1_Config_Data[2].readbuf = "AT+SOCK=2,\"base\"?\r\n";
	Cat1_Config_Data[2].recievebuf = "\r\n+OK=2,\"base\",1,0,1,0,47.103.195.0,6683\r\n";
	Cat1_Config_Data[2].configbuf = "AT+SOCK=2,\"base\",1,0,1,0,47.103.195.0,6683\r\n";
	
	Cat1_Config_Data[3].readbuf = "AT+SOCK=3,\"base\"?\r\n";
	Cat1_Config_Data[3].recievebuf = "\r\n+OK=3,\"base\",1,0,1,0,1w511862l9.goho.co,31697\r\n";
	Cat1_Config_Data[3].configbuf = "AT+SOCK=3,\"base\",1,0,1,0,1w511862l9.goho.co,31697\r\n";
	
	//flush heart package
	//uint2char(heartpackagebuffer,socketheartbeat_f,26);
	uint32_t socketheart_len=2*(5+2*DEVID_LEN+7);
	hex_to_ascii(heartpackagebuffer,socketheartbeat_f,socketheart_len);
	vdatastorageCopyArray((uint8_t *)socketheartbeat_f,((uint8_t *)socketheartbeat[0]+23),socketheart_len);
	vdatastorageCopyArray((uint8_t *)socketheartbeat_f,((uint8_t *)socketheartbeat[1]+23),socketheart_len);
	vdatastorageCopyArray((uint8_t *)socketheartbeat_f,((uint8_t *)socketheartbeat[2]+23),socketheart_len);
	vdatastorageCopyArray((uint8_t *)socketheartbeat_f,((uint8_t *)socketheartbeat[3]+23),socketheart_len);
	vdatastorageCopyArray((uint8_t *)socketheartbeat_f,((uint8_t *)socketheartbeat[4]+25),socketheart_len);
	vdatastorageCopyArray((uint8_t *)socketheartbeat_f,((uint8_t *)socketheartbeat[5]+25),socketheart_len);
	vdatastorageCopyArray((uint8_t *)socketheartbeat_f,((uint8_t *)socketheartbeat[6]+25),socketheart_len);
	vdatastorageCopyArray((uint8_t *)socketheartbeat_f,((uint8_t *)socketheartbeat[7]+25),socketheart_len);
	
	Cat1_Config_Data[4].readbuf = "AT+SOCK=0,\"regist\"?\r\n";
	Cat1_Config_Data[4].recievebuf = socketheartbeat[0];
	Cat1_Config_Data[4].configbuf = socketheartbeat[4];
	
	Cat1_Config_Data[5].readbuf = "AT+SOCK=1,\"regist\"?\r\n";
	Cat1_Config_Data[5].recievebuf = socketheartbeat[1];
	Cat1_Config_Data[5].configbuf = socketheartbeat[5];
	
	Cat1_Config_Data[6].readbuf = "AT+SOCK=2,\"regist\"?\r\n";
	Cat1_Config_Data[6].recievebuf = socketheartbeat[2];
	Cat1_Config_Data[6].configbuf = socketheartbeat[6];
	
	Cat1_Config_Data[7].readbuf = "AT+SOCK=3,\"regist\"?\r\n";
	Cat1_Config_Data[7].recievebuf = socketheartbeat[3];
	Cat1_Config_Data[7].configbuf = socketheartbeat[7];
	
	Cat1_Config_Data[8].readbuf = "AT+SOCK=0,\"keep/alive\"?\r\n";
	Cat1_Config_Data[8].recievebuf = "\r\n+OK=0,\"keep/alive\",0,0,0,KeepAlive,60\r\n";
	Cat1_Config_Data[8].configbuf = "AT+SOCK=0,\"keep/alive\",0,0,0,KeepAlive,60\r\n";
	
	Cat1_Config_Data[9].readbuf = "AT+SOCK=1,\"keep/alive\"?\r\n";
	Cat1_Config_Data[9].recievebuf = "\r\n+OK=1,\"keep/alive\",0,0,0,KeepAlive,60\r\n";
	Cat1_Config_Data[9].configbuf = "AT+SOCK=1,\"keep/alive\",0,0,0,KeepAlive,60\r\n";
	
	Cat1_Config_Data[10].readbuf = "AT+SOCK=2,\"keep/alive\"?\r\n";
	Cat1_Config_Data[10].recievebuf = "\r\n+OK=2,\"keep/alive\",0,0,0,KeepAlive,60\r\n";
	Cat1_Config_Data[10].configbuf = "AT+SOCK=2,\"keep/alive\",0,0,0,KeepAlive,60\r\n";
	
	Cat1_Config_Data[11].readbuf = "AT+SOCK=3,\"keep/alive\"?\r\n";
	Cat1_Config_Data[11].recievebuf = "\r\n+OK=3,\"keep/alive\",0,0,0,KeepAlive,60\r\n";
	Cat1_Config_Data[11].configbuf = "AT+SOCK=3,\"keep/alive\",0,0,0,KeepAlive,60\r\n";
						
	return true;
}



/***********************************************************
*@fuction	:uiconfigcatGetCharPlength
*@brief		:
*@param		:--
*@return	:void
*@author	:flechazo
*@date		:2023-07-13
***********************************************************/

uint32_t uiconfigcatGetCharPlength(char *data){
	static uint32_t len=0;
	for(len=0;len<128;len++){
		if((data[len]==0x0D)&&(data[len+1]==0x0A)&&(data[len+2]==0x00)){
			len+=3;
			return len;
		}
	}
	return 0;
}



/***********************************************************
*@fuction	:varray_move_forward
*@brief		:
*@param		:--
*@return	:void
*@author	:flechazo
*@date		:2023-07-12
***********************************************************/

void varray_move_forward(uint8_t *arr, int length, int movlen)
{
    for(int i = 0; i < (length - movlen); i++)
    {
        arr[i] = arr[i + movlen];
    }
}

/***********************************************************
*@fuction	:uconfigcatfind_recieve_head
*@brief		:
*@param		:--
*@return	:void
*@author	:flechazo
*@date		:2023-07-12
***********************************************************/

uint8_t *uconfigcatfind_recieve_head(uint8_t *data)
{
    for(int i = 0; i < 128; i++)
    {
        if(data[i] == 0x0D)
        {
            //find head
            if(i > 0)
            {
                varray_move_forward(data, 128, i);
            }
            break;
        }
    }
    return data;
}

/***********************************************************
*@fuction	:vconfigcatDefaultConfigInit
*@brief		:
*@param		:--
*@return	:void
*@author	:flechazo
*@date		:2023-07-12
***********************************************************/

bool vconfigcatDefaultConfigInit(void)
{
    //funenable
    if(!ControllerFun.Info.configdefaultcat)
    {
        return false;
    }

    //init flag
    if(Cat1_Config.ConfigInitFlag)
    {
        return true;
    }

    if(FlechazoTimer.Control.IsTimeOut_s(&Cat1_Config.ConfigDefaultTime, 2))
    {
        switch(Cat1_Config.ConfigDefaultCount)
        {
        //start config
        //1、+++
        case 0:
        {
            Cat1_Config.ConfigMode = true;
            vrs485Send((uint8_t *)configCat_1, sizeof(configCat_1)-1);
            vusart0Send((uint8_t *)configCat_1, sizeof(configCat_1)-1);
						configcount=0;
						sendorrecieveflag=false;
            Cat1_Config.ConfigDefaultCount++;
        }
        break;
        //recieve +OK
        case 1:
        {
            if(Cat1_Config.configrecieveflag)
            {
                //check data
                if(vdatastorageCheckArraySame((uint8_t *)configCat_1_r, uconfigcatfind_recieve_head(Cat1_Config.RecieveBuffer), sizeof(configCat_1_r)-1))
                {
                    //same
                    Cat1_Config.ConfigDefaultCount++;
                }
                else
                {
                    //dif
                    //return false;
                    //Cat1_Config.ConfigDefaultCount--;
                    //config

                }
                vrs485Send(Cat1_Config.RecieveBuffer, sizeof(configCat_1_r));
                Cat1_Config.configrecieveflag = false;
            }
            else
            {
                //no recieve
                Cat1_Config.ConfigDefaultCount++;
            }
        }
        break;
        //2、AT\r\n
        case 2:
        {
            vrs485Send((uint8_t *)configCat_2, sizeof(configCat_2)-1);
            vusart0Send((uint8_t *)configCat_2, sizeof(configCat_2)-1);
            Cat1_Config.ConfigDefaultCount++;
        }
        break;
        //recieve +OK
        case 3:
        {
            if(Cat1_Config.configrecieveflag)
            {
                //check data
                if(vdatastorageCheckArraySame((uint8_t *)configCat_1_r, uconfigcatfind_recieve_head(Cat1_Config.RecieveBuffer), sizeof(configCat_1_r)-1))
                {
                    //same init config
	            bconfigcatInit();
		    //limit other send
		    ControllerFun.Info.heartbeat = false;
		    //goto next step
                    Cat1_Config.ConfigDefaultCount++;
                }
                else
                {
                    //dif
                    //return false;
                    //Cat1_Config.ConfigDefaultCount--;
                    //config

                }
                vrs485Send(Cat1_Config.RecieveBuffer, sizeof(configCat_1_r));
                Cat1_Config.configrecieveflag = false;
            }
            else
            {
                //no recieve
                Cat1_Config.ConfigDefaultCount--;
            }
        }
        break;
        //3、config 12 group 
        case 4:
        {
		if(sendorrecieveflag){
		//to check data
		if(Cat1_Config.configrecieveflag){
		//recieve
			if(vdatastorageCheckArraySame((uint8_t *)Cat1_Config_Data[configcount].recievebuf, uconfigcatfind_recieve_head(Cat1_Config.RecieveBuffer), uiconfigcatGetCharPlength(Cat1_Config_Data[configcount].recievebuf)-1)){
				//to next config option
				configcount++;
				if(configcount>=CAT1_CONFIG_DATA_STRUCT_GROUP){
					printf("\r\n----------complete cat1 config----------\r\n");
					//complete config
					configcount=0;
					Cat1_Config.ConfigDefaultCount++;
				}
			}else{
				printf("\r\n----------start config cat1 default %d----------\r\n",configcount);
				//to config 
				vrs485Send((uint8_t *)Cat1_Config_Data[configcount].configbuf, uiconfigcatGetCharPlength(Cat1_Config_Data[configcount].configbuf)-1);
				vusart0Send((uint8_t *)Cat1_Config_Data[configcount].configbuf, uiconfigcatGetCharPlength(Cat1_Config_Data[configcount].configbuf)-1);
				//to read again
				sendorrecieveflag = false;
			}
				printf("\r\n----------read cat1 config flow %d----------\r\n",configcount);
				vrs485Send(uconfigcatfind_recieve_head(Cat1_Config.RecieveBuffer), uiconfigcatGetCharPlength(((char *)Cat1_Config.RecieveBuffer)));
				Cat1_Config.configrecieveflag = false;
			}else{
				//no recieve
				printf("\r\n----------can't read cat1 config %d----------\r\n",configcount);
				sendorrecieveflag=false;
			}
		}else{
			//to send cmd
			printf("\r\n----------start read cat1 config %d----------\r\n",configcount);
			vrs485Send((uint8_t *)Cat1_Config_Data[configcount].readbuf, uiconfigcatGetCharPlength(Cat1_Config_Data[configcount].readbuf)-1);
			vusart0Send((uint8_t *)Cat1_Config_Data[configcount].readbuf, uiconfigcatGetCharPlength(Cat1_Config_Data[configcount].readbuf)-1);
			sendorrecieveflag=true;
		}
        }
        break;
	case 5:
	{
            vrs485Send((uint8_t *)configCat_exit, sizeof(configCat_exit)-1);
            vusart0Send((uint8_t *)configCat_exit, sizeof(configCat_exit)-1);
            Cat1_Config.ConfigDefaultCount++;
	}
	break;
	//exit 
        case 6:
        {
            if(Cat1_Config.configrecieveflag)
            {
                //check data
                if(vdatastorageCheckArraySame((uint8_t *)configCat_1_r, uconfigcatfind_recieve_head(Cat1_Config.RecieveBuffer), sizeof(configCat_1_r)-1))
                {
                    //same
                    Cat1_Config.ConfigDefaultCount++;
                }
                else
                {
                    //dif
                    //return false;
                    Cat1_Config.ConfigDefaultCount--;
                    //config

                }
                vrs485Send(Cat1_Config.RecieveBuffer, sizeof(configCat_1_r));
                Cat1_Config.configrecieveflag = false;
            }
            else
            {
                //no recieve
                Cat1_Config.ConfigDefaultCount--;
            }
        }
        break;
        case 7:
        {
		//config complete
		Cat1_Config.ConfigInitFlag = true;
		ControllerFun.Info.heartbeat = true;
        }
	break;
        }
        Cat1_Config.ConfigDefaultTime = FlechazoTimer.Control.GetCurrentTime_s();
    }
    return true;
}
FlechazoCLF
关注
专栏目录
广和通 L610 模组（4G Cat.1 通信模组）AT指令测试 TCP/UDP 通信过程
Mculover666的博客（嵌入式）
09-04 1万+
广和通 L610 4G Cat.1 模组 L610系列是广和通LTECat-1系列工业化模组。 L610系列一共有三个版本，全面覆盖亚洲、欧洲以及拉美地区主要运营商网络频段，包含L610-CN/L610-EU/L610-LA（支持Wi-Fi& BT）。 模组包含采用方便贴片的LCC+LGA封装以。与NL668系列PIN兼容，可直接替换。 模组支持FDDLTE/TDD-LTE、GSM制式的远距离通讯模式和支持WIFI、Bluetooth近距离无线传输技术。另外，模组具有丰富的扩展接口，支持UART/
移远 EC200S 模组（4G Cat.1 通信模组）AT指令测试 TCP/UDP 通信过程
热门推荐
Mculover666的博客（嵌入式）
08-29 1万+
移远EC200S 4G Cat.1 模组 EC200S-CN 是移远通信推出的LTE Cat 1 无线通信模块，支持最大下行速率10Mbps 和最大上行速率5Mbps，具有超高的性价比。 同时在封装上兼容移远通信多网络制式LTE Standard EC2x（EC25、EC21、EC20 R2.0、EC20 R2.1）和EC200T/EG25-G/EG21-G 模块以及UMTS/HSPA+ UC20/UC200T 模块，实现了3G 网络与4G 网络之间的无缝切换。 EC200S-CN 还支持标准的Mini
SIMCOM 4G模组AT指令中文版
09-07
SIMCOM 4G模组AT指令中文版
LTE Cat 1 无线通信模块 AT 指令使用
嵌入式攻城狮
12-29 3437
LTE Cat 1 无线通信模块 AT 指令使用
调试4g模块，AT命令的使用
最新发布
weixin_71997855的博客
05-31 2433
在调试4g模块的时候，我们手里的模块其实支持4种上网模式，分别是rmnet,ecm,mbim,rndis。所以你需要确定你要使用哪种上网模式，这时就可以使用AT命令来切换。
【合宙4G Cat.1入门教程】--Cat.1 AT指令连接阿里云收发数据 下
qq_42965739的博客
05-30 4053
通过使用AT指令，快速连接上云服务器进行数据收发，达到给设备联网的效果 1、连接阿里云 以下AT指令若有疑问可参考合宙的Luat 4G模块AT命令手册V4.1.6，这里对AT指令不做细致描述 根据【合宙4G Cat.1入门教程】–Cat.1 AT指令连接阿里云收发数据< 上 > 得到的用户名和密码，分别发送以下AT指令，即可连接到阿里云 ProductKey：a1odIqpc7I7 DeviceName：Air724UG DeviceSecret：wpnqLvOgVHOdEhqJ4koeVU
移远4G模块AT指令说明
03-25
4G模块的AT指令汇总，在开发模块之前先了解AT指令的大体结构和基本功能是非常有必要的，让自己对模块有一个模糊和功能上的概念，在开发过程中会越来越顺利；
合宙4G模组AIR780E的驱动程序
04-10
合宙4G模组AIR780E是一款适用于物联网应用的通信模块，它结合了CAT1（Category 1）的4G网络连接能力和强大的GPS（全球定位系统）及GNSS（全球导航卫星系统）功能。在开发基于此模组的应用时，驱动程序是至关重要的...
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系列模块封装兼容，可以尽可能减少客户研发投入并缩短上市时间。它专为各种高吞吐量无线数
ML302_Cat-1_ML302_4G物联网STM32_
10-04
标题中的“ML302_Cat-1_ML302_4G物联网STM32_”表明我们讨论的主题是关于使用ML302 LTE Cat.1模块在STM32微控制器上实现4G物联网应用的教程或项目。这个主题涵盖了嵌入式系统、物联网(IoT)技术、无线通信和微控制器...
AT指令（中文详解版）(一)
segments的专栏
10-20 5940
一 ． 一 般 命 令 1．AT+CGMI      给出模块厂商的标识。 2．AT+CGMM    获得模块标识。这个命令用来得到支持的频带（GSM 900，DCS 1800    或PCS 1900）。当 模块有多频带时，回应可能是不同频带的结合。 3．AT+CGMR    获得模块的软件版本。 4．AT+CGSN    获得 GSM  模块的 IMEI（国际移动设备标识）序列号。
【合宙4G Cat.1入门教程】--Cat.1 AT指令连接阿里云收发数据 上
qq_42965739的博客
05-30 4510
使用AT指令，快速连接上云服务器进行数据收发，达到给设备联网的效果 1、阿里云创建设备 1.1 阿里云创建产品 登录阿里云，支付宝账号或淘宝账号即可 阿里云物联网平台地址：https://account.aliyun.com/login/login.htm?oauth_callback=https%3A%2F%2Fiot.console.aliyun.com%2Fquick_start 选择设备管理->产品->创建产品 填写相关参数：产品名称自定义，所属品类选择自定义品类，节点
关于有人物联网的Cat1模块串口AT指令控制模块的联网网址
qq_50173542的博客
07-11 449
cat1,stm32,rtt
Cat.1模块使用总结（EC600N）
自由的天空
03-12 1万+
由于Cat.4模块（EC20）功耗大，考虑到NB网络覆盖问题（设备在野外工作场景），因此项目上用选择了Cat.1（EC600N）模块，现在把调试过程总结下，希望能够帮助到大家。EC20使用总结请看：单片机和4G模块通信总结（EC20）。 一、电源 手册说供电电压≥3.4V，峰值电流3A。 二、通信口 UART和IO口都是1.8V，需要做电平准换。 三、开机顺序 我是上电1s后复位，复位低电平600ms，然后100ms后开机，开机等待10s后进行操作。 四、AT指令 采用消息地体原理，具体请看
移远4G模块 EC200x EC600 系列AT命令手册
silent_dusbin的博客
03-24 1万+
本文是译至移远官方文档 xxx_AT_Commands_Manual 目录1.简介1.1.AT命令语法1.2.支持的字符集1.3.能用AT命令接口1.4. 未经请求的结果代码1.5.关闭程序2.一般命令3.串行接口控制命令4.状态控制命令5.SIM相关命令6.网络服务命令7.电话簿命令8.短消息服务命令9.数据包域命令10.硬件相关命令 1.简介 这款芯片的AT命令集是遵循国际标准3GPPTS27.007、3GPPTS27.005以及Quectel开发的专用AT命令的组合。 1.1.AT命令语法 AT命令要
C51：蓝牙/Wifi/4G 无线控制开关
qq_73379310的博客
05-26 2090
3.esp8266无法连接TCP 关闭防火墙，检查端口号有没有建立,检查发送的格式有没有错漏。 发送 AT+CIFSR 查看station的ip是否和你建立的tcp服务器的网段一致 需要和你电脑在同一个wifi下。
使用AT命令操作Modem 3G/4G模块
虎哥LoveDroid
08-14 5671
除了标准的AT命令集，不同厂商可能会引入自定义的AT命令来支持特定的功能。这些自定义的AT命令可以用于设备的特定配置、控制和操作。例如，一个嵌入式设备制造商可能会引入用于控制设备唯一功能的AT命令。
基于LTE Cat.1(4G)云透传模块
gavinpeng的专栏
09-27 2044
基于LTE Cat.1(4G)云透传模块 1. 概述 1.1 简介 ZGST20x 串口透传模块使用了LTE-CAT.1技术，支持4G全网通。配合本公司的数据中转云平台，用户随时随地配置数据传输路径，支持多种网络协议。我们也可以为用户部署私有数据中转平台。模块也支持用户定制，广泛适用于工，农业，商业物网联应用。 1.2 硬件说明 主模块：上海移远 Quectel EC600N 天线：IPEX射频座，支持FPC和吸盘天线 Sim卡座：Nano SIM 7 PIN自弹式卡座 插针供电范围：5
4G拨号上网 之 AT指令学习
qq_54593609的博客
07-16 9166
常用的AT指令
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FlechazoCLF

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值