﻿//定数宣言(共通設定)/////////////////////////////////////////////////////////////////////////
var mcDUMMY_TAG_FILE   = "server\script\demo_taglist.txt";
var mcSYS_CONF_FILE    = "server\config\system_config.txt";
var mcSYS_UF           = "PLC01.F01.";
var mcSYS_MODE         = "SYS.MODE.PLC01_VIRTUAL";
var mcSYS_PLCMODE      = mcSYS_UF & "SIM_MODE";
var mcRONDOM_TAG       = "$SIN500";
var mcDP               = 1;

//起動初期値(起動時にONしたいアドレス)
var mcDemoDataOn = T;
var mcDemoData   = c("PLC01.F01.ZZR07559@0.BIN1",
                     "PLC01.F01.ZZR07689@0.BIN1");

var mcDemoAuto   = c("PLC01.F01.ZZR08331",
                     "PLC01.F01.ZZR08461",
                     "PLC01.F01.ZZR08591",
                     "PLC01.F01.ZZR08721");

var mcDemoDataOff = c("PLC01.F01.ZZR07559@2.BIN1",
                      "PLC01.F01.ZZR07689@2.BIN1");


//定数宣言(ﾀｲﾏ設定)
var mcTIM_LOAD_ID      = 101;
var mcTIM_PROC_ID1     = 102;
var mcTIM_PROC_ID2     = 103;
var mcTIM_LOAD_ID_INT  = 1;
var mcTIM_PROC_ID_INT1 = 1;
var mcTIM_PROC_ID_INT2 = 1;

//定数宣言(SO設定)//
var mcSO_POINT   = 0;
var mcSO_CNTL    = 1;
var mcSO_CNTL_PR = 2;
var mcSO_IO      = 3;
var mcSO_DEV_ON  = 4;
var mcSO_DEV_OFF = 5;
var mcSO_OV_ON   = 6;
var mcSO_OV_OFF  = 7;
var mcSO_NOTE    = 8;
var mcSO_RESET   = 9;
var mcSO_QUALITY = 10;
var mcSO_ALARM1  = 11;
var mcSO_ALARM2  = 12;

var mcINI_SO_CNTL   = 8;
var mcINI_SO_OV_OFF = 1;

//定数宣言(PVI設定)//
var mcPVI_POINT    = 0;
var mcPVI_PV       = 1;
var mcPVI_PV_MAX   = 2;
var mcPVI_PV_MIN   = 3;
var mcPVI_NOTE     = 4;
var mcPVI_QUALITY  = 5;
var mcPVI_DEADBAND = 6;
var mcPVI_ALARM1   = 7;
var mcPVI_ALARM2   = 8;
var mcPVI_ALARM3   = 9;
var mcPVI_ALARM4   = 10;
var mcPVI_ALST1    = 11;
var mcPVI_ALST2    = 12;
var mcPVI_ALST3    = 13;
var mcPVI_ALST4    = 14;

var mcINI_PVI_PVMAX = 300;
var mcINI_PVI_PVMIN = 0;
var mcINI_PVI_AL_HH = 300;
var mcINI_PVI_AL_H  = 285;
var mcINI_PVI_AL_L  = 15;
var mcINI_PVI_AL_LL = 0;

//定数宣言(SVO設定)//
var mcSVO_POINT      = 0;
var mcSVO_CNTL       = 1;
var mcSVO_CNTL_PR    = 2;
var mcSVO_IO         = 3;
var mcSVO_PV         = 4;
var mcSVO_SV_IN      = 5;
var mcSVO_SV_OUT     = 6;
var mcSVO_DV         = 7;
var mcSVO_SVLIMIT_HI = 8;
var mcSVO_SVLIMIT_LO = 9;
var mcSVO_PV_MAX     = 10;
var mcSVO_PV_MIN     = 11;
var mcSVO_NOTE       = 12;
var mcSVO_QUALITY    = 13;
var mcSVO_DEADBAND   = 14;
var mcSVO_ALARM1     = 15;
var mcSVO_ALARM2     = 16;
var mcSVO_ALARM3     = 17;
var mcSVO_ALARM4     = 18;
var mcSVO_ALST1      = 19;
var mcSVO_ALST2      = 20;
var mcSVO_ALST3      = 21;
var mcSVO_ALST4      = 22;
var mcSVO_ALARM5     = 23;
var mcSVO_ALST5      = 24;

var mcINI_SVO_CNTL       = 8;
var mcINI_SVO_SV_OUT     = 250;
var mcINI_SVO_DV         = 15;
var mcINI_SVO_SVLIMIT_HI = 300;
var mcINI_SVO_SVLIMIT_LO = 0;
var mcINI_SVO_PVMAX      = 300;
var mcINI_SVO_PVMIN      = 0;
var mcINI_SVO_AL_HH      = 300;
var mcINI_SVO_AL_H       = 285;
var mcINI_SVO_AL_L       = 15;
var mcINI_SVO_AL_LL      = 0;
var mcINI_SVO_AL_DV      = 10;

//定数宣言(MVO設定)//
var mcMVO_POINT      = 0;
var mcMVO_CNTL       = 1;
var mcMVO_CNTL_PR    = 2;
var mcMVO_IO         = 3;
var mcMVO_PV         = 4;
var mcMVO_MV         = 5;
var mcMVO_PV_MAX     = 6;
var mcMVO_PV_MIN     = 7;
var mcMVO_MVLIMIT_HI = 8;
var mcMVO_MVLIMIT_LO = 9;
var mcMVO_NOTE       = 10;
var mcMVO_QUALITY    = 11;
var mcMVO_DEADBAND   = 12;
var mcMVO_ALARM1     = 13;
var mcMVO_ALARM2     = 14;
var mcMVO_ALARM3     = 15;
var mcMVO_ALARM4     = 16;
var mcMVO_ALST1      = 17;
var mcMVO_ALST2      = 18;
var mcMVO_ALST3      = 19;
var mcMVO_ALST4      = 20;

var mcINI_MVO_CNTL       = 8;
var mcINI_MVO_MV         = 15;
var mcINI_MVO_PVMAX      = 100;
var mcINI_MVO_PVMIN      = 0;
var mcINI_MVO_MVLIMIT_HI = 100;
var mcINI_MVO_MVLIMIT_LO = 0;
var mcINI_MVO_AL_HH      = 100;
var mcINI_MVO_AL_H       = 95;
var mcINI_MVO_AL_L       = 5;
var mcINI_MVO_AL_LL      = 0;

//定数宣言(CNT設定)//
var mcCNT_POINT       = 0;
var mcCNT_RUN_IN      = 1;
var mcCNT_RUN_OUT     = 2;
var mcCNT_STOP_IN     = 3;
var mcCNT_STOP_OUT    = 4;
var mcCNT_RESET_IN    = 5;
var mcCNT_RESET_OUT   = 6;
var mcCNT_RESET_START = 7;
var mcCNT_PV          = 8;
var mcCNT_NOTE        = 9;
var mcCNT_QUALITY     = 10;

var mcINI_CNT_STOP_IN = 1;

//定数宣言(PR設定)//
var mcPR_POINT      = 0;
var mcPR_CNTL       = 1;
var mcPR_CNTL_PR    = 2;
var mcPR_IO         = 3;
var mcPR_PV         = 4;
var mcPR_SV         = 5;
var mcPR_MV         = 6;
var mcPR_RN         = 7;
var mcPR_SV_MAX     = 8;
var mcPR_SV_MIN     = 9;
var mcPR_SVLIMIT_HI = 10;
var mcPR_SVLIMIT_LO = 11;
var mcPR_BIAS       = 12;
var mcPR_PV_MAX     = 13;
var mcPR_PV_MIN     = 14;
var mcPR_MVLIMIT_HI = 15;
var mcPR_MVLIMIT_LO = 16;
var mcPR_NOTE       = 17;
var mcPR_QUALITY    = 18;
var mcPR_DEADBAND   = 19;
var mcPR_ALARM1     = 20;
var mcPR_ALARM2     = 21;
var mcPR_ALARM3     = 22;
var mcPR_ALARM4     = 23;
var mcPR_ALST1      = 24;
var mcPR_ALST2      = 25;
var mcPR_ALST3      = 26;
var mcPR_ALST4      = 27;
var mcPR_ALARM5     = 28;
var mcPR_ALARM6     = 29;
var mcPR_ALST5      = 30;
var mcPR_ALST6      = 31;

var mcINI_PR_CNTL       = 8;
var mcINI_PR_MV         = 15;
var mcINI_PR_SV         = 25;
var mcINI_PR_RN         = 25;
var mcINI_PR_SVMAX      = 90;
var mcINI_PR_SVMIN      = 10;
var mcINI_PR_SVLIMIT_HI = 100;
var mcINI_PR_SVLIMIT_LO = 0;
var mcINI_PR_PVMAX      = 100;
var mcINI_PR_PVMIN      = 0;
var mcINI_PR_MVLIMIT_HI = 100;
var mcINI_PR_MVLIMIT_LO = 0;
var mcINI_PR_AL_HH      = 100;
var mcINI_PR_AL_H       = 95;
var mcINI_PR_AL_L       = 5;
var mcINI_PR_AL_LL      = 0;

//定数宣言(PID設定)//
var mcPID_POINT      = 0;
var mcPID_CNTL       = 1;
var mcPID_CNTL_PID   = 2;
var mcPID_IO         = 3;
var mcPID_PV         = 4;
var mcPID_SV         = 5;
var mcPID_MV         = 6;
var mcPID_DV         = 7;
var mcPID_P          = 8;
var mcPID_I          = 9;
var mcPID_D          = 10;
var mcPID_SVLIMIT_HI = 11;
var mcPID_SVLIMIT_LO = 12;
var mcPID_PV_MAX     = 13;
var mcPID_PV_MIN     = 14;
var mcPID_MVLIMIT_HI = 15;
var mcPID_MVLIMIT_LO = 16;
var mcPID_NOTE       = 17;
var mcPID_QUALITY    = 18;
var mcPID_DEADBAND   = 19;
var mcPID_ALARM1     = 20;
var mcPID_ALARM2     = 21;
var mcPID_ALARM3     = 22;
var mcPID_ALARM4     = 23;
var mcPID_ALST1      = 24;
var mcPID_ALST2      = 25;
var mcPID_ALST3      = 26;
var mcPID_ALST4      = 27;
var mcPID_ALARM5     = 28;
var mcPID_ALST5      = 29;
var mcPID_ALARM6     = 30;
var mcPID_ALARM7     = 31;
var mcPID_ALST6      = 32;
var mcPID_ALST7      = 33;

var mcINI_PID_CNTL       = 8;
var mcINI_PID_MV         = 15;
var mcINI_PID_SV         = 250;
var mcINI_PID_DV         = 20;
var mcINI_PID_P          = 120;
var mcINI_PID_I          = 1500;
var mcINI_PID_D          = 250;
var mcINI_PID_SVLIMIT_HI = 300;
var mcINI_PID_SVLIMIT_LO = 0;
var mcINI_PID_PVMAX      = 300;
var mcINI_PID_PVMIN      = 0;
var mcINI_PID_MVLIMIT_HI = 100;
var mcINI_PID_MVLIMIT_LO = 0;
var mcINI_PID_AL_HH      = 300;
var mcINI_PID_AL_H       = 285;
var mcINI_PID_AL_L       = 15;
var mcINI_PID_AL_LL      = 0;
var mcINI_PID_AL_DV      = 10;

//変数宣言///////////////////////////////////////////////////////////////////////////////////
var mvReadData_SO;
var mvReadData_PVI;
var mvReadData_SVO;
var mvReadData_MVO;
var mvReadData_CNT;
var mvReadData_PR;
var mvReadData_PID;

var mvLoadData_SO;
var mvLoadData_PVI;
var mvLoadData_SVO;
var mvLoadData_MVO;
var mvLoadData_CNT;
var mvLoadData_PR;
var mvLoadData_PID;

var mvAddData_SO;
var mvAddData_PVI;
var mvAddData_SVO;
var mvAddData_MVO;
var mvAddData_CNT;
var mvAddData_PR;
var mvAddData_PID;

var mvIniData_SO;
var mvIniData_PVI;
var mvIniData_SVO;
var mvIniData_MVO;
var mvIniData_CNT;
var mvIniData_PR;
var mvIniData_PID;

var mvPVI_PV;
var mvSVO_PV;
var mvMVO_PV;
var mvCNT_PV;
var mvPR_PV;
var mvPID_PV;

var mvDEBUG_MODE;
var mvLoadData;

var mvLoadFlag_SO;
var mvLoadFlag_PVI;
var mvLoadFlag_SVO;
var mvLoadFlag_MVO;
var mvLoadFlag_CNT;
var mvLoadFlag_PR;
var mvLoadFlag_PID;

//EVENT:初期化処理///////////////////////////////////////////////////////////////////////////
event OnInitialize()
{
	::SvsDump("初期化処理開始");
	var vName = ::SvsGetActionName();
	::AddTag(mcSYS_MODE);
	::AddTag(mcSYS_PLCMODE);
	::AddTag(mcRONDOM_TAG);
	
	//CONFIGﾌｧｲﾙ読込
	var vSysLoadData;
	if (::LoadCsvFile(mcSYS_CONF_FILE, vSysLoadData, F, F, "[SYSTEM_CONFIG]", "(end)") == F) {
		::SvsDump("CONFIG情報の取得に失敗しました");
		return ;
	} else {
		mvDEBUG_MODE = vSysLoadData[1, vSysLoadData[0,] == "ENABLE_SERVER_SCRIPT_LOG"] == "T";
	}
	if(mvDEBUG_MODE){
		::SvsDump("詳細ﾛｸﾞ出力:有効");
	} else {
		::SvsDump("詳細ﾛｸﾞ出力:無効");
	}

	//初期化ﾌﾗｸﾞﾘｾｯﾄ
	mvLoadData = F;
	mvLoadFlag_SO = F; 
	mvLoadFlag_PVI = F;
	mvLoadFlag_SVO = F;
	mvLoadFlag_MVO = F;
	mvLoadFlag_CNT = F;
	mvLoadFlag_PR = F;
	mvLoadFlag_PID = F;
	
	::SetTimer(mcTIM_LOAD_ID, mcTIM_LOAD_ID_INT * 1000, -1);
	mDBG("初期化ﾀｲﾏを開始しました");
	::SvsDump("初期化待機中…");
}

//EVENT:ﾀｲﾏｰ処理/////////////////////////////////////////////////////////////////////////////
event OnTimer(timerid,counter)
{
	var vErrMsg;
	var vVal;
	
	//Serverﾃﾞﾊﾞｯｸﾓｰﾄﾞ
	if(::GetVal(mcSYS_MODE) == T){
		//PLCｼﾐｭﾚｰﾀﾓｰﾄﾞ
		if(::GetVal(mcSYS_PLCMODE) == T){	
			//演算処理1呼出
			if(timerid == mcTIM_PROC_ID1){
				::mDoCalculationProcess1();
			//演算処理2呼出
			}else if(timerid == mcTIM_PROC_ID2){
				::mDoCalculationProcess2();
				::mDoCalculationProcess3();
			//初回起動時のみ設定
			}else if(timerid == mcTIM_LOAD_ID && ::GetVal(mcSYS_PLCMODE) == T){
				//設定ﾃﾞｰﾀ取得
				if(mvLoadData == F){
					mDBG("[初期化処理]仮想ﾀｸﾞ準備開始");
					this.mReadTagData();
					mvLoadData = T;
				}
				//初回起動時に全てのﾀｸﾞが正しく取得できるようになるまで
				//SOクラス//////////////////////////////////////////////
				vVal = ::GetVal(mvIniData_SO);
				if(vVal[vVal == #N/A#] != #NOTHING#){
					mDBG("[初期化処理]SOｸﾗｽ 仮想ﾀｸﾞ準備中…");
					return;
				}
				//PVIクラス//////////////////////////////////////////////
				vVal = ::GetVal(mvIniData_PVI);
				if(vVal[vVal == #N/A#] != #NOTHING#){
					mDBG("[初期化処理]PVIｸﾗｽ 仮想ﾀｸﾞ準備中…");
					return;
				}
				
				//SVOクラス//////////////////////////////////////////////
				vVal = ::GetVal(mvIniData_SVO);
				if(vVal[vVal == #N/A#] != #NOTHING#){
					mDBG("[初期化処理]SVOｸﾗｽ 仮想ﾀｸﾞ準備中…");
					return;
				}
				//MVOクラス//////////////////////////////////////////////
				vVal = ::GetVal(mvIniData_MVO);
				if(vVal[vVal == #N/A#] != #NOTHING#){
					mDBG("[初期化処理]MVOｸﾗｽ 仮想ﾀｸﾞ準備中…");
					return;
				}
				//CNTクラス//////////////////////////////////////////////
				vVal = ::GetVal(mvIniData_CNT);
				if(vVal[vVal == #N/A#] != #NOTHING#){
					mDBG("[初期化処理]CNTｸﾗｽ 仮想ﾀｸﾞ準備中…");
					return;
				}
				//PRクラス//////////////////////////////////////////////
				vVal = ::GetVal(mvIniData_PR);
				if(vVal[vVal == #N/A#] != #NOTHING#){
					mDBG("[初期化処理]PRｸﾗｽ 仮想ﾀｸﾞ準備中…");
					return;
				}
				//PIDクラス//////////////////////////////////////////////
				vVal = ::GetVal(mvIniData_PID);
				if(vVal[vVal == #N/A#] != #NOTHING#){
					mDBG("[初期化処理]PIDｸﾗｽ 仮想ﾀｸﾞ準備中…");
					return;
				}		
				
				//制御設定読込・登録
				mDBG("[初期化処理]仮想ﾀｸﾞ準備完了");
				::KillTimer(mcTIM_LOAD_ID);
				mIniDataSet();
				mDBG("[初期化処理]仮想ﾀｸﾞ初期値ﾃﾞｰﾀｾｯﾄ完了");
				::SetTimer(mcTIM_PROC_ID1, mcTIM_PROC_ID_INT1 * 1000, -1);
				::SetTimer(mcTIM_PROC_ID2, mcTIM_PROC_ID_INT2 * 1000, -1);
				mDBG("仮想実行ﾌﾟﾛｾｽを開始しました");
			}
		}
	}
}

//EVENT:終了処理/////////////////////////////////////////////////////////////////////////////
event OnTerminate()
{
	::SvsDump("Destroy");
}

/////////////////////////////////////////////////////////////////////////////////////////////
//初期値設定
function mIniDataSet()
{
	var vCnt;
	var vWriteTags;
	var vWriteVals;
		
	//SOクラス////////////////////////////////////////////
	if(mvLoadFlag_SO == T){
		vWriteTags = c(mvAddData_SO[, mcSO_CNTL],
		               mvAddData_SO[, mcSO_OV_OFF]
		               );
		vCnt       = ::GetValueElement(mvAddData_SO[, mcSO_CNTL], 0);
		vWriteVals = c(::RepeatValue(mcINI_SO_CNTL, vCnt), 
		               ::RepeatValue(mcINI_SO_OV_OFF, vCnt)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(SO)");
		}
	}
	//PVIクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_PVI == T){
		vWriteTags = c(mvAddData_PVI[, mcPVI_PV_MAX],
		               mvAddData_PVI[, mcPVI_PV_MIN],
		               mvAddData_PVI[, mcPVI_ALST1],
		               mvAddData_PVI[, mcPVI_ALST2],
		               mvAddData_PVI[, mcPVI_ALST3],
		               mvAddData_PVI[, mcPVI_ALST4]
		               );
		vCnt       = ::GetValueElement(mvAddData_PVI[, mcPVI_PV_MAX], 0);
		vWriteVals = c(::RepeatValue(mcINI_PVI_PVMAX, vCnt), 
		               ::RepeatValue(mcINI_PVI_PVMIN, vCnt),
		               ::RepeatValue(mcINI_PVI_AL_HH, vCnt),
		               ::RepeatValue(mcINI_PVI_AL_H, vCnt),
		               ::RepeatValue(mcINI_PVI_AL_L, vCnt),
		               ::RepeatValue(mcINI_PVI_AL_LL, vCnt)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(PVI)");
		}
	}	
	//SVOクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_SVO == T){
		vWriteTags = c(mvAddData_SVO[, mcSVO_CNTL],
		               mvAddData_SVO[, mcSVO_SV_OUT],
		               mvAddData_SVO[, mcSVO_DV],
		               mvAddData_SVO[, mcSVO_SVLIMIT_HI],
		               mvAddData_SVO[, mcSVO_SVLIMIT_LO],
		               mvAddData_SVO[, mcSVO_PV_MAX],
		               mvAddData_SVO[, mcSVO_PV_MIN],
		               mvAddData_SVO[, mcSVO_ALST1],
		               mvAddData_SVO[, mcSVO_ALST2],
		               mvAddData_SVO[, mcSVO_ALST3],
		               mvAddData_SVO[, mcSVO_ALST4],
		               mvAddData_SVO[, mcSVO_ALST5]
		               );
		vCnt       = ::GetValueElement(mvAddData_SVO[, mcSVO_CNTL], 0);
		vWriteVals = c(::RepeatValue(mcINI_SVO_CNTL, vCnt),
		               ::RepeatValue(mcINI_SVO_SV_OUT, vCnt),
		               ::RepeatValue(mcINI_SVO_DV, vCnt),
		               ::RepeatValue(mcINI_SVO_SVLIMIT_HI, vCnt),
		               ::RepeatValue(mcINI_SVO_SVLIMIT_LO, vCnt),
		               ::RepeatValue(mcINI_SVO_PVMAX, vCnt), 
		               ::RepeatValue(mcINI_SVO_PVMIN, vCnt),
		               ::RepeatValue(mcINI_SVO_AL_HH, vCnt),
		               ::RepeatValue(mcINI_SVO_AL_H, vCnt),
		               ::RepeatValue(mcINI_SVO_AL_L, vCnt),
		               ::RepeatValue(mcINI_SVO_AL_LL, vCnt),
		               ::RepeatValue(mcINI_SVO_AL_DV, vCnt)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(SVO)");
		}
	}
	//MVOクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_MVO == T){
		vWriteTags = c(mvAddData_MVO[, mcMVO_CNTL],
		               mvAddData_MVO[, mcMVO_MV],
		               mvAddData_MVO[, mcMVO_PV_MAX],
		               mvAddData_MVO[, mcMVO_PV_MIN],
		               mvAddData_MVO[, mcMVO_MVLIMIT_HI],
		               mvAddData_MVO[, mcMVO_MVLIMIT_LO],
		               mvAddData_MVO[, mcMVO_ALST1],
		               mvAddData_MVO[, mcMVO_ALST2],
		               mvAddData_MVO[, mcMVO_ALST3],
		               mvAddData_MVO[, mcMVO_ALST4]
		               );
		vCnt       = ::GetValueElement(mvAddData_MVO[, mcMVO_CNTL], 0);
		vWriteVals = c(::RepeatValue(mcINI_MVO_CNTL, vCnt),
		               ::RepeatValue(mcINI_MVO_MV, vCnt),
		               ::RepeatValue(mcINI_MVO_PVMAX, vCnt),
		               ::RepeatValue(mcINI_MVO_PVMIN, vCnt),
		               ::RepeatValue(mcINI_MVO_MVLIMIT_HI, vCnt),
		               ::RepeatValue(mcINI_MVO_MVLIMIT_LO, vCnt),
		               ::RepeatValue(mcINI_MVO_AL_HH, vCnt),
		               ::RepeatValue(mcINI_MVO_AL_H, vCnt),
		               ::RepeatValue(mcINI_MVO_AL_L, vCnt),
		               ::RepeatValue(mcINI_MVO_AL_LL, vCnt)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(MVO)");
		}
	}
	//CNTクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_CNT == T){
		if(::WriteRefresh(mvAddData_CNT[, mcCNT_STOP_IN], mcINI_CNT_STOP_IN) == F){
				::SvsDump("初期値の一括書込に失敗しました(SO)");
		}
	}
	//PRクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_PR == T){
		vWriteTags = c(mvAddData_PR[, mcPR_CNTL],
		               mvAddData_PR[, mcPR_MV],
		               mvAddData_PR[, mcPR_SV],
		               mvAddData_PR[, mcPR_RN],
		               mvAddData_PR[, mcPR_SV_MAX],
		               mvAddData_PR[, mcPR_SV_MIN],
		               mvAddData_PR[, mcPR_SVLIMIT_HI],
		               mvAddData_PR[, mcPR_SVLIMIT_LO],
		               mvAddData_PR[, mcPR_PV_MAX],
		               mvAddData_PR[, mcPR_PV_MIN],
		               mvAddData_PR[, mcPR_MVLIMIT_HI],
		               mvAddData_PR[, mcPR_MVLIMIT_LO],
		               mvAddData_PR[, mcPR_ALST1],
		               mvAddData_PR[, mcPR_ALST2],
		               mvAddData_PR[, mcPR_ALST3],
		               mvAddData_PR[, mcPR_ALST4]
		               );
		vCnt       = ::GetValueElement(mvAddData_PR[, mcPR_CNTL], 0);
		vWriteVals = c(::RepeatValue(mcINI_PR_CNTL, vCnt),
		               ::RepeatValue(mcINI_PR_MV, vCnt),
		               ::RepeatValue(mcINI_PR_SV, vCnt),
		               ::RepeatValue(mcINI_PR_RN, vCnt),
		               ::RepeatValue(mcINI_PR_SVMAX, vCnt),
		               ::RepeatValue(mcINI_PR_SVMIN, vCnt),
		               ::RepeatValue(mcINI_PR_SVLIMIT_HI, vCnt),
		               ::RepeatValue(mcINI_PR_SVLIMIT_LO, vCnt),
		               ::RepeatValue(mcINI_PR_PVMAX, vCnt),
		               ::RepeatValue(mcINI_PR_PVMIN, vCnt),
		               ::RepeatValue(mcINI_PR_MVLIMIT_HI, vCnt),
		               ::RepeatValue(mcINI_PR_MVLIMIT_LO, vCnt),
		               ::RepeatValue(mcINI_PR_AL_HH, vCnt),
		               ::RepeatValue(mcINI_PR_AL_H, vCnt),
		               ::RepeatValue(mcINI_PR_AL_L, vCnt),
		               ::RepeatValue(mcINI_PR_AL_LL, vCnt)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(PR)");
		}
	}
	//PIDクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_PID == T){
		vWriteTags = c(mvAddData_PID[, mcPID_CNTL],
		               mvAddData_PID[, mcPID_MV],
		               mvAddData_PID[, mcPID_SV],
		               mvAddData_PID[, mcPID_DV],
		               mvAddData_PID[, mcPID_P],
		               mvAddData_PID[, mcPID_I],
		               mvAddData_PID[, mcPID_D],
		               mvAddData_PID[, mcPID_SVLIMIT_HI],
		               mvAddData_PID[, mcPID_SVLIMIT_LO],
		               mvAddData_PID[, mcPID_PV_MAX],
		               mvAddData_PID[, mcPID_PV_MIN],
		               mvAddData_PID[, mcPID_MVLIMIT_HI],
		               mvAddData_PID[, mcPID_MVLIMIT_LO],
		               mvAddData_PID[, mcPID_ALST1],
		               mvAddData_PID[, mcPID_ALST2],
		               mvAddData_PID[, mcPID_ALST3],
		               mvAddData_PID[, mcPID_ALST4],
	                       mvAddData_PID[, mcPID_ALST5]
		               );
		vCnt       = ::GetValueElement(mvAddData_PID[, mcPID_CNTL], 0);
		vWriteVals = c(::RepeatValue(mcINI_PID_CNTL, vCnt),
		               ::RepeatValue(mcINI_PID_MV, vCnt),
		               ::RepeatValue(mcINI_PID_SV, vCnt),
		               ::RepeatValue(mcINI_PID_DV, vCnt),
		               ::RepeatValue(mcINI_PID_P, vCnt),
		               ::RepeatValue(mcINI_PID_I, vCnt),
		               ::RepeatValue(mcINI_PID_D, vCnt),
		               ::RepeatValue(mcINI_PID_SVLIMIT_HI, vCnt),
		               ::RepeatValue(mcINI_PID_SVLIMIT_LO, vCnt),
		               ::RepeatValue(mcINI_PID_PVMAX, vCnt),
		               ::RepeatValue(mcINI_PID_PVMIN, vCnt),
		               ::RepeatValue(mcINI_PID_MVLIMIT_HI, vCnt),
		               ::RepeatValue(mcINI_PID_MVLIMIT_LO, vCnt),
		               ::RepeatValue(mcINI_PID_AL_HH, vCnt),
		               ::RepeatValue(mcINI_PID_AL_H, vCnt),
		               ::RepeatValue(mcINI_PID_AL_L, vCnt),
		               ::RepeatValue(mcINI_PID_AL_LL, vCnt),
		               ::RepeatValue(mcINI_PID_AL_DV, vCnt)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(PID)");
		}
	}
	
	//デモモード////////////////////////////////////////////
	if(mcDemoDataOn == T){
		//一括書き込み(FB)
		vCnt       = ::GetValueElement(mcDemoData, 0);
		vWriteVals = ::RepeatValue("1", vCnt);
			
		if(::WriteRefresh(mcDemoData, vWriteVals) == F){
					::SvsDump("初期値の一括書込に失敗しました(Demo)");
		}
		vCnt       = ::GetValueElement(mcDemoDataOff, 0);
		vWriteVals = ::RepeatValue("0", vCnt);
			
		if(::WriteRefresh(mcDemoDataOff, vWriteVals) == F){
					::SvsDump("初期値の一括書込に失敗しました(Demo)");
		}
		vCnt       = ::GetValueElement(mcDemoAuto, 0);
		vWriteVals = ::RepeatValue("16", vCnt);
			
		if(::WriteRefresh(mcDemoAuto, vWriteVals) == F){
					::SvsDump("初期値の一括書込に失敗しました(Demo)");
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////
//OutputValue値を一括で読み込み、FBへ転送（※デモ動作用）
function mDoCalculationProcess1()
{
	var vReadVals;
	var vReadTags;
	var vWriteTags;
	var vReadTagsStr;
	var vWriteTagsStr;
		
	//SOクラス////////////////////////////////////////////
	if(mvLoadFlag_SO == T){
		vReadTagsStr = ::CArrayToStr(mvAddData_SO[, mcSO_OV_ON] & "," & 
		                             mvAddData_SO[, mcSO_OV_OFF], ",", F, F);
		vWriteTagsStr = ::CArrayToStr(mvAddData_SO[, mcSO_DEV_ON] & "," & 
		                              mvAddData_SO[, mcSO_DEV_OFF], ",", F, F);
		vReadTags  = ::CStrToArray(vReadTagsStr, ",", F, F);
		vWriteTags = ::CStrToArray(vWriteTagsStr, ",", F, F);
			
		//一括読み込み(OV)
		this.ReadRefresh(vReadTags);
		vReadVals = ::GetVal(vReadTags);
		
		//一括書き込み(FB)
		if(::WriteRefresh(vWriteTags, vReadVals) == F){
			::SvsDump("仮想ﾀｸﾞの一括書込に失敗しました(SO)");
		}
	}
	//SVOクラス////////////////////////////////////////////
	if(mvLoadFlag_SVO == T){
		vReadTags  = mvAddData_SVO[, mcSVO_SV_OUT];
		vWriteTags = mvAddData_SVO[, mcSVO_SV_IN];
		
		//一括読み込み(OV)
		this.ReadRefresh(vReadTags);
		vReadVals = ::GetVal(vReadTags);
		
		//一括書き込み(FB)
		if(::WriteRefresh(vWriteTags, vReadVals) == F){
			::SvsDump("仮想ﾀｸﾞの一括書込に失敗しました(SVO_SV)");
		}
	}
	//CNTクラス////////////////////////////////////////////
	if(mvLoadFlag_CNT == T){
		vReadTagsStr = ::CArrayToStr(mvAddData_CNT[, mcCNT_RESET_OUT], ",", F, F);
		                                              
		vWriteTagsStr = ::CArrayToStr(mvAddData_CNT[, mcCNT_RESET_IN], ",", F, F);

		vReadTags  = ::CStrToArray(vReadTagsStr, ",", F, F);
		vWriteTags = ::CStrToArray(vWriteTagsStr, ",", F, F);
		
		//一括読み込み(OV)
		this.ReadRefresh(vReadTags);
		vReadVals = ::GetVal(vReadTags);
		
		//一括書き込み(FB)
		if(::WriteRefresh(vWriteTags, vReadVals) == F){
			::SvsDump("仮想ﾀｸﾞの一括書込に失敗しました(CNT_RESET)");
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////
//PV計測値を自動的に値変化させる(SVO、MVO、CNT、PR、PID)
//PIDのSV_Editの値に基づき、PV/MV/SV/DVの値を自動的に変化させる
function mDoCalculationProcess2()
{
	var vReadVals,vReadVals0,vReadVals1,vReadVals2,vReadVals3;
	var vWriteVals;
	
	//PVIクラス////////////////////////////////////////////
	if(mvLoadFlag_PVI == T){
		//FBを読込
		this.ReadRefresh(mvAddData_PVI[, mcPVI_PV]);
		vReadVals = this.GetVal(mvAddData_PVI[, mcPVI_PV]);
	
		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvPVI_PV); iCnt++){
			if(vReadVals[iCnt] > 95) {
				mvPVI_PV[iCnt] -= 1;
			}else if(vReadVals[iCnt] < 65){
				mvPVI_PV[iCnt] += 1;
			}
			vReadVals[iCnt] = mvPVI_PV[iCnt] + 1.32 * (5 *::Math.Abs(this.GetVal(mcRONDOM_TAG) * 2));
			vReadVals[iCnt] = ::CNumStr(vReadVals[iCnt], mcDP);
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PVI[, mcPVI_PV], vReadVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPVI_PV)");
		}
	}
	//SVOクラス////////////////////////////////////////////
	if(mvLoadFlag_SVO == T){
		//FBを読込
		this.ReadRefresh(mvAddData_SVO[, mcSVO_PV]);
		this.ReadRefresh(mvAddData_SVO[, mcSVO_SV_IN]);
		this.ReadRefresh(mvAddData_SVO[, mcSVO_CNTL]);
		vReadVals0 = this.GetVal(mvAddData_SVO[, mcSVO_PV]);
		vReadVals1 = this.GetVal(mvAddData_SVO[, mcSVO_SV_IN]);
		vReadVals2 = this.GetVal(mvAddData_SVO[, mcSVO_CNTL]);

		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvSVO_PV); iCnt++){
			if(mIsAutoMode(vReadVals2[iCnt]) == T)
				if(vReadVals0[iCnt] < vReadVals1[iCnt]){
					vReadVals0[iCnt] += 0.125;
				}else{
					vReadVals0[iCnt] -= 0.125;
				} 
		}
		vWriteVals = ::Math.Abs(vReadVals0 - vReadVals1);
		
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_SVO[, mcSVO_PV], vReadVals0) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvSVO_PV)");
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_SVO[, mcSVO_DV], vWriteVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvSVO_PV)");
		}
	}
	//MVOクラス////////////////////////////////////////////
	if(mvLoadFlag_MVO == T){
		//FBを読込
		this.ReadRefresh(mvAddData_MVO[, mcMVO_PV]);
		this.ReadRefresh(mvAddData_MVO[, mcMVO_MV]);
		vReadVals = this.GetVal(mvAddData_MVO[, mcMVO_PV]);
		vReadVals0 = this.GetVal(mvAddData_MVO[, mcMVO_MV]);

		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvMVO_PV); iCnt++){
			if(vReadVals0[iCnt] < 65){
				vReadVals0[iCnt] += 0.125;
			}else{
				vReadVals0[iCnt] -= 0.125;
			} 
			vReadVals[iCnt] = ::CNumStr(vReadVals0[iCnt] * 1.234, mcDP);
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_MVO[, mcMVO_PV], vReadVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvMVO_PV)");
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_MVO[, mcMVO_MV], vReadVals0) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvMVO_MV)");
		}
	}
	//CNTクラス////////////////////////////////////////////
	if(mvLoadFlag_CNT == T){
		//FBを読込
		this.ReadRefresh(mvAddData_CNT[,mcCNT_PV]);
		this.ReadRefresh(mvAddData_CNT[,mcCNT_RUN_OUT]);
		this.ReadRefresh(mvAddData_CNT[,mcCNT_STOP_OUT]);
		this.ReadRefresh(mvAddData_CNT[,mcCNT_RESET_OUT]);
		this.ReadRefresh(mvAddData_CNT[,mcCNT_RESET_START]);
		
		var vReadVals0 = this.GetVal(mvAddData_CNT[, mcCNT_PV]);
		var vReadVals1 = this.GetVal(mvAddData_CNT[, mcCNT_RUN_OUT]);
		var vReadVals2 = this.GetVal(mvAddData_CNT[, mcCNT_STOP_OUT]);
		var vReadVals3 = this.GetVal(mvAddData_CNT[, mcCNT_RESET_OUT]);
		var vReadVals4 = this.GetVal(mvAddData_CNT[, mcCNT_RESET_START]);
	
		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvCNT_PV); iCnt++){
			if(vReadVals1[iCnt] == T){
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_RUN_IN], 1) == F){
					::SvsDump("RUNの書込に失敗しました(mcCNT_RUN_IN)");
				}
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_STOP_IN], 0) == F){
					::SvsDump("RUNの書込に失敗しました(mcCNT_RUN_OUT)");
				}
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_STOP_OUT], 0) == F){
					::SvsDump("RUNの書込に失敗しました(mcCNT_STOP_OUT)");
				}
				mvCNT_PV[iCnt] = mvCNT_PV[iCnt] + 1;
				vReadVals0[iCnt] = mvCNT_PV[iCnt];
			}
			if(vReadVals2[iCnt] == T){
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_RUN_IN], 0) == F){
					::SvsDump("RUNの書込に失敗しました(mcCNT_RUN_IN)");
				}
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_RUN_OUT], 0) == F){
					::SvsDump("RUNの書込に失敗しました(mcCNT_RUN_OUT)");
				}
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_STOP_IN], 1) == F){
					::SvsDump("RUNの書込に失敗しました(mcCNT_STOP_OUT)");
				}
			}
			//RESETの場合(現在PVを0)
			if(vReadVals3[iCnt] == T){
				mvCNT_PV[iCnt] = 0;
				vReadVals0[iCnt] = 0;
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_RESET_OUT], 0) == F){
					::SvsDump("RESETの書込に失敗しました(mcCNT_RESET_OUT)");
				}
			}
			//RESET_STARTの場合(現在PVを0にしてRUN開始)
			if(vReadVals4[iCnt] == T){
				mvCNT_PV[iCnt] = 0;
				vReadVals0[iCnt] = 0;
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_RUN_OUT], 1) == F){
					::SvsDump("RUNの書込に失敗しました(mcCNT_RUN_OUT)");
				}
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_STOP_OUT], 0) == F){
					::SvsDump("STOPの書込に失敗しました(mcCNT_STOP_OUT)");
				}
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_RESET_OUT], 0) == F){
					::SvsDump("RESETの書込に失敗しました(mcCNT_RESET_OUT)");
				}
				if(::WriteVal(mvAddData_CNT[iCnt, mcCNT_RESET_START], 0) == F){
					::SvsDump("RESET_STARTの書込に失敗しました(mcCNT_RESET_START)");
				}
			}
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_CNT[,mcCNT_PV], vReadVals0) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込に失敗しました(mcCNT_PV)");
		}
	}
	//PRクラス////////////////////////////////////////////
	if(mvLoadFlag_PR == T){
		//FBを読込
		this.ReadRefresh(mvAddData_PR[, mcPR_PV]);
		this.ReadRefresh(mvAddData_PR[, mcPR_SV]);
		this.ReadRefresh(mvAddData_PR[, mcPR_MV]);
		this.ReadRefresh(mvAddData_PR[, mcPR_CNTL]);
		vReadVals0 = this.GetVal(mvAddData_PR[, mcPR_PV]);
		vReadVals1 = this.GetVal(mvAddData_PR[, mcPR_SV]);
		vReadVals2 = this.GetVal(mvAddData_PR[, mcPR_MV]);
		vReadVals3 = this.GetVal(mvAddData_PR[, mcPR_CNTL]);

		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvPR_PV); iCnt++){
			if(mIsAutoMode(vReadVals3[iCnt]) == T){
				if(vReadVals0[iCnt] < vReadVals1[iCnt]){
					vReadVals2[iCnt] += 0.125;
				}else{
					vReadVals2[iCnt] -= 0.125;
				} 
				vReadVals0[iCnt] = ::CNumStr(vReadVals2[iCnt] * 1.234, mcDP);
			}
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PR[, mcPR_PV], vReadVals0) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPR_PV)");
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PR[, mcPR_MV], vReadVals2) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPR_MV)");
		}
	}
	//PIDクラス////////////////////////////////////////////
	if(mvLoadFlag_PID == T){
		//FBを読込
		this.ReadRefresh(mvAddData_PID[, mcPID_PV]);
		this.ReadRefresh(mvAddData_PID[, mcPID_SV]);
		this.ReadRefresh(mvAddData_PID[, mcPID_MV]);
		this.ReadRefresh(mvAddData_PID[, mcPID_CNTL]);
		vReadVals0 = this.GetVal(mvAddData_PID[, mcPID_PV]);
		vReadVals1 = this.GetVal(mvAddData_PID[, mcPID_SV]);
		vReadVals2 = this.GetVal(mvAddData_PID[, mcPID_MV]);
		vReadVals3 = this.GetVal(mvAddData_PID[, mcPID_CNTL]);

		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvPID_PV); iCnt++){
			if(mIsAutoMode(vReadVals3[iCnt]) == T){
				if(vReadVals0[iCnt] < vReadVals1[iCnt]){
					vReadVals2[iCnt] += 0.125;
				}else{
					vReadVals2[iCnt] -= 0.125;
				} 
				vReadVals0[iCnt] = ::CNumStr(vReadVals2[iCnt] * 1.234 / 3, mcDP);
			}
		}
		vWriteVals = ::Math.Abs(vReadVals0 - vReadVals1);

		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PID[, mcPID_PV], vReadVals0) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPID_PV)");
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PID[, mcPID_MV], vReadVals2) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPID_MV)");
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PID[, mcPID_DV], vWriteVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPID_DV)");
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////
//デモンストレーションモード(警報)
function mDoCalculationProcess3()
{
	var vReadTags,vReadTagsStr,vReadVals;
	var vWriteTags,vWriteTagsStr, vWriteVals;
	var vReadPV,vReadMV,vReadDV,vReadAL1,vReadAL2,vReadAL3,vReadAL4,vReadAL5,vReadAL6,vReadAL7;
	
	//警報確認
	//PVIクラス////////////////////////////////////////////
	if(mvLoadFlag_PVI == T){
		//FBを読込
		vReadTagsStr = ::CArrayToStr(mvAddData_PVI[, mcPVI_PV] & "," &
		                             mvAddData_PVI[, mcPVI_ALST1] & "," &
		                             mvAddData_PVI[, mcPVI_ALST2] & "," &
		                             mvAddData_PVI[, mcPVI_ALST3] & "," &
		                             mvAddData_PVI[, mcPVI_ALST4], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadPV  = this.GetVal(mvAddData_PVI[, mcPVI_PV]);
		vReadAL1 = this.GetVal(mvAddData_PVI[, mcPVI_ALST1]);
		vReadAL2 = this.GetVal(mvAddData_PVI[, mcPVI_ALST2]);
		vReadAL3 = this.GetVal(mvAddData_PVI[, mcPVI_ALST3]);
		vReadAL4 = this.GetVal(mvAddData_PVI[, mcPVI_ALST4]);		
		
		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvPVI_PV); iCnt++){
			vWriteTagsStr = ::CArrayToStr(mvAddData_PVI[iCnt, mcPVI_ALARM1] & "," &
			                              mvAddData_PVI[iCnt, mcPVI_ALARM2] & "," &
			                              mvAddData_PVI[iCnt, mcPVI_ALARM3] & "," &
			                              mvAddData_PVI[iCnt, mcPVI_ALARM4], ",", F, F);
			vWriteTags = ::CStrToArray(vWriteTagsStr, ",", F, F);
			vWriteVals = c(0, 0, 0, 0);
			
			if(vReadPV[iCnt] >= vReadAL1[iCnt]){
				vWriteVals[0] = 1;
			}
			if(vReadPV[iCnt] >= vReadAL2[iCnt]){
				vWriteVals[1] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL3[iCnt]){
				vWriteVals[2] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL4[iCnt]){
				vWriteVals[3] = 1;
			}
			//演算結果を一括書き込み
			if(::WriteRefresh(vWriteTags, vWriteVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(PVI警報)");
	  		}
		}
	}
	//SVOクラス////////////////////////////////////////////
	if(mvLoadFlag_SVO == T){
		//FBを読込
		vReadTagsStr = ::CArrayToStr(mvAddData_SVO[, mcSVO_PV] & "," &
		                             mvAddData_SVO[, mcSVO_ALST1] & "," &
		                             mvAddData_SVO[, mcSVO_ALST2] & "," &
		                             mvAddData_SVO[, mcSVO_ALST3] & "," &
		                             mvAddData_SVO[, mcSVO_ALST4] & "," &
		                             mvAddData_SVO[, mcSVO_ALST5], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadPV  = this.GetVal(mvAddData_SVO[, mcSVO_PV]);
		vReadDV  = this.GetVal(mvAddData_SVO[, mcSVO_DV]);
		vReadAL1 = this.GetVal(mvAddData_SVO[, mcSVO_ALST1]);
		vReadAL2 = this.GetVal(mvAddData_SVO[, mcSVO_ALST2]);
		vReadAL3 = this.GetVal(mvAddData_SVO[, mcSVO_ALST3]);
		vReadAL4 = this.GetVal(mvAddData_SVO[, mcSVO_ALST4]);		
		vReadAL5 = this.GetVal(mvAddData_SVO[, mcSVO_ALST5]);	
		
		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvSVO_PV); iCnt++){
			vWriteTagsStr = ::CArrayToStr(mvAddData_SVO[iCnt, mcSVO_ALARM1] & "," &
			                              mvAddData_SVO[iCnt, mcSVO_ALARM2] & "," &
			                              mvAddData_SVO[iCnt, mcSVO_ALARM3] & "," &
			                              mvAddData_SVO[iCnt, mcSVO_ALARM4] & "," &			
			                              mvAddData_SVO[iCnt, mcSVO_ALARM5], ",", F, F);
			vWriteTags = ::CStrToArray(vWriteTagsStr, ",", F, F);
			vWriteVals = c(0, 0, 0, 0, 0);
			
			if(vReadPV[iCnt] >= vReadAL1[iCnt]){
				vWriteVals[0] = 1;
			}
			if(vReadPV[iCnt] >= vReadAL2[iCnt]){
				vWriteVals[1] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL3[iCnt]){
				vWriteVals[2] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL4[iCnt]){
				vWriteVals[3] = 1;
			}
			if(vReadDV >= vReadAL5[iCnt]){
				vWriteVals[4] = 1;
			}
			//演算結果を一括書き込み
			if(::WriteRefresh(vWriteTags, vWriteVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(SVO警報)");
	  		}
		}
	}
	//MVOクラス////////////////////////////////////////////
	if(mvLoadFlag_MVO == T){
		//FBを読込
		vReadTagsStr = ::CArrayToStr(mvAddData_MVO[, mcMVO_PV] & "," &
		                             mvAddData_MVO[, mcMVO_ALST1] & "," &
		                             mvAddData_MVO[, mcMVO_ALST2] & "," &
		                             mvAddData_MVO[, mcMVO_ALST3] & "," &
		                             mvAddData_MVO[, mcMVO_ALST4], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadPV  = this.GetVal(mvAddData_MVO[, mcMVO_PV]);
		vReadAL1 = this.GetVal(mvAddData_MVO[, mcMVO_ALST1]);
		vReadAL2 = this.GetVal(mvAddData_MVO[, mcMVO_ALST2]);
		vReadAL3 = this.GetVal(mvAddData_MVO[, mcMVO_ALST3]);
		vReadAL4 = this.GetVal(mvAddData_MVO[, mcMVO_ALST4]);
		
		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvMVO_PV); iCnt++){
			vWriteTagsStr = ::CArrayToStr(mvAddData_MVO[iCnt, mcMVO_ALARM1] & "," &
			                              mvAddData_MVO[iCnt, mcMVO_ALARM2] & "," &
			                              mvAddData_MVO[iCnt, mcMVO_ALARM3] & "," &
			                              mvAddData_MVO[iCnt, mcMVO_ALARM4], ",", F, F);
			vWriteTags = ::CStrToArray(vWriteTagsStr, ",", F, F);
			vWriteVals = c(0, 0, 0, 0);
			
			if(vReadPV[iCnt] >= vReadAL1[iCnt]){
				vWriteVals[0] = 1;
			}
			if(vReadPV[iCnt] >= vReadAL2[iCnt]){
				vWriteVals[1] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL3[iCnt]){
				vWriteVals[2] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL4[iCnt]){
				vWriteVals[3] = 1;
			}
			
			//演算結果を一括書き込み
			if(::WriteRefresh(vWriteTags, vWriteVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(MVO警報)");
	  		}
		}
	}
	//PRクラス////////////////////////////////////////////
	if(mvLoadFlag_PR == T){
		//FBを読込
		vReadTagsStr = ::CArrayToStr(mvAddData_PR[, mcPR_PV] & "," &
		                             mvAddData_PR[, mcPR_MV] & "," &
		                             mvAddData_PR[, mcPR_ALST1] & "," &
		                             mvAddData_PR[, mcPR_ALST2] & "," &
		                             mvAddData_PR[, mcPR_ALST3] & "," &
		                             mvAddData_PR[, mcPR_ALST4] & "," &		
		                             mvAddData_PR[, mcPR_ALST5] & "," &
		                             mvAddData_PR[, mcPR_ALST6], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadPV  = this.GetVal(mvAddData_PR[, mcPR_PV]);
		vReadMV  = this.GetVal(mvAddData_PR[, mcPR_MV]);
		vReadAL1 = this.GetVal(mvAddData_PR[, mcPR_ALST1]);
		vReadAL2 = this.GetVal(mvAddData_PR[, mcPR_ALST2]);
		vReadAL3 = this.GetVal(mvAddData_PR[, mcPR_ALST3]);
		vReadAL4 = this.GetVal(mvAddData_PR[, mcPR_ALST4]);
		vReadAL5 = this.GetVal(mvAddData_PR[, mcPR_ALST5]);		
		vReadAL6 = this.GetVal(mvAddData_PR[, mcPR_ALST6]);		
				
		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvPR_PV); iCnt++){
			vWriteTagsStr = ::CArrayToStr(mvAddData_PR[iCnt, mcPR_ALARM1] & "," &
			                              mvAddData_PR[iCnt, mcPR_ALARM2] & "," &
			                              mvAddData_PR[iCnt, mcPR_ALARM3] & "," &
			                              mvAddData_PR[iCnt, mcPR_ALARM4] & "," &
			                              mvAddData_PR[iCnt, mcPR_ALARM5] & "," &			
			                              mvAddData_PR[iCnt, mcPR_ALARM6], ",", F, F);
			vWriteTags = ::CStrToArray(vWriteTagsStr, ",", F, F);
			vWriteVals = c(0, 0, 0, 0, 0, 0);
			
			if(vReadPV[iCnt] >= vReadAL1[iCnt]){
				vWriteVals[0] = 1;
			}
			if(vReadPV[iCnt] >= vReadAL2[iCnt]){
				vWriteVals[1] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL3[iCnt]){
				vWriteVals[2] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL4[iCnt]){
				vWriteVals[3] = 1;
			}
			if(vReadMV[iCnt] >= vReadAL5[iCnt]){
				vWriteVals[4] = 1;
			}
			if(vReadMV[iCnt] <= vReadAL6[iCnt]){
				vWriteVals[5] = 1;
			}

			//演算結果を一括書き込み
			if(::WriteRefresh(vWriteTags, vWriteVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(PR警報)");
	  		}
		}
	}
	//PIDクラス////////////////////////////////////////////
	if(mvLoadFlag_PID == T){
		//FBを読込
		vReadTagsStr = ::CArrayToStr(mvAddData_PID[, mcPID_PV] & "," &
		                             mvAddData_PID[, mcPID_DV] & "," &
		                             mvAddData_PID[, mcPID_MV] & "," &
		                             mvAddData_PID[, mcPID_ALST1] & "," &
		                             mvAddData_PID[, mcPID_ALST2] & "," &
		                             mvAddData_PID[, mcPID_ALST3] & "," &
		                             mvAddData_PID[, mcPID_ALST4] & "," &		
		                             mvAddData_PID[, mcPID_ALST5] & "," &
		                             mvAddData_PID[, mcPID_ALST6] & "," &
		                             mvAddData_PID[, mcPID_ALST7], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadPV  = this.GetVal(mvAddData_PID[, mcPID_PV]);
		vReadMV  = this.GetVal(mvAddData_PID[, mcPID_MV]);
		vReadDV  = this.GetVal(mvAddData_PID[, mcPID_DV]);
		vReadAL1 = this.GetVal(mvAddData_PID[, mcPID_ALST1]);
		vReadAL2 = this.GetVal(mvAddData_PID[, mcPID_ALST2]);
		vReadAL3 = this.GetVal(mvAddData_PID[, mcPID_ALST3]);
		vReadAL4 = this.GetVal(mvAddData_PID[, mcPID_ALST4]);
		vReadAL5 = this.GetVal(mvAddData_PID[, mcPID_ALST5]);		
		vReadAL6 = this.GetVal(mvAddData_PID[, mcPID_ALST6]);		
		vReadAL7 = this.GetVal(mvAddData_PID[, mcPID_ALST7]);
				
		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvPID_PV); iCnt++){
			vWriteTagsStr = ::CArrayToStr(mvAddData_PID[iCnt, mcPID_ALARM1] & "," &
			                              mvAddData_PID[iCnt, mcPID_ALARM2] & "," &
			                              mvAddData_PID[iCnt, mcPID_ALARM3] & "," &
			                              mvAddData_PID[iCnt, mcPID_ALARM4] & "," &
			                              mvAddData_PID[iCnt, mcPID_ALARM5] & "," &
			                              mvAddData_PID[iCnt, mcPID_ALARM6] & "," &			
			                              mvAddData_PID[iCnt, mcPID_ALARM7], ",", F, F);
			vWriteTags = ::CStrToArray(vWriteTagsStr, ",", F, F);
			vWriteVals = c(0, 0, 0, 0, 0, 0, 0);
			
			if(vReadPV[iCnt] >= vReadAL1[iCnt]){
				vWriteVals[0] = 1;
			}
			if(vReadPV[iCnt] >= vReadAL2[iCnt]){
				vWriteVals[1] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL3[iCnt]){
				vWriteVals[2] = 1;
			}
			if(vReadPV[iCnt] <= vReadAL4[iCnt]){
				vWriteVals[3] = 1;
			}
			if(vReadDV >= vReadAL5[iCnt]){
				vWriteVals[4] = 1;
			}
			if(vReadMV[iCnt] >= vReadAL6[iCnt]){
				vWriteVals[5] = 1;
			}
			if(vReadMV[iCnt] <= vReadAL7[iCnt]){
				vWriteVals[6] = 1;
			}

			//演算結果を一括書き込み
			if(::WriteRefresh(vWriteTags, vWriteVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(PID警報)");
	  		}
		}
	}
}

//ﾕｰｻﾞｰ定義関数:ﾃﾞﾊﾞｯｸﾞ用実ﾀｸﾞﾃﾞｰﾀ格納関数///////////////////////////////////////////////////
function mReadTagData()
{
  var vErrMsg;

	//実ﾀｸﾞﾃﾞｰﾀ取得(SO)////////////
	if(mLoadTagIniData("[SO]", "[SO_END]", mvReadData_SO, mvLoadData_SO, mvAddData_SO, mvIniData_SO, vErrMsg) == F){
		mDBG(vErrMsg);
	}else{
		if(mvIniData_SO != "" && mvIniData_SO != #N/A#){
			::AddTag(mvIniData_SO);
			mvLoadFlag_SO = T;
			mDBG("[MELSEC:SO]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_SO = F;
			mDBG("[MELSEC:SO]:仮想実ﾀｸﾞ登録無し");
		}
	}
	//実ﾀｸﾞﾃﾞｰﾀ取得(PVI)////////////
	if(mLoadTagIniData("[PVI]", "[PVI_END]", mvReadData_PVI, mvLoadData_PVI, mvAddData_PVI, mvIniData_PVI, vErrMsg) == F){
		mDBG(vErrMsg);
	}else{
		if(mvIniData_PVI != "" && mvIniData_PVI != #N/A#){
			::AddTag(mvIniData_PVI);
			mvPVI_PV = ::RepeatValue(1, ::GetValueTotalElement(mvAddData_PVI[, mcPVI_PV]));
			mvLoadFlag_PVI = T;
			mDBG("[MELSEC:PVI]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_PVI = F;
			mDBG("[MELSEC:PVI]:仮想実ﾀｸﾞ登録無し");
		}	
	}
	//実ﾀｸﾞﾃﾞｰﾀ取得(SVO)////////////
	if(mLoadTagIniData("[SVO]", "[SVO_END]", mvReadData_SVO, mvLoadData_SVO, mvAddData_SVO, mvIniData_SVO, vErrMsg) == F){
		mDBG(vErrMsg);
	}else{
		if(mvIniData_SVO != "" && mvIniData_SVO != #N/A#){
			::AddTag(mvIniData_SVO);
			mvSVO_PV = ::RepeatValue(1, ::GetValueTotalElement(mvAddData_SVO[, mcSVO_PV]));
			mvLoadFlag_SVO = T;
			mDBG("[MELSEC:SVO]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_SVO = F;
			mDBG("[MELSEC:SVO]:仮想実ﾀｸﾞ登録無し");
		}	
	}
	//実ﾀｸﾞﾃﾞｰﾀ取得(MVO)////////////
	if(mLoadTagIniData("[MVO]", "[MVO_END]", mvReadData_MVO, mvLoadData_MVO, mvAddData_MVO, mvIniData_MVO, vErrMsg) == F){
		mDBG(vErrMsg);
	}else{
		if(mvIniData_MVO != "" && mvIniData_MVO != #N/A#){
			::AddTag(mvIniData_MVO);
			mvMVO_PV = ::RepeatValue(1, ::GetValueTotalElement(mvAddData_MVO[, mcMVO_PV]));
			mvLoadFlag_MVO = T;
			mDBG("[MELSEC:MVO]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_MVO = F;
			mDBG("[MELSEC:MVO]:仮想実ﾀｸﾞ登録無し");
		}	
	}
	//実ﾀｸﾞﾃﾞｰﾀ取得(CNT)////////////
	if(mLoadTagIniData("[CNT]", "[CNT_END]", mvReadData_CNT, mvLoadData_CNT, mvAddData_CNT, mvIniData_CNT, vErrMsg) == F){
		mDBG(vErrMsg);
	}else{
		if(mvIniData_CNT != "" && mvIniData_CNT != #N/A#){
			::AddTag(mvIniData_CNT);
			mvCNT_PV = ::RepeatValue(1, ::GetValueTotalElement(mvAddData_CNT[, mcCNT_PV]));
			mvLoadFlag_CNT = T;
			mDBG("[MELSEC:CNT]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_CNT = F;
			mDBG("[MELSEC:CNT]:仮想実ﾀｸﾞ登録無し");
		}
	}
	//実ﾀｸﾞﾃﾞｰﾀ取得(PR)////////////
	if(mLoadTagIniData("[PR]", "[PR_END]", mvReadData_PR, mvLoadData_PR, mvAddData_PR, mvIniData_PR, vErrMsg) == F){
		mDBG(vErrMsg);
	}else{
		if(mvIniData_PR != "" && mvIniData_PR != #N/A#){
			::AddTag(mvIniData_PR);
			mvPR_PV = ::RepeatValue(1, ::GetValueTotalElement(mvAddData_PR[, mcPR_PV]));
			mvLoadFlag_PR = T;
			mDBG("[MELSEC:PR]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_PR = F;
			mDBG("[MELSEC:PR]:仮想実ﾀｸﾞ登録無し");
		}
	}
	//実ﾀｸﾞﾃﾞｰﾀ取得(PID)////////////
	if(mLoadTagIniData("[PID]", "[PID_END]", mvReadData_PID, mvLoadData_PID, mvAddData_PID, mvIniData_PID, vErrMsg) == F){
		mDBG(vErrMsg);
	}else{
		if(mvIniData_PID != "" && mvIniData_PID != #N/A#){
			::AddTag(mvIniData_PID);
			mvPID_PV = ::RepeatValue(1, ::GetValueTotalElement(mvAddData_PID[, mcPID_PV]));
			mvLoadFlag_PID = T;
			mDBG("[MELSEC:PID]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_PID = F;
			mDBG("[MELSEC:PID]:仮想実ﾀｸﾞ登録無し");
		}	
	}		
	::SvsDump("初期化処理完了");
}

//ﾕｰｻﾞｰ定義関数:ﾃﾞﾊﾞｯｸﾞ用実ﾀｸﾞﾃﾞｰﾀ取得関数///////////////////////////////////////////////////
//引数1:vFData    (検索開始ｺｰﾄﾞ)
//引数2:vEData    (検索終了ｺｰﾄﾞ)
//返値1:vLoadData (範囲内全ﾃﾞｰﾀ)
//返値1:vIniData  (範囲内ﾎﾟｲﾝﾄｱﾄﾞﾚｽﾃﾞｰﾀ)
//返値1:vErrMsg   (関数ｴﾗｰﾒｯｾｰｼﾞ)
function mLoadTagIniData(vFData, vEData, &vReadData, &vLoadData, &vAddData, &vIniData, &vErrMsg)
{
	if (::LoadCsvFile(mcDUMMY_TAG_FILE, vReadData, F, F, vFData, vEData) == F){
		vErrMsg = vFData & ":" & "実ﾀｸﾞﾃﾞｰﾀ取得取得失敗";
		return F;
	}else{
		//空白行を削除
		var vMemData = #NOTHING#;
		var vCnt = ::GetValueElement(vReadData, 0);
		var vDevCnt = ::GetValueElement(vReadData, 1);

		for(var iCnt = 0; iCnt < vCnt; iCnt++){
			if(vReadData[iCnt, 1] !=""){
				vMemData = ::AddTableRow(vMemData, vReadData[iCnt,]);
			}
		}
		
		vLoadData = vMemData;
		//実ﾀｸﾞｱﾄﾞﾚｽ取得(配列変換後の全ﾃﾞｰﾀ)
		vReadData = ::ExchangeTableColRow(vLoadData);
		
		//実ﾀｸﾞｱﾄﾞﾚｽ取得(配列変換後のｱﾄﾞﾚｽのみ)
		vAddData = #NOTHING#;
		vCnt = ::GetValueElement(vLoadData, 0);
		vDevCnt = ::GetValueElement(vLoadData, 1);
		vAddData = ::Revar(vAddData, vCnt - 1, vDevCnt);
		for(var iCnt = 0; iCnt < vCnt; iCnt++){
			vAddData[iCnt,] = vLoadData[iCnt + 1,];
		}
		
		//実ﾀｸﾞｱﾄﾞﾚｽ取得(実ﾀｸﾞのみ1次元配列)
		vIniData = vReadData;
		vIniData[0,] = "";
		vIniData[,0] = "";
		vIniData = ::GetUniqueValue(vIniData);
		vIniData = ::CArrayToStr(vIniData, ",", F, F);
		vIniData  = ::TrimLeftStr(vIniData,",");
		vIniData = ::CStrToArray(vIniData, ",", F, F);
	}
	return T;
}

//ﾕｰｻﾞｰ定義関数:FB自動・手動関数/////////////////////////////////////////////////////////////
function mIsAutoMode(vValue)
{
	var vRet = (vValue & 0x10) > 0;
	return vRet;
}

function mIsManualMode(vValue)
{
	var vRet = (vValue & 0x8) > 0;
	return vRet;
}

function mIsCasMode(vValue)
{
	var vRet = (vValue & 0x20) > 0;
	return vRet;
}

function mIsDisableAutoMode(vValue)
{
	var vRet = (vValue & 0x10) > 0;
	return vRet;
}

function mIsDisableManualMode(vValue)
{
	var vRet = (vValue & 0x8) > 0;
	return vRet;
}

function mIsDisableCasMode(vValue)
{
	var vRet = (vValue & 0x20) > 0;
	return vRet;
}

//ﾕｰｻﾞｰ定義関数:ﾃﾞﾊﾞｯｸﾞ用ﾛｸﾞ出力関数/////////////////////////////////////////////////////////
function mDBG(vMessage)
{
	if(mvDEBUG_MODE){
		 ::SvsDump(vMessage);
	}
}