#include "publicdata/publicdata.h"
#if WH_GM5_EN
#include "plat_comm/4g_module/bs_wh_gm5.h"
#include "app_init/app_init.h"
#include "mylog/mylog.h"
#include "sys_drv_init.h"
#include "plat_comm/impl/bs_connect_impl.h"

S_4G_CTRL_DATA s_4g_ctrl;

S8_T s8_FindAck(U8_T *src, U8_T *des);
S8_T s8_UART3_Send_AT_Cmd(U8_T *sendBuf, U8_T sendLen, U8_T *ack, U8_T resendCnt, U16_T delayTimeMs);

// 对外提供函数
#if 1
/**
* ************************************************************************
* @brief           -状态清空函数
*
* @param[in]

* @param[out]
*
* @author          LQ
* @date            2025-08-28
* ************************************************************************
*/
void v_wh_gm5_data_init(S_4G_CONFIG_PARA *s_4g_para)
{
	//4G模块硬件重启
	RST_4G(0);    
	PWR_4G(0);
	mSleep(NUM_100);
	RST_4G(1);   
	PWR_4G(1);
	mSleep(NUM_100);

	memset(&s_4g_ctrl , 0 ,sizeof(S_4G_CTRL_DATA));

	memcpy(&s_4g_ctrl.s_4g_para ,s_4g_para,sizeof(S_4G_CONFIG_PARA));
}
/**
* ************************************************************************
* @brief           -SIM卡号
*
* @param[in]

* @param[out]
*
* @author          LQ
* @date            2025-08-28
* ************************************************************************
*/
U8_T v_GM5_get_sim(U8_T *data)
{
	U8_T ret = 0;

	if (data == NULL)
		return ret;
	memset(data, 0, 20);
	if (s_4g_ctrl.u8_Sim_Card[0] != 0)
	{
		memcpy(data, s_4g_ctrl.u8_Sim_Card, 20);
		ret = 1;
	}

	return ret;
}

/**
* ************************************************************************
* @brief           -4G模块版本卡号
*
* @param[in]		data 4G模块版本号获取数组 长度固定位20

* @param[out]
*
* @author          LQ
* @date            2025-08-28
* ************************************************************************
*/
U8_T v_GM5_get_4g_version(U8_T *data)
{
	U8_T ret = 0;

	if (data == NULL)
		return ret;
	memset(data, 0, 20);
	if (s_4g_ctrl.u8_4g_Version[0] != 0)
	{
		memcpy(data, s_4g_ctrl.u8_4g_Version, 20);
		ret = 1;
	}

	return ret;
}

/**
 * ************************************************************************
 * @brief           -查询信号强度
 *
 * @param[in]

 * @param[out]     -信号强度(-1-n)
 *
 * @author          LQ
 * @date            2025-08-28
 * ************************************************************************
 */
S8_T s8_UAT_check_signal_quality()
{
	U8_T u8_sendBuf[] = "iesztAT+CSQ\r\n";
	U8_T u8_recvBuf[50] = {0};
	U8_T u8_ack[] = "+CSQ:";
	U8_T ackOK[] = "OK";
	U8_T rcvLen = 0;
	S8_T ackIndex = -1;
	U8_T temp[3] = {0};
	U8_T i, j;

	u16_usart_send(COM_PORT_BS, u8_sendBuf, sizeof(u8_sendBuf));

	mSleep(200);

	memset(u8_recvBuf, 0, 50);

	rcvLen = u16_usart_recv(COM_PORT_BS, u8_recvBuf, 50);
	if (rcvLen > 0)
	{
		if (s8_FindAck(u8_recvBuf, ackOK)) // 收到OK，如果后面有数据，说明数据也接收完全
		{
			ackIndex = s8_FindAck(u8_recvBuf, u8_ack); // 找到期望应答有效数据
			if ((ackIndex >= 0))
			{
				for (i = ackIndex + 6, j = 0; i < rcvLen; i++)
				{
					if (u8_recvBuf[i] != ',')
						temp[j++] = u8_recvBuf[i];
					else
						break;
				}

				return atoi((const char *)temp);
			}
		}
	}

	return -1;
}

/**
 * ************************************************************************
 * @brief           -查询socketA连接状态,回复+SOCKALK:Connected/Disconnected\r\n\r\nOK\r\n
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_check_socket_LinkState(U8_T u8_id)
{
	U8_T u8_sendBuf_A[] = "iesztAT+SOCKALK?\r\n";
	U8_T u8_sendBuf_B[] = "iesztAT+SOCKBLK?\r\n";
	U8_T u8_ack[] = "+SOCKALK:Connected";

	if(u8_id == 0)
		return s8_UART3_Send_AT_Cmd(u8_sendBuf_A, sizeof(u8_sendBuf_A) - 1, u8_ack, 2, 1000);
	else
		return s8_UART3_Send_AT_Cmd(u8_sendBuf_B, sizeof(u8_sendBuf_B) - 1, u8_ack, 2, 1000);
}

/**
 * ************************************************************************
 * @brief           -通过串口AT指令查询网络连接状态
 *
 * @param[in]

 * @param[out]     -0未连接，1连接
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
U8_T u8_UAT_CheckConnState()
{
	U8_T u8_sendBuf[] = "iesztAT+SOCKALK?\r\n";
	U8_T u8_ack[] = "+SOCKALK:Connected";
	S8_T s8_ret = -1;

	s8_ret = s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, u8_ack, 2, 2000);
	if (s8_ret == -1)
		return 0;
	else
		return 1;
}
/**
 * ************************************************************************
 * @brief           - 4G 模块串口缓存清空  
 * 
 * 
 * 
 * @author          jiankalka 
 * @date            2025-12-20
 * ************************************************************************
 */
void v_4g_uart_cache_clear(void)
{
	U8_T rcvLen = 0;
	U8_T u8_recvBuf[200] = {0};

	rcvLen = u16_usart_recv(COM_PORT_BS, u8_recvBuf, 200);

	if (rcvLen > 0) {
		printf("4G uart cache discard, len=%u\r\n", (unsigned)rcvLen);
	}
}
#endif

/**
 * 1.AT+WKMOD 查询/设置工作模式，默认NET网络数据透传/AT指令
 * 2.AT+SOCKA 查询/设置socketA参数
 * 3.AT+SOCKAEN 查询/设置是否使能socketA
 * 4.AT+SOCKALK 查询socketA 连接状态
 *
 * 从网络透传切换至指令模式的时序：
 * 1.串口设备给模块连续发送“+++”，模块回复“a”                   串口——+++——>模块
 * 2.在发送“+++”之前的一个串口打包间隔时间内不可发送任何数据      串口<——a——模块
 * 3.当设备接收‘a’后，必须3秒内给模块发送一个‘a’                串口——a——>模块
 * 4.模块在接收到a之后，给设备发送“+ok”，并进入临时指令模式       串口<——+ok——模块
 * 5.设备接收到“+ok”后，知道模块已进入临时指令模式，可以向其发送AT指令
 */

/****************UART3发送等回复****************/
/**
 * ************************************************************************
 * @brief           -在接收缓存中，查找是否收到期望应答
 *
 * @param[in]      src	-缓存数据
 * @param[in]      des	-目标值
 * @param[out]     s8_findResult  - 目标值下标
 *
 * @author          LQ
 * @date            2025-08-22
 * ************************************************************************
 */
S8_T s8_FindAck(U8_T *src, U8_T *des)
{
	S8_T s8_findResult = -1; // 查询结果
	char *p_strstr = NULL;

	p_strstr = strstr((const char *)src, (const char *)des);
	if (p_strstr != NULL)
	{
		s8_findResult = p_strstr - (char *)src; // des所在下标
	}

	return s8_findResult;
}

/**
 * ************************************************************************
 * @brief           -AT指令设置命令
 *
 * @param[in]      sendbuf	-发送数据指针
 * @param[in]      sendLen	-发送数据长度
 * @param[in]      ack	-期望应答有效数据
 * @param[in]      resendCnt	-重发次数计数
 * @param[in]      delayTimeMs	-延时时间
 * @param[out]     ackIndex  - 期望应答有效数据
 *
 * @author          LQ
 * @date            2025-08-22
 * ************************************************************************
 */
S8_T s8_UART3_Send_AT_Cmd(U8_T *sendBuf, U8_T sendLen, U8_T *ack, U8_T resendCnt, U16_T delayTimeMs)
{
	U8_T count = 0;
	U8_T rcvLen = 0;
	S8_T ackIndex = -1;
	U8_T ackOK[] = "OK";
	#define RECV_BUF_SIZE (100)
	U8_T rcvBuf[RECV_BUF_SIZE] = {0};

	// com_write(COM_PORT_BS, sendBuf, sendLen, 0);
	u16_usart_send(COM_PORT_BS, sendBuf, sendLen);
	memset(rcvBuf, 0, RECV_BUF_SIZE);
	do
	{
		mSleep(delayTimeMs);

		if(rcvLen < RECV_BUF_SIZE)        //已接收数据满了 不再接收新数据
		    rcvLen += u16_usart_recv(COM_PORT_BS,&rcvBuf[rcvLen], RECV_BUF_SIZE-rcvLen);

		if (rcvLen > 2)
		{
			if((count != resendCnt) &&											//没有检测到\r\n 最后一次接收也让允许解析
				(rcvBuf[rcvLen - 2] != 0x0d || rcvBuf[rcvLen - 1] != 0x0a))		//确保AT指令最后两位是 \r\n
			{
				continue;
			}
			else if (s8_FindAck(rcvBuf, ackOK)) // 收到OK，如果后面有数据，说明数据也接收完全
			{
				if (ack != NULL)
				{
					ackIndex = s8_FindAck(rcvBuf, ack); // 找到期望应答有效数据
					if ((ackIndex >= 0))
						return ackIndex;
				}
				else
					return 1;
			}
		}
		count++;
	} while (count < resendCnt); // 如果没收到期望应答，重新发送

	return -1;
}

/**
 * ************************************************************************
 * @brief           -工作模式设置
 *
 * @param[in]      sendbuf	-发送数据指针
 * @param[in]      sendLen	-发送数据长度
 * @param[in]      ack	-期望应答有效数据
 * @param[in]      resendCnt	-重发次数计数
 * @param[in]      delayTimeMs	-延时时间
 * @param[out]     ackIndex  - 期望应答有效数据
 *
 * @author          LQ
 * @date            2025-08-22
 * ************************************************************************
 */
S8_T s8_UART3_set_work_mode_cmd(U8_T *sendBuf, U8_T sendLen, U8_T *ack, U8_T resendCnt, U16_T delayTimeMs)
{
	U8_T count = 0;
	U8_T rcvLen = 0;
	S8_T ackIndex = -1;
	U8_T rcvBuf[100] = {0};

	do
	{
		memset(rcvBuf, 0, 100);
		u16_usart_send(COM_PORT_BS, sendBuf, sendLen);
		mSleep(delayTimeMs);
		rcvLen = u16_usart_recv(COM_PORT_BS, rcvBuf, 100);
		if (rcvLen > 0)
		{
			ackIndex = s8_FindAck(rcvBuf, ack); // 找到期望应答有效数据
			if ((ackIndex >= 0))
				return ackIndex;
		}
		count++;
	} while (count < resendCnt); // 如果没收到期望应答，重新发送
	return -1;
}

/****************通用指令****************/
/**
 * ************************************************************************
 * @brief           -保存当前设置并重启,回复OK
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_save_restart()
{
	U8_T u8_sendBuf[] = "AT+S\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -设置工作模式 - 默认网络透传模式net
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_word_mode()
{
	U8_T u8_sendBuf[] = "AT+WKMOD=NET\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -查询4g版本号
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_query_version(U8_T *data)
{
	U8_T u8_sendBuf[] = "AT+VER?\r\n";
	U8_T u8_recvBuf[50] = {0};
	U8_T u8_ack[] = "+VER:";
	U8_T ackOK[] = "OK";
	U8_T rcvLen = 0;
	S8_T ackIndex = -1;
	U8_T u8_ret = 0;

	if (data == NULL)
		return u8_ret;

	mSleep(NUM_30);

	u16_usart_send(COM_PORT_BS, u8_sendBuf, sizeof(u8_sendBuf) - 1);

	mSleep(NUM_200);

	memset(u8_recvBuf, 0, 50);
	rcvLen = u16_usart_recv(COM_PORT_BS, u8_recvBuf, 50);
	if (rcvLen > 0)
	{
		if (s8_FindAck(u8_recvBuf, ackOK) >= 0)
		{
			ackIndex = s8_FindAck(u8_recvBuf, u8_ack);
			if ((ackIndex >= 0))
			{
				u8_ret = 1;
				memset(data, 0, 20);
				strncpy((char *)data, (char *)&u8_recvBuf[ackIndex + 5],20);
			}
		}
	}
	mSleep(NUM_30);

	return u8_ret;
}
// S8_T s8_query_version() 				//查询固件版本号
// {
// 	U8_T u8_sendBuf[] = "AT+VER?\r\n";
// 	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf)-1, NULL, 2, 50);
// }

/****************串口参数指令****************/
/**
 * ************************************************************************
 * @brief           -设置串口参数，默认值即可
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_uart()
{
	U8_T u8_sendBuf[] = "AT+UART=115200,8,1,NONE,NONE\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -设置串口打包时间
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_uart_PackTime()
{
	U8_T u8_sendBuf[] = "AT+UARTFT=20\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}

/****************透传相关指令****************/
/**
 * ************************************************************************
 * @brief           -设置命令密码
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_cmdPw()
{
	U8_T u8_sendBuf[] = "AT+CMDPW=ieszt\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -设置串口AT指令使能 ,ON开启 OFF关闭，回复OK
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_UAT_EN()
{
	U8_T u8_sendBuf[] = "AT+UATEN=ON\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -设置串口缓存使能，打开
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_catch_EN() // 设置串口缓存使能,打开
{
	U8_T u8_sendBuf[] = "AT+CACHEN=ON\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/****************网络参数指令****************/
/**
 * ************************************************************************
 * @brief           -设置APN信息 - 默认CMNET无需设置
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_APN(U8_T u8_apn_type)
{
	if (u8_apn_type == 0) // 公网
	{
		U8_T u8_sendBuf[] = "AT+APN=CMNET,,\r\n"; // 公网默认配置 用户名/密码默认为空
		return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
	}
	else if (u8_apn_type == 1)
	{
		U8_T u8_sendBuf[] = "AT+APN=CMIOTECHARGENET,,0,0\r\n"; // 国网移动卡 用户名/密码默认为空
		return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
	}
	else if (u8_apn_type == 2)
	{
		U8_T u8_sendBuf[] = "AT+APN=SHIEVSP01.SCHJ.NJM2MAPN,,0,0\r\n"; // 国网联通卡 用户名/密码默认为空
		return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
	}
	else if (u8_apn_type == 3)
	{
		U8_T u8_sendBuf[] = "AT+APN=evs.vpdn.sh,,0,0\r\n"; // 国网电信卡 用户名/密码默认为空
		return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
	}

	else
		return 1; // 其余情况默认不设置
}
/**
 * ************************************************************************
 * @brief           -设置串口分发使能
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_sdp_EN()
{
	U8_T u8_sendBuf[] = "AT+SDPEN=ON\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -设置串口分发不使能
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_sdp_OFF() // 设置串口分发bu使能
{
	U8_T u8_sendBuf[] = "AT+SDPEN=OFF\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -设置socketA使能
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_socketA_EN()
{
	U8_T u8_sendBuf[] = "AT+SOCKAEN=ON\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -设置socketB使能
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_socketB_EN()
{
	U8_T u8_sendBuf[] = "AT+SOCKBEN=ON\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -设置socketB不使能
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_socketB_NoEN() // 设置socketB不使能
{
	U8_T u8_sendBuf[] = "AT+SOCKBEN=OFF\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}
/**
 * ************************************************************************
 * @brief           -设置socketA参数
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_socketA_para(U8_T *u8_server_domain) // 设置socketA参数
{
	U8_T u8_sendBuf[50] = {0};
	U8_T u8_len;

	if(u8_server_domain == NULL)
		return 0;

	u8_len = sprintf((char *)(&u8_sendBuf[0]), "AT+SOCKA=TCP,%s\r\n", u8_server_domain);

	return s8_UART3_Send_AT_Cmd(u8_sendBuf, u8_len, NULL, 2, 700);
}
/**
 * ************************************************************************
 * @brief           -设置socketB参数
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_socketB_para(U8_T *u8_server_domain) // 设置socketB参数
{
	U8_T u8_sendBuf[50] = {0};
	U8_T u8_len;

	u8_len = sprintf((char *)(&u8_sendBuf[0]), "AT+SOCKB=TCP,%s\r\n", u8_server_domain);

	return s8_UART3_Send_AT_Cmd(u8_sendBuf, u8_len, NULL, 2, 700);
}

/****************注册包指令******************/
/****************心跳包指令******************/
/**
 * ************************************************************************
 * @brief           -设置心跳包不使能
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_set_heart_off()
{
	U8_T u8_sendBuf[] = "AT+HEARTEN=OFF\r\n";
	return s8_UART3_Send_AT_Cmd(u8_sendBuf, sizeof(u8_sendBuf) - 1, NULL, 2, 500);
}

/****************模式切换到指令模式******************/

/**
 * ************************************************************************
 * @brief           -切换到指令模式
 *
 * @param[in]
 * @param[out]      -
 *
 * @author          LQ
 * @date            2025-08-22
 * ************************************************************************
 */
U8_T u8_work_mode_cmd() // 切换到指令模式
{
	static U8_T u8_step = 0;
	S8_T s8_ret = -1;
	S8_T s8_entm_ret = -1;
	U8_T u8_cmd[] = "+++";
	U8_T u8_cmd_ack[] = "a";

	U8_T u8_ok[] = "+ok";
	U8_T u8_entm[] = "AT+ENTM\r\n";
	switch (u8_step)
	{
	case 0:
	{
		// 串口设备连续发送+++，等待模块回复a
		s8_ret = s8_UART3_set_work_mode_cmd(&u8_cmd[0], sizeof(u8_cmd) - 1, u8_cmd_ack, 3, 2000);//处理发送太快、回复慢问题
		// 如果收不到回复，判断模块在配置状态，退出，重新进入配置状态	//20201228zpc
		if (s8_ret == -1)
		{
			s8_entm_ret = s8_UART3_Send_AT_Cmd(u8_entm, sizeof(u8_entm) - 1, NULL, 2, 500);
			if (s8_entm_ret == -1)
				return 0;

			s8_ret = s8_UART3_set_work_mode_cmd(u8_cmd, sizeof(u8_cmd) - 1, u8_cmd_ack, 3, 500);
			if (s8_ret == -1)
				return 0;
		}

		mSleep(20);
		u8_step = 1;
	}
	case 1:
	{
		// 串口设备发送a，等待模块回复+ok
		s8_ret = s8_UART3_set_work_mode_cmd(u8_cmd_ack, sizeof(u8_cmd_ack) - 1, u8_ok, 3, 500);
		if (s8_ret == -1)
		{
			s8_entm_ret = s8_UART3_Send_AT_Cmd(u8_entm, sizeof(u8_entm) - 1, NULL, 2, 500);
			if (s8_entm_ret == -1)
				u8_step = 0;
			return 0;
		}

		u8_step = 0;
		break;
	}
	default:
		break;
	}

	return 1;
}
/**
 * ************************************************************************
 * @brief           -切换到数据透传模式
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
U8_T u8_work_mode_data()
{
	S8_T s8_ret = -1;
	U8_T u8_entm[] = "AT+ENTM\r\n";

	s8_ret = s8_UART3_Send_AT_Cmd(u8_entm, sizeof(u8_entm) - 1, NULL, 2, 500);
	if (s8_ret == -1)
		return 0;
	else
		return 1;
}
/**
 * ************************************************************************
 * @brief           -查询SIM卡号
 *
 * @param[in]

 * @param[out]
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_check_number(U8_T *data)
{
	U8_T u8_sendBuf[] = "AT+ICCID?\r\n";
	U8_T u8_ack[] = "+ICCID:";
	U8_T u8_recvBuf[100] = {0};
	U8_T rcvLen = 0;
	U8_T ackOK[] = "OK";
	S8_T ackIndex = -1;
	U8_T u8_ret = 0;

	if (data == NULL)
		return u8_ret;
	u16_usart_send(COM_PORT_BS, u8_sendBuf, sizeof(u8_sendBuf) - 1);
	mSleep(NUM_300);
	memset(u8_recvBuf, 0, 100);

	rcvLen = u16_usart_recv(COM_PORT_BS, u8_recvBuf, 100);
	if (rcvLen > 0)
	{
		if (s8_FindAck(u8_recvBuf, ackOK))
		{
			ackIndex = s8_FindAck(u8_recvBuf, u8_ack);
			if ((ackIndex >= 0))
			{
				u8_ret = 1;
				memset(data, 0, 20);
				strncpy((char *)data, (char *)&u8_recvBuf[ackIndex + 7],20);
			}
		}
	}
	return u8_ret;
}

/**
 * ************************************************************************
 * @brief           -WH-GM5模块初始化，设置模式/参数等
 *
 * @param[in]      *s_4g-4g模块配置参数结构体数据

 * @param[out]     -配网流程状态  0配网成功 非0 配网中（1-15配网步骤）  
 *
 * @author          LQ
 * @date            2025-08-26
 * ************************************************************************
 */
S8_T s8_WH_GM5_init(void)
{
	S8_T step ;
	// 备注 -- 默认值正确的，即使设置未收到应答，也进入下一步 lyn20201229
	switch (s_4g_ctrl.e_wh_gm5_init_step)
	{
	case STEP_SWCHTO_CMD_MODE: // 切换到指令模式，模块新版默认串口AT指令使能，以防现场有老模块，仍保持指令模式设置
	{
		if (u8_work_mode_cmd())
		{
			s_4g_ctrl.e_wh_gm5_init_step = STEP_MODE_NET_ON;
			s_4g_ctrl.u8_out_cnt = 0;
		}
		break;
	}
	case STEP_MODE_NET_ON: // 设置工作模式为网络透传模式，工作模式默认NET
	{

		s8_query_version(&s_4g_ctrl.u8_4g_Version[0]); // 测试，查询固件版本号
		s8_check_number(&s_4g_ctrl.u8_Sim_Card[0]);
		if (s8_set_word_mode() >= 0)
			s_4g_ctrl.e_wh_gm5_init_step = STEP_UAT_ON;

		if ((s_4g_ctrl.u8_out_cnt++) > 3)
		{
			s_4g_ctrl.e_wh_gm5_init_step = STEP_UAT_ON;
			s_4g_ctrl.u8_out_cnt = 0;
		}
		break;
	}
	case STEP_UAT_ON: // 使能串口AT指令(默认使能)，串口AT指令需要密码，默认usr.cn， usr.cn#AT+[CMD]
	{
		if (s8_set_UAT_EN() >= 0)
			s_4g_ctrl.e_wh_gm5_init_step = STEP_UAT_SET_PACK_TIME;
		break;
	}
	case STEP_UAT_SET_PACK_TIME: // 打包时间 20ms
	{
		if (s8_set_uart_PackTime() >= 0)
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SET_PWD;
		break;
	}
	case STEP_SET_PWD: // 设置命令密码“ieszt”
	{
		if (s8_set_cmdPw() >= 0)
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SET_APN;
		break;
	}
	case STEP_SET_APN: // 设置APN
	{
		if (s8_set_APN(s_4g_ctrl.s_4g_para.u8_Sim_Type) >= 0)
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SET_SDPEN;
		break;
	}
	case STEP_SET_SDPEN: // 设置套接字分发
	{
		if (s_4g_ctrl.s_4g_para.u8_socketB_en && (s8_set_sdp_EN()  >= 0))		//套接字分发使能
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SCKA_ON;
		else if (s8_set_sdp_OFF() >= 0)						//套接字分发使能 不使能
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SCKA_ON;
		break;
	}
	case STEP_SCKA_ON: // 设置socketA使能,默认ON
	{
		if (s8_set_socketA_EN() >= 0)
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SET_SCKA_PARA;

		if ((s_4g_ctrl.u8_out_cnt++) > 3)
		{
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SET_SCKA_PARA;
			s_4g_ctrl.u8_out_cnt = 0;
		}
		break;
	}
	case STEP_SET_SCKA_PARA: // 设置socketA参数
	{
		if (s8_set_socketA_para(s_4g_ctrl.s_4g_para.socketA_IP) >= 0)
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SCKB_ON;
		break;
	}
	case STEP_SCKB_ON: // 设置socketB使能,默认ON
	{
		if ((s_4g_ctrl.s_4g_para.u8_socketB_en) && (s8_set_socketB_EN() >= 0))
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SET_SCKB_PARA;
		else if ((s_4g_ctrl.s_4g_para.u8_socketB_en != 1) && (s8_set_socketB_NoEN() >= 0))
			s_4g_ctrl.e_wh_gm5_init_step = STEP_HEART_OFF;

		if ((s_4g_ctrl.u8_out_cnt++) > 3)
		{
			s_4g_ctrl.e_wh_gm5_init_step = STEP_HEART_OFF;
			s_4g_ctrl.u8_out_cnt = 0;
		}
		break;
	}
	case STEP_SET_SCKB_PARA: // 设置socketB参数
	{
		if (s8_set_socketB_para(s_4g_ctrl.s_4g_para.socketB_IP) >= 0)
			s_4g_ctrl.e_wh_gm5_init_step = STEP_HEART_OFF;
		break;
	}
	case STEP_HEART_OFF: // 设置心跳包不使能
	{
		if (s8_set_heart_off() >= 0)
			s_4g_ctrl.e_wh_gm5_init_step = STEP_SAVE;
		break;
	}
	case STEP_SAVE: // 保存当前设置并重启
	{
		if (s8_save_restart() >= 0)
		{
			s_4g_ctrl.e_wh_gm5_init_step = STEP_INIT_OK;
			s_4g_ctrl.u8_out_cnt = 0;
			mSleep(500);
		}
		break;
	}
	default:
		break;
	}

	//流程结果输出 
	if (s_4g_ctrl.e_wh_gm5_init_step == STEP_INIT_OK)
		step = 0;
	else
		step = (U8_T)s_4g_ctrl.e_wh_gm5_init_step + 1;

	return step;
}
#endif /* WH_GM5_EN */