Network-Modules/Drivers/Modules/bc260y/Bc260y_Initialize.c

#include "CONFIG.h"
#if  BC260Y

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

#include "PumpBusiness.h"
#include "Log_Module.h"
#include "Regist.h"
#include "UDP_Client.h"
#include "Initialize.h"

#include "bc260y.h"

// 函数声明
static void INITIALIZE_Process(void); // 流程
static void INITIALIZE_SetStatus(enum INITIALIZE_StatusEnum status); // 设置状态
static void INITIALIZE_SetResult(enum INITIALIZE_ResultEnum result); // 设置结果

static void goto_start(void); // 开始
static void goto_success(void); // 成功
static void goto_failure(char * _info); // 失败
static void goto_finish(void); // 结束

// 流程
enum Step{
	STEP_START, // 开始
	STEP_EXIT_SLEEP, // 退出睡眠
	STEP_ENTER_SLEEP, // 进入睡眠
	STEP_SET_SLEEP ,// 设置休眠模式
	STEP_QUERY_CFUN,
	STEP_SET_CFUN_0,
	STEP_SET_CFUN_1, // 设置全功能模式
	STEP_WAIT_SET_CFUN_1, // 等待设置全功能模式结果
	STEP_WAIT, // 等待
	STEP_SET_QISDE_0,
	STEP_SET_QISDE_1,
	STEP_SET_CEREG_2, // 设置ps域允许上报网络注册和位置信息
	STEP_QUERY_CEREG, // 查询网络注册状态
	STEP_SUCCESS, // 成功
	STEP_FAILURE, // 失败
	STEP_FINISH,
};

// 步骤跳转时的监听
static uint8_t STEP_SET_CFUN_1_times = 0; // 全功能模式的次数
static uint16_t goto_step_event(uint16_t ns)
{
	// 重置bc260y状态
	bc260y.reset();
	
	// 流程控制
	uint16_t step = ns;
	if(ns == STEP_SET_CFUN_1 && STEP_SET_CFUN_1_times++ >= 1)
	{
		goto_failure("重新联网次数过多");
		step = STEP_FAILURE;
	}
	return step;
}

// 流程控制
static struct PCTRL_Struct pctrl = {
	.current_step = STEP_FINISH,
	.next_step = STEP_FINISH,
	.step_wait = STEP_WAIT,
	.goto_step_listener = goto_step_event,
};

// 备注
static char info[40];
// 开始
static void goto_start(void)
{
	PCTRL_GotoStep(&pctrl, STEP_START, "开始");
}
// 成功
static void goto_success(void)
{
	INITIALIZE_SetResult(INITIALIZE_Result_Success);
	PCTRL_GotoStep(&pctrl, STEP_SUCCESS, "成功");
}
// 失败
static void goto_failure(char * _info)
{
	INITIALIZE_SetResult(INITIALIZE_Result_Failure);
	memset(info, 0, sizeof(info));
	strcpy(info, _info);
	PCTRL_GotoStep(&pctrl, STEP_FAILURE, "失败");
	Log_Printf_Debug("info：%s！\r\n", info);
}
// 结束
static void goto_finish(void)
{
	INITIALIZE_SetStatus(INITIALIZE_Status_Done);
	PCTRL_GotoStep(&pctrl, STEP_FINISH, "结束");
}





// 状态
static enum INITIALIZE_StatusEnum udpclient_status = INITIALIZE_Status_None;
// 结果
static enum INITIALIZE_ResultEnum udpclient_result = INITIALIZE_Result_None;
// 设置状态
static void INITIALIZE_SetStatus(enum INITIALIZE_StatusEnum status)
{
	udpclient_status = status;
}
// 获取状态
enum INITIALIZE_StatusEnum INITIALIZE_GetStatus(void)
{
	return udpclient_status;
}
// 设置结果
static void INITIALIZE_SetResult(enum INITIALIZE_ResultEnum result)
{
	udpclient_result = result;
}
// 获取结果
enum INITIALIZE_ResultEnum INITIALIZE_GetResult(void)
{
	return udpclient_result;
}
// 重置
enum EXECUTE_ResultEnum INITIALIZE_Reset(void)
{
	if(INITIALIZE_GetStatus() == INITIALIZE_Status_Being)
	{
		Log_Printf_Debug("初始化流程重置错误！\r\n");
		return EXECUTE_Result_Failure;
	}
	INITIALIZE_SetStatus(INITIALIZE_Status_None);
	INITIALIZE_SetResult(INITIALIZE_Result_None);
	return EXECUTE_Result_Success;
}
// 开始
enum EXECUTE_ResultEnum INITIALIZE_Start(void)
{
	INITIALIZE_Reset();
	if(INITIALIZE_GetStatus() != INITIALIZE_Status_None)
	{
		Log_Printf_Debug("初始化流程启动错误！\r\n");
		return EXECUTE_Result_Failure;
	}
	goto_start();
	INITIALIZE_SetStatus(INITIALIZE_Status_Being);
	return EXECUTE_Result_Success;
}
// 流程处理，放到循环里
void INITIALIZE_ProcessHandle(void)
{
	if(INITIALIZE_GetStatus() == INITIALIZE_Status_Being)
	{
		INITIALIZE_Process();
	}
}

// 初始化诱因处理
void INITIALIZE_TriggerHandle(void)
{
	if((REGIST_GetStatus() != REGIST_Status_Being) && (UDPCLIENT_GetStatus() != UDPCLIENT_Status_Being))
	{
		enum Result result =bc260y.ready();
		if(result==Result_Success)
		{
			INITIALIZE_Start();
		}
	}
}




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 void INITIALIZE_Process(void)
{
	switch(pctrl.current_step)
	{
		case STEP_START: // 开始
			PCTRL_GotoStep(&pctrl, STEP_EXIT_SLEEP, "退出休眠");
			break;
		case STEP_EXIT_SLEEP: // 退出休眠
			result = bc260y.exit_sleep_2();
			if(result == Result_Success)
			{
				PCTRL_GotoStep(&pctrl, STEP_SET_QISDE_1, "开启回显");
			}
			else if(result == Result_Failed)
			{
				goto_failure("退出休眠失败");
			}
			break;
		case STEP_SET_QISDE_1: // 开启回显
			result = bc260y.set_qisde(1);
		  if(result == Result_Success)
			{
				PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "设置最小功能模式");
			}
			else if(result == Result_Failed)
			{
				goto_failure("开启回显失败");
			}
		    break;
		case STEP_SET_CFUN_0:
			result=bc260y.set_cfun(0);//设置最小功能模式
			if(result == Result_Success)
			{
				if(INITIALIZE_GetResult() != INITIALIZE_Result_None)
				{
					goto_finish();
				}
				else
				{
					PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_1, "设置全功能模式");
				}
			}
			else if(result == Result_Failed)
			{
				goto_failure("设置最小功能模式失败");
				goto_finish();
			}
			break;
		case STEP_SET_CFUN_1:
			result = bc260y.set_cfun(1);
			if(result == Result_Success)
			{
				PCTRL_GotoStep(&pctrl, STEP_SET_CEREG_2, "设置网络状态");
			}
			else if(result == Result_Failed)
			{
				goto_failure("设置全功能模式失败");
			}
			break;
		case STEP_SET_CEREG_2: // 设置ps域
			result = bc260y.set_cereg(2);
			if(result == Result_Success)
			{
				PCTRL_GotoStep(&pctrl, STEP_QUERY_CEREG, "查询网络状态");
			}
			else if(result == Result_Failed)
			{
				goto_failure("设置ps域失败");
			}
			break;
		case STEP_QUERY_CEREG: // 查询ps域
			result = bc260y.query_cereg(&cgreg_n, &cgreg_stat, &cgreg_lac, &cgreg_ci);
			if(result == Result_Success)
			{
				if(cgreg_stat == 1)
				{
			    goto_success();
				}
				else
				{
					goto_failure("网络注册失败");
				}
			}
			else if(result == Result_Failed)
			{
				goto_failure("网络注册失败");
			}
			break;
		case STEP_WAIT: // 等待
			PCTRL_Wait(&pctrl);
			break;
		case STEP_SUCCESS: // 成功
			goto_finish();
			break;
		case STEP_FAILURE: // 失败
			PCTRL_GotoStep(&pctrl, STEP_SET_CFUN_0, "初始化失败，设置最小功能模式");
			break;
		case STEP_FINISH: // 结束流程
			break;
		default:
			goto_failure("步骤不存在");
			break;
	}
	
}

#endif