myvtm/Module/mod_ups/UpsFSM.cpp

#include "stdafx.h"
#include "UpsFSM.h"
#include "GetDevInfoHelper.h"
#include "EventCode.h"

#include <map>
#include "RVCComm.h"
#include "publicFunExport.h"

const int MAX_UPS_INIT_TRIES = 3;


bool isnostr(const char *str)
{
	int len = strlen(str);
	if (len == 0)
		return true;
	for (int i = 0; i < len; ++i)
	{
		if (*(str+i) != ' ')
			return false;
	}
	return true;
}
ErrorCodeEnum CUpsFSM::OnInit()
{
	LOG_FUNCTION();
	CSystemStaticInfo sysInfo;
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;

	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->InitializeVendorLogSwitch();
	FulfillAdapterInfoFrom(pEntity->vendorLibInfo);

	LogWarn(Severity_Low, Error_Unexpect, LOG_ERR_UPS_LOGWARN_ROOTINFO, m_adapterInfo.adapterFilePath.GetData());
	ToLogRootINIInfo();

	ErrorCodeEnum eErrDev = m_hDevHelper.LoadUp(m_adapterInfo.adapterFilePath);
	if (eErrDev != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("load vendor dll(%s) failed.", (LPCTSTR)m_adapterInfo.adapterFileName);
		return Error_DevLoadFileFailed;
	}
	int initTries = 0;
	do {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%d,%d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		eErrDev = m_hDevHelper->DevOpen(m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		if (eErrDev != Error_Succeed) {
			SetErrPackage("OnInit::DevOpen", m_devSN, eErrDev, MEC_DEVAPI_UPS_DevOpen);
			AlarmDEC();
			initTries++;
			Sleep(200);
			continue;
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("open ups succeed.");
		m_bOpened = true;
		ZeroMemory(m_devCatInfo.szModel, sizeof(m_devCatInfo.szModel));
		ZeroMemory(m_devCatInfo.szType, sizeof(m_devCatInfo.szType));
		ZeroMemory(m_devCatInfo.szVendor, sizeof(m_devCatInfo.szVendor));
		eErrDev = m_hDevHelper->GetDevCategory(m_devCatInfo);
		if (eErrDev == Error_Succeed) {
			m_adapterInfo.FulfillCategoryInfo(m_devCatInfo);
		} else if (eErrDev == Error_NotImpl) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevCategory return Error_NotImpl.");
		} else {
			SetErrPackage("OnInit::GetDevCategory", m_devSN, eErrDev, MEC_DEVAPI_UPS_GetDevCategory);
			AlarmDEC();
		}
		break;
	} while (initTries < MAX_UPS_INIT_TRIES);

	return Error_Succeed;
}
ErrorCodeEnum CUpsFSM::OnExit()
{
	ErrorCodeEnum eErr = Error_Succeed;
	if (m_hDevHelper != nullptr) {
		m_hDevHelper.TearDown();
	}
	return eErr;
}

void CUpsFSM::s0_on_entry()
{
	UpsStatusEnum eUpsState;
	ErrorCodeEnum eErrCode = m_hDevHelper->GetDevStatus(eUpsState);
	if (eErrCode != Error_Succeed) {
		LOG_UPS_ERROR_MSG_MACRO(eErrCode, GetDevStatus);
	} else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("UpsState: %d", eUpsState);
	}
	m_testResult = Error_Succeed;

	if (m_FirstStart) {
		m_FirstStart = FALSE;
		ToLogWarnInfoAboutTerm();
	}
	m_testResult = Error_Succeed;
}
void CUpsFSM::s0_on_exit()
{

}
unsigned int CUpsFSM::s0_on_event(FSMEvent* e)
{
	switch(e->iEvt)
	{
	case USER_EVT_SHUTDOWN:
		{
			e->SetHandled();
			ShutDownTask* task = new ShutDownTask(this);
			ShutDownEvent* sde = dynamic_cast<ShutDownEvent*>(e);
			task->ctx = sde->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 0;
		}
		break;
	case USER_EVT_GETSTATUS:
		{
			e->SetHandled();
			UpsStatusEnum eUpsState;
			ErrorCodeEnum eErrState = m_hDevHelper->GetDevStatus(eUpsState);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s,%d",SpStrError(eErrState), eUpsState);
			GetStatusEvent* pGse = dynamic_cast<GetStatusEvent*>(e);
			pGse->ctx->Ans.Status = eUpsState;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("status: %d",pGse->ctx->Ans.Status);
			pGse->ctx->Answer(eErrState);
		}
		break;
	default:
		return 1;
	}
	return 0;
}

void CUpsFSM::s1_on_entry()
{
}
void CUpsFSM::s1_on_exit()
{

}
unsigned int CUpsFSM::s1_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	switch(e->iEvt)
	{
	case USER_EVT_SHUTDOWN_FINISHED:
		{
			e->SetHandled();
			return e->param1;
		}
	default:
		return 1;
	}
}

void CUpsFSM::s2_on_entry()
{
	CheckTask *pTask = new CheckTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	m_testResult = Error_InvalidState;
}
void CUpsFSM::s2_on_exit()
{
}
unsigned int CUpsFSM::s2_on_event(FSMEvent* pEvt)
{
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_CHECK_FINISHED:
		ret = pEvt->param1;
		break;
	default:
		break;
	}
	return ret;
}

int CUpsFSM::ShutDown(SpReqAnsContext<UpsService_Shutdown_Req,UpsService_Shutdown_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	UpsStatusEnum eUpsStatus;
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("shutdown time: %d, uptime: %d", ctx->Req.ShutdownTime, ctx->Req.UpTime);
	ErrorCodeEnum err = m_hDevHelper->GetDevStatus(eUpsStatus);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("(%s)status:[%d],%d,%d",SpStrError(err), eUpsStatus, ctx->Req.ShutdownTime, ctx->Req.UpTime);
    if (ctx->Req.ShutdownTime < 0 || ctx->Req.UpTime < 0) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("error param");
        ctx->Answer(Error_Param);
        return 2; //do not jump
    }
	err = m_hDevHelper->Shutdown(ctx->Req.ShutdownTime,ctx->Req.UpTime);
	if (err == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("shutdown...");
		ctx->Answer(Error_Succeed);
		return 0;
	}
	else
	{
		LOG_UPS_ERROR_MSG_MACRO(err, Shutdown);
		ctx->Answer(Error_Unexpect);
		return 1;
	}
}
int CUpsFSM::CheckStatus()
{
	int i = 0;
	while(1)
	{
		if (m_hDevHelper != nullptr)
		{
			UpsStatusEnum eUpsStatus;
			ErrorCodeEnum eErr;
			eErr = m_hDevHelper->GetDevStatus(eUpsStatus);
			if (eErr == Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CheckStatus %d",eUpsStatus);
				if (eUpsStatus == UPS_STATUS_NORMAL || eUpsStatus == UPS_STATUS_NO_ELECTOR)
					return 0;
			}
		}
		Sleep(10000);
		i++;
		if (i > 30)
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("have try 5 minutes.");
			i = 0;
		}
	}
	return 1;
}
void CUpsFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	pTransactionContext->SendAnswer(m_testResult);
}