4G-NB/Drivers/BC260_UDP_Client5.c

/**
  ******************************************************************************
  * 版   本       ：V1.0.0
  * 作   者       ：liuyanbin,helomgxiang
  * 版权所有，盗版必究。
  * Copyright(C) All rights reserved
  ******************************************************************************
  *                             历史记录
  *     序号      版本        变更内容          作者              日期
  *      1        V0.0.1      实现数据发送功能      何龙翔          2023/12/10
  *      2        V0.0.2      实现NB数据发送功能      刘艳斌          2024/1/10
  *      3        V0.0.3      整合4g和nb      刘艳斌          2024/1/24
  *
  ******************************************************************************
  */

#include "stm32f10x.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>


#include "UDP_Client5.h"
#include "CoAP.h"

#include "mbedtls_util.h"

#include "cJSON.h"
#include "sys.h"
#include "bc260.h"
#include "pump_dicts.h"
#include "INflash.h"
#include "PumpBusiness.h"
#include "aliyuniot.h"
#if  NBFLAG


// 流程
enum Step{
	STEP_NONE, // 空闲状态，无操作
	STEP_START, // 开始
	STEP_EXIT_SLEEP, // 退出睡眠
	STEP_ENTER_SLEEP, // 进入睡眠
	STEP_WAIT, // 等待
	
	STEP_STATE, // 查询状态
	STEP_OPEN, // 打开
	STEP_OPEN_WAIT_RESULT, // 等待打开结果
	STEP_JUDGE_AUTH_OR_DATA, // 判断认证还是发送
	STEP_JOIN_AUTH_MESSAGE, // 拼接认证报文
	STEP_JOIN_DATA_MESSAGE, // 拼接数据报文
	STEP_QUERY_SLEEP, // 查询休眠
	STEP_SET_SLEEP, // 开启休眠
	STEP_QUERY_QENG_SERVINGCELL, // 查询信号质量
	
	STEP_SET_QISDE_0, // 关闭发送回显
	STEP_SEND, // 发送
	STEP_RECV, // 等待发送结果
	
	STEP_SET_CFUN_0, // 设置最小功能模式
	STEP_WAIT_SET_CFUN_0, // 等待设置最小功能模式
	STEP_SET_CFUN_1, // 设置全功能模式
	STEP_WAIT_SET_CFUN_1, // 等待设置全功能模式结果
	
	STEP_SET_CGREG_2, // 设置ps域允许上报网络注册和位置信息
	STEP_QUERY_CGREG, // 查询网络注册状态
	STEP_DATAFORMAT,//配置发送格式
	
	STEP_CLOSE, // 关闭
	
	STEP_SUCCESS, // 成功
	STEP_FAILURE, // 失败
	STEP_FINISH, // 流程结束
};
// 当前
static enum Step step = STEP_NONE;
// 下一步
static enum Step next_step = STEP_NONE;

// 客户端5
struct COMM_Client_Struct UDP_Client5 = {
	.status = Client_Status_None,
};

// 注册后的参数
extern Coefficient_Data flashdata;

// socket ID
static uint8_t connectID = 1;


// coap报文
static uint8_t coap_message[512]; 
static uint16_t coap_message_length = 0;


// 泵参数
extern struct Pump_Params pump_params;
// 待发送数据的地址和长度
static uint8_t databuff[128];
static uint16_t data_length;

static uint8_t test_flag=0;

extern struct AT_Struct AT;
// 计时相关的变量
uint8_t Client5_time_flag = 0;
uint32_t Client5_timer_ms = 0;
uint32_t Client5_wait_time = 10;
// 信号值
static struct Signal
{
	int RSRP;
	int RSRQ; 
	int RSSI; 
	int SINR;
} signal = {
	.RSRP = 99,
	.RSRQ = 99,
	.RSSI = 99,
	.SINR = 99,
};

void Query_Signal(int * RSRP, int * RSRQ, int * RSSI, int * SINR)
{
	*RSRP = signal.RSRP;
	*RSRQ = signal.RSRQ;
	*RSSI = signal.RSSI;
	*SINR = signal.SINR;
}

// 初始化
void UDP_Client5_Init(void)
{

	aliyuniot_set_device_params(flashdata.productKey,flashdata.deviceName,flashdata.deviceSecret);
	// 设置host
 
}
// 声明函数。步骤跳转
void goto_step(enum Step ns);
// 发送流程
void UDP_Client5_Handle(void);
// 发送数据
void UDP_Client5_Send(struct Pump_Params params,uint8_t test_switch)
{
	test_flag=test_switch;
	if(step == STEP_NONE)
	{
		// 初始化
		UDP_Client5_Init();
		// 正在发送
		UDP_Client5.status = Client_Status_Sending;
		// 流程开始
		goto_step(STEP_START);
	}
}
// 获取状态
enum Client_Status UDP_Client5_Status(void)
{
	if(UDP_Client5.status == Client_Status_None)
	{
		return UDP_Client5.status;
	}
	else if(step == STEP_FINISH)
	{
		return UDP_Client5.status;
	}
	else
	{
		return Client_Status_Sending;
	}
}
// 清除
void UDP_Client5_Clear(void)
{
	// 流程置空
	goto_step(STEP_NONE);
	// 空闲
	UDP_Client5.status = Client_Status_None;
}

// 直接跳转到下一步
static void goto_step(enum Step ns)
{
	// 重置bc260y状态
	bc260y.reset();
	step = ns; 
}

// 先等待再跳转到下一步
static void goto_step_wait(enum Step ns, uint32_t t)
{
	goto_step(STEP_WAIT); // 等待
	Client5_wait_time = t;
	next_step = ns; // 等待之后跳转
}

// 只等待，等待之后返回原来的步骤
static void goto_wait(uint32_t t)
{
	goto_step_wait(step, t);
}

// 失败
static void goto_failure(char * info)
{
	Log_Printf_Debug("STEP: 数据发送失败,%s\r\n", info);
	UDP_Client5.status = Client_Status_Failure;
	strcpy(UDP_Client5.info, info);
	goto_step(STEP_FAILURE);
}

// 成功
static void goto_success(char * info)
{
	Log_Printf_Debug("STEP: 数据发送成功,%s\r\n", info);
	UDP_Client5.status = Client_Status_Success;
	strcpy(UDP_Client5.info, info);
	goto_step(STEP_SUCCESS);
}

// 等待
static void wait(void)
{
	if(Client5_time_flag == 0)
	{
		Client5_timer_ms = 0;
		Client5_time_flag = 1;
	}
	else if(Client5_timer_ms > Client5_wait_time)
	{
		goto_step(next_step); // 进入下一步
		Client5_time_flag = 0;
	}
}

//// 发送数据的逻辑
static enum Result result = Result_None;
static uint8_t cgreg_n; 
static uint8_t cgreg_stat; 
static uint16_t cgreg_lac; 
static uint32_t cgreg_ci;
static uint8_t query_cgreg_times = 0; // 查询网络状态的次数
static uint8_t auth_times = 0; // 认证次数
static uint16_t socket_err = 0;
static uint8_t auth_or_data = 0;
void UDP_Client5_Handle(void)
{
	// 流程
	switch(step)
	{
		case STEP_NONE: // 空闲
			break;
		case STEP_START: // 开始
			query_cgreg_times = 0; // 查询网络状态的次数
			auth_times = 0; // 认证次数
			goto_step(STEP_EXIT_SLEEP);
			break;
		case STEP_EXIT_SLEEP: // 退出休眠
			result = bc260y.exit_sleep();
		    if(result == Result_Success)
			{
				goto_step_wait(STEP_SET_CFUN_1, 5);
			}
			else if(result == Result_Failed)
			{
				goto_step_wait(STEP_SET_CFUN_1, 100);
			}
			break;
		case STEP_SET_CFUN_1: // 设置全功能模式
			result = bc260y.set_cfun(1);
			if(result == Result_Success)
			{
				goto_step(STEP_SET_CGREG_2);
			}
			else if(result == Result_Failed)
			{
				goto_failure("设置全功能模式失败");
			}
			break;
		case STEP_SET_CGREG_2: // 设置ps域
			result = bc260y.set_cgreg(2);
			if(result == Result_Success)
			{
				goto_step(STEP_SET_QISDE_0);
			}
			else if(result == Result_Failed)
			{
				goto_failure("设置ps域失败");
			}
			break;
		case STEP_SET_QISDE_0: // 关闭回显
			result = bc260y.set_qisde(0);
			if(result == Result_Success)
			{
				goto_step(STEP_QUERY_CGREG);
			}
			else if(result == Result_Failed)
			{
				goto_failure("关闭回显失败");
			}
			break;
		case STEP_QUERY_CGREG: // 查询ps域
			result = bc260y.query_cgreg(&cgreg_n, &cgreg_stat, &cgreg_lac, &cgreg_ci);
			if(result == Result_Success)
			{
				if(cgreg_stat == 1)
				{
					// 参数赋值
					pump_params.lac = cgreg_lac;
					pump_params.ci = cgreg_ci;
					// 编码
						// 下一步
					if(test_flag == 0)
					{
						goto_step(STEP_CLOSE);
					}
					else
					{
						goto_step(STEP_QUERY_QENG_SERVINGCELL);
					}
				}
				else if(query_cgreg_times > 10) // 最多查询20次
				{
					goto_failure("查询ps域次数过多");
				}
				else
				{
					goto_wait(400);
					query_cgreg_times++;
				}
			}
			else if(result == Result_Failed)
			{
				goto_failure("查询ps域失败");
			}
			break;
			case STEP_QUERY_QENG_SERVINGCELL: // 查询信号质量
			result = bc260y.qeng_servingcell(&signal.RSRP, &signal.RSRQ, &signal.RSSI, &signal.SINR);
			if(result == Result_Success)
			{
				goto_step(STEP_CLOSE);
			}
			else if(result == Result_Failed)
			{
				goto_failure("查询信号质量失败");
			}
			break;
		case STEP_CLOSE: // 关闭连接
			result = bc260y.close_socket(connectID);
			if(result == Result_Success)
			{
				goto_step(STEP_DATAFORMAT);
			}
			else if(result == Result_Failed)
			{
				goto_failure("关闭连接失败");
			}
			break;
		case STEP_DATAFORMAT:
			result = bc260y.dataformat(1);
			if(result == Result_Success)
			{
			 goto_step(STEP_OPEN);
			}
			else if(result == Result_Failed)
			{
				goto_failure("配置发送格式失败");
			}
		   break;
		case STEP_OPEN: // 打开客户端
			result = bc260y.open_socket(connectID, "UDP",aliyuniot_get_host(), aliyuniot_get_port(), 1, &socket_err);
			if(result == Result_Success)
			{
				if(socket_err == 0)
				{
					goto_step(STEP_JUDGE_AUTH_OR_DATA);
				}
				else
				{
					goto_failure("客户端打开错误");
				}
			}
			else if(result == Result_Failed)
			{
				goto_failure("打开客户端失败");
			}
			break;
		case STEP_JUDGE_AUTH_OR_DATA: // 判断认证还是发送
			auth_or_data = aliyuniot_is_authentication();
			if(auth_or_data == 1) // 已认证
			{
				goto_step(STEP_JOIN_DATA_MESSAGE);
			}
			else
			{
				goto_step(STEP_JOIN_AUTH_MESSAGE);
			}
			break;
		case STEP_JOIN_AUTH_MESSAGE: // 拼接认证报文
			if(auth_times > 0) // 最多重新认证一次
			{
				goto_failure("认证次数过多");
			}
			else 
			{
				aliyuniot_get_auth_message(coap_message, &coap_message_length);
				goto_step(STEP_SEND);
				auth_times++;
			}
			break;
		case STEP_JOIN_DATA_MESSAGE: // 拼接数据报文
			pump_params.lac = cgreg_lac;
			pump_params.ci = cgreg_ci;
			Pump_Params_Refresh();
					// 编码
			business_protocol_encode(pump_params, databuff, &data_length);
			aliyuniot_get_data_message(databuff, data_length, coap_message, &coap_message_length);
			goto_step(STEP_SEND);
			break;
 
		case STEP_SEND: // 发送send
			result = bc260y.send(connectID, coap_message, coap_message_length);
			if(result == Result_Success)
			{
				goto_step(STEP_RECV);
			}
			else if(result == Result_Failed)
			{
				goto_failure("发送send失败");
			}
			break;
		case STEP_RECV: // 等待结果
			result = bc260y.recv_with_time(connectID, coap_message, &coap_message_length, 10000);
			if(result == Result_Success)
			{
				uint8_t res = aliyuniot_recv_data_handle(coap_message, coap_message_length);
				if(res == 0) // 发送失败
				{
					goto_step(STEP_JUDGE_AUTH_OR_DATA); // 重新认证
				}
				else if(res == 1) // 认证成功
				{
					goto_step(STEP_JOIN_DATA_MESSAGE);
				}
				else if(res == 2) // 发送成功
				{
					goto_success("发送成功");
				}
			}
			else if(result == Result_Failed)
			{
				goto_failure("等待结果失败");
			}
			break;
		case STEP_WAIT: // 等待
			wait();
			break;
		case STEP_SUCCESS: // 成功
			goto_step(STEP_SET_SLEEP);
			break;
		case STEP_FAILURE: // 失败
			goto_step(STEP_SET_SLEEP);
			break;
		case STEP_SET_SLEEP: // 设置休眠模式
			result = bc260y.set_sleep(1);
			if(result != Result_None)
			{
			   goto_step(STEP_ENTER_SLEEP);
			}
			break;
		case STEP_ENTER_SLEEP: // 进入睡眠
			//bc260y.enter_sleep();
			goto_step(STEP_FINISH);
			break;
		case STEP_FINISH: // 结束流程
			break;
		default:
			break;
	}
	
}


#endif