﻿//定数宣言(共通設定)/////////////////////////////////////////////////////////////////////////
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               = 2;

//起動初期値(起動時にONしたいアドレス)
var mcDemoDataOn = T;
var mcDemoData   = c("PLC01.F01.EM15858@1.BIN1",
                     "PLC01.F01.EM15878@1.BIN1",
                     "PLC01.F01.EM15898@1.BIN1",
                     "PLC01.F01.EM15918@1.BIN1",
                     "PLC01.F01.EM15738@2.BIN1",
                     "PLC01.F01.EM15758@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_AMMODE_IN  = 1;
var mcSO_AMMODE_OUT = 2;
var mcSO_VAL_IN     = 3;
var mcSO_VAL_OUT    = 4;
var mcSO_NOTE       = 5;
var mcSO_QUALITY    = 6;
var mcSO_BYPASS     = 7;

//定数宣言(PVI設定)//
var mcPVI_POINT     = 0;
var mcPVI_PVPLC     = 1;
var mcPVI_NOTE      = 2;
var mcPVI_QUALITY   = 3;
var mcPVI_PV_FIL    = 4;
var mcPVI_BYPASS    = 5;
var mcPVI_ALARM1    = 6;
var mcPVI_ALARM2    = 7;
var mcPVI_ALARM3    = 8;
var mcPVI_ALARM4    = 9;
var mcPVI_ALST1_IN  = 10;
var mcPVI_ALST1_OUT = 11;
var mcPVI_ALST2_IN  = 12;
var mcPVI_ALST2_OUT = 13;
var mcPVI_ALST3_IN  = 14;
var mcPVI_ALST3_OUT = 15;
var mcPVI_ALST4_IN  = 16;
var mcPVI_ALST4_OUT = 17;

var mcINI_PVI_AL_HH = 100;
var mcINI_PVI_AL_H  = 95;
var mcINI_PVI_AL_L  = 5;
var mcINI_PVI_AL_LL = 0;

//定数宣言(SVO設定)//
var mcSVO_POINT      = 0;
var mcSVO_LRMODE_IN  = 1;
var mcSVO_LRMODE_OUT = 2;
var mcSVO_SVMODE_IN  = 3;
var mcSVO_SVMODE_OUT = 4;
var mcSVO_PVPLC      = 5;
var mcSVO_SVPLC_IN   = 6;
var mcSVO_SVPLC_OUT  = 7;
var mcSVO_NOTE       = 8;
var mcSVO_QUALITY    = 9;
var mcSVO_PV_FIL     = 10;
var mcSVO_BYPASS     = 11;
var mcSVO_ALARM1     = 12;
var mcSVO_ALARM2     = 13;
var mcSVO_ALARM3     = 14;
var mcSVO_ALARM4     = 15;
var mcSVO_ALST1_IN   = 16;
var mcSVO_ALST1_OUT  = 17;
var mcSVO_ALST2_IN   = 18;
var mcSVO_ALST2_OUT  = 19;
var mcSVO_ALST3_IN   = 20;
var mcSVO_ALST3_OUT  = 21;
var mcSVO_ALST4_IN   = 22;
var mcSVO_ALST4_OUT  = 23;

var mcINI_SVO_SVPLC_OUT = 80;
var mcINI_SVO_AL_HH     = 100;
var mcINI_SVO_AL_H      = 95;
var mcINI_SVO_AL_L      = 5;
var mcINI_SVO_AL_LL     = 0;

//定数宣言(MVO設定)//
var mcMVO_POINT      = 0;
var mcMVO_AMMODE_IN  = 1;
var mcMVO_AMMODE_OUT = 2;
var mcMVO_PVPLC      = 3;
var mcMVO_MV_IN      = 4;
var mcMVO_MV_OUT     = 5;
var mcMVO_NOTE       = 6;
var mcMVO_QUALITY    = 7;
var mcMVO_PV_FIL     = 8;
var mcMVO_BYPASS     = 9;
var mcMVO_ALARM1     = 10;
var mcMVO_ALARM2     = 11;
var mcMVO_ALARM3     = 12;
var mcMVO_ALARM4     = 13;
var mcMVO_ALST1_IN   = 14;
var mcMVO_ALST1_OUT  = 15;
var mcMVO_ALST2_IN   = 16;
var mcMVO_ALST2_OUT  = 17;
var mcMVO_ALST3_IN   = 18;
var mcMVO_ALST3_OUT  = 19;
var mcMVO_ALST4_IN   = 20;
var mcMVO_ALST4_OUT  = 21;
var mcMVO_ALARM5     = 22;
var mcMVO_ALARM6     = 23;
var mcMVO_ALST5_IN   = 24;
var mcMVO_ALST5_OUT  = 25;
var mcMVO_ALST6_IN   = 26;
var mcMVO_ALST6_OUT  = 27;

var mcINI_MVO_AL_HH  = 100;
var mcINI_MVO_AL_H   = 95;
var mcINI_MVO_AL_L   = 5;
var mcINI_MVO_AL_LL  = 0;
var mcINI_MVO_AL_MVH = 100;
var mcINI_MVO_AL_MVL = 0;

//定数宣言(CNT設定)//
var mcCNT_POINT       = 0;
var mcCNT_RUNSTOP_IN  = 1;
var mcCNT_RUNSTOP_OUT = 2;
var mcCNT_PV          = 3;
var mcCNT_QUALITY     = 4;
var mcCNT_BYPASS      = 5;

var mcINI_CNT_STOP_OUT = 0;

//定数宣言(PR設定)//
var mcPR_POINT       = 0;
var mcPR_AMMODE_IN   = 1;
var mcPR_AMMODE_OUT  = 2;
var mcPR_LRMODE_IN   = 3;
var mcPR_LRMODE_OUT  = 4;
var mcPR_SVMODE_IN   = 5;
var mcPR_SVMODE_OUT  = 6;
var mcPR_PVPLC       = 7;
var mcPR_SVPLC_IN    = 8;
var mcPR_SVPLC_OUT   = 9;
var mcPR_MV_IN       = 10;
var mcPR_MV_OUT      = 11;
var mcPR_RATIO_IN    = 12;
var mcPR_RATIO_OUT   = 13;
var mcPR_INBIAS_IN   = 14;
var mcPR_INBIAS_OUT  = 15;
var mcPR_OUTBIAS_IN  = 16;
var mcPR_OUTBIAS_OUT = 17;
var mcPR_NOTE        = 18;
var mcPR_QUALITY     = 19;
var mcPR_PV_FIL      = 20;
var mcPR_BYPASS      = 21;
var mcPR_ALARM1      = 22;
var mcPR_ALARM2      = 23;
var mcPR_ALST1_IN    = 24;
var mcPR_ALST1_OUT   = 25;
var mcPR_ALST2_IN    = 26;
var mcPR_ALST2_OUT   = 27;

var mcINI_PR_SVPLC_OUT = 25;
var mcINI_PR_AL_MVH    = 100;
var mcINI_PR_AL_MVL    = 0;

//定数宣言(PID設定)//
var mcPID_POINT      = 0;
var mcPID_AMMODE_IN  = 1;
var mcPID_AMMODE_OUT = 2;
var mcPID_LRMODE_IN  = 3;
var mcPID_LRMODE_OUT = 4;
var mcPID_SVMODE_IN  = 5;
var mcPID_SVMODE_OUT = 6;
var mcPID_PVPLC      = 7;
var mcPID_SVPLC_IN   = 8;
var mcPID_SVPLC_OUT  = 9;
var mcPID_MV_IN      = 10;
var mcPID_MV_OUT     = 11;
var mcPID_DVPLC      = 12;
var mcPID_P_IN       = 13;
var mcPID_P_OUT      = 14;
var mcPID_I_IN       = 15;
var mcPID_I_OUT      = 16;
var mcPID_D_IN       = 17;
var mcPID_D_OUT      = 18;
var mcPID_NOTE       = 19;
var mcPID_QUALITY    = 20;
var mcPID_PV_FIL     = 21;
var mcPID_BYPASS     = 22;
var mcPID_ALARM1     = 23;
var mcPID_ALARM2     = 24;
var mcPID_ALARM3     = 25;
var mcPID_ALARM4     = 26;
var mcPID_ALST1_IN   = 27;
var mcPID_ALST1_OUT  = 28;
var mcPID_ALST2_IN   = 29;
var mcPID_ALST2_OUT  = 30;
var mcPID_ALST3_IN   = 31;
var mcPID_ALST3_OUT  = 32;
var mcPID_ALST4_IN   = 33;
var mcPID_ALST4_OUT  = 34;
var mcPID_ALARM5     = 35;
var mcPID_ALST5_IN   = 36;
var mcPID_ALST5_OUT  = 37;
var mcPID_ALARM6     = 38;
var mcPID_ALARM7     = 39;
var mcPID_ALST6_IN   = 40;
var mcPID_ALST6_OUT  = 41;
var mcPID_ALST7_IN   = 42;
var mcPID_ALST7_OUT  = 43;

var mcINI_PID_SVPLC  = 80;
var mcINI_PID_P      = 120;
var mcINI_PID_I      = 1500;
var mcINI_PID_D      = 250;
var mcINI_PID_AL_HH  = 100;
var mcINI_PID_AL_H   = 95;
var mcINI_PID_AL_L   = 5;
var mcINI_PID_AL_LL  = 0;
var mcINI_PID_AL_DV  = 10;
var mcINI_PID_AL_MVH = 100;
var mcINI_PID_AL_MVL = 0;

//変数宣言///////////////////////////////////////////////////////////////////////////////////
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();
				::SetTimer(mcTIM_PROC_ID1, mcTIM_PROC_ID_INT1 * 1000, -1);
				::SetTimer(mcTIM_PROC_ID2, mcTIM_PROC_ID_INT2 * 2000, -1);
				mDBG("仮想実行ﾌﾟﾛｾｽを開始しました");
			}
		}
	}
}

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

/////////////////////////////////////////////////////////////////////////////////////////////
//初期値設定
function mIniDataSet()
{
	var vCnt;
	var vWriteTags;
	var vWriteVals;
	
  //PVIクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_PVI == T){
		vWriteTags = c(mvAddData_PVI[, mcPVI_ALST1_OUT],
		               mvAddData_PVI[, mcPVI_ALST2_OUT],
		               mvAddData_PVI[, mcPVI_ALST3_OUT],
		               mvAddData_PVI[, mcPVI_ALST4_OUT]
		               );
		vCnt       = ::GetValueElement(mvAddData_PVI[, mcPVI_ALST1_OUT], 0);
		vWriteVals = c(::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_SVPLC_OUT],
		               mvAddData_SVO[, mcSVO_ALST1_OUT],
		               mvAddData_SVO[, mcSVO_ALST2_OUT],
		               mvAddData_SVO[, mcSVO_ALST3_OUT],
		               mvAddData_SVO[, mcSVO_ALST4_OUT]
		               );
		vCnt       = ::GetValueElement(mvAddData_SVO[, mcSVO_SVPLC_OUT], 0);
		vWriteVals = c(::RepeatValue(mcINI_SVO_SVPLC_OUT, 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)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(SVO)");
		}
	}

	//MVOクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_MVO == T){
		vWriteTags = c(mvAddData_MVO[, mcMVO_ALST1_OUT],
		               mvAddData_MVO[, mcMVO_ALST2_OUT],
		               mvAddData_MVO[, mcMVO_ALST3_OUT],
		               mvAddData_MVO[, mcMVO_ALST4_OUT],
		               mvAddData_MVO[, mcMVO_ALST5_OUT],	
		               mvAddData_MVO[, mcMVO_ALST6_OUT]
		               );
		vCnt       = ::GetValueElement(mvAddData_MVO[, mcMVO_ALST1_OUT], 0);
		vWriteVals = c(::RepeatValue(mcINI_MVO_AL_HH, vCnt),
		               ::RepeatValue(mcINI_MVO_AL_H, vCnt),
		               ::RepeatValue(mcINI_MVO_AL_L, vCnt),
		               ::RepeatValue(mcINI_MVO_AL_LL, vCnt),
		               ::RepeatValue(mcINI_MVO_AL_MVH, vCnt),
		               ::RepeatValue(mcINI_MVO_AL_MVL, vCnt)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(MVO)");
		}
	}

	//CNTクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_CNT == T){
		if(::WriteRefresh(mvAddData_CNT[, mcCNT_RUNSTOP_OUT], mcINI_CNT_STOP_OUT) == F){
				::SvsDump("初期値の一括書込に失敗しました(CNT)");
		}
	}

	//PRクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_PR == T){
		vWriteTags = c(mvAddData_PR[, mcPR_SVPLC_OUT],
		               mvAddData_PR[, mcPR_ALST1_OUT],
		               mvAddData_PR[, mcPR_ALST2_OUT]
		               );
		vCnt       = ::GetValueElement(mvAddData_PR[, mcPR_SVPLC_OUT], 0);
		vWriteVals = c(::RepeatValue(mcINI_PR_SVPLC_OUT, vCnt),
		               ::RepeatValue(mcINI_PR_AL_MVH, vCnt),
		               ::RepeatValue(mcINI_PR_AL_MVL, vCnt)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(PR)");
		}
	}

	//PIDクラス////////////////////////////////////////////
	//一括書き込み(FB)
	if(mvLoadFlag_PID == T){
		vWriteTags = c(mvAddData_PID[, mcPID_SVPLC_OUT],
    	               mvAddData_PID[, mcPID_P_OUT],
		               mvAddData_PID[, mcPID_I_OUT],
		               mvAddData_PID[, mcPID_D_OUT],
		               mvAddData_PID[, mcPID_ALST1_OUT],
		               mvAddData_PID[, mcPID_ALST2_OUT],
		               mvAddData_PID[, mcPID_ALST3_OUT],
		               mvAddData_PID[, mcPID_ALST4_OUT],
		               mvAddData_PID[, mcPID_ALST5_OUT],
		               mvAddData_PID[, mcPID_ALST6_OUT],
		               mvAddData_PID[, mcPID_ALST7_OUT]
		               );
		vCnt       = ::GetValueElement(mvAddData_PID[, mcPID_SVPLC_OUT], 0);
		vWriteVals = c(::RepeatValue(mcINI_PID_SVPLC, vCnt),
		               ::RepeatValue(mcINI_PID_P, vCnt),
		               ::RepeatValue(mcINI_PID_I, vCnt),
		               ::RepeatValue(mcINI_PID_D, 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),
		               ::RepeatValue(mcINI_PR_AL_MVH, vCnt),
		               ::RepeatValue(mcINI_PR_AL_MVL, vCnt)
		               );
		
		if(::WriteRefresh(vWriteTags, vWriteVals) == F){
				::SvsDump("初期値の一括書込に失敗しました(SO)");
		}
	}
	
	//デモモード////////////////////////////////////////////
	if(mcDemoDataOn == T){
		//一括書き込み(FB)
		vCnt       = ::GetValueElement(mcDemoData, 0);
		vWriteVals = ::RepeatValue("1", vCnt);
			
		if(::WriteRefresh(mcDemoData, 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_AMMODE_OUT] & "," & 
		                             mvAddData_SO[, mcSO_VAL_OUT], ",", F, F);
		                                           
		vWriteTagsStr = ::CArrayToStr(mvAddData_SO[, mcSO_AMMODE_IN] & "," & 
		                              mvAddData_SO[, mcSO_VAL_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("仮想ﾀｸﾞの一括書込に失敗しました(SO)");
		}
	}
	//PVIクラス////////////////////////////////////////////
	if(mvLoadFlag_PVI == T){
		vReadTagsStr = ::CArrayToStr(mvAddData_PVI[, mcPVI_ALST1_OUT] & "," & 
		                             mvAddData_PVI[, mcPVI_ALST2_OUT] & "," & 
		                             mvAddData_PVI[, mcPVI_ALST3_OUT] & "," & 
		                             mvAddData_PVI[, mcPVI_ALST4_OUT], ",", F, F);
		                                           
		vWriteTagsStr = ::CArrayToStr(mvAddData_PVI[, mcPVI_ALST1_IN] & "," & 
		                              mvAddData_PVI[, mcPVI_ALST2_IN] & "," & 
		                              mvAddData_PVI[, mcPVI_ALST3_IN] & "," & 
		                              mvAddData_PVI[, mcPVI_ALST4_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("仮想ﾀｸﾞの一括書込に失敗しました(PVI)");
		}
	}
	//SVOクラス////////////////////////////////////////////
	if(mvLoadFlag_SVO == T){
		vReadTagsStr = ::CArrayToStr(mvAddData_SVO[, mcSVO_LRMODE_OUT] & "," & 
		                             mvAddData_SVO[, mcSVO_SVMODE_OUT] & "," &
		                             mvAddData_SVO[, mcSVO_SVPLC_OUT] & "," & 
		                             mvAddData_SVO[, mcSVO_ALST1_OUT] & "," & 
		                             mvAddData_SVO[, mcSVO_ALST2_OUT] & "," & 
		                             mvAddData_SVO[, mcSVO_ALST3_OUT] & "," & 
		                             mvAddData_SVO[, mcSVO_ALST4_OUT], ",", F, F);
		                                           
		vWriteTagsStr = ::CArrayToStr(mvAddData_SVO[, mcSVO_LRMODE_IN] & "," & 
		                              mvAddData_SVO[, mcSVO_SVMODE_IN] & "," &
		                              mvAddData_SVO[, mcSVO_SVPLC_IN] & "," & 
		                              mvAddData_SVO[, mcSVO_ALST1_IN] & "," & 
		                              mvAddData_SVO[, mcSVO_ALST2_IN] & "," & 
		                              mvAddData_SVO[, mcSVO_ALST3_IN] & "," & 
		                              mvAddData_SVO[, mcSVO_ALST4_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("仮想ﾀｸﾞの一括書込に失敗しました(SVO)");
		}
	}
	//MVOクラス////////////////////////////////////////////
	if(mvLoadFlag_MVO == T){
		vReadTagsStr = ::CArrayToStr(mvAddData_MVO[, mcMVO_AMMODE_OUT] & "," &
		                             mvAddData_MVO[, mcMVO_MV_OUT] & "," &
		                             mvAddData_MVO[, mcMVO_ALST1_OUT] & "," &
		                             mvAddData_MVO[, mcMVO_ALST2_OUT] & "," &
		                             mvAddData_MVO[, mcMVO_ALST3_OUT] & "," &
		                             mvAddData_MVO[, mcMVO_ALST4_OUT] & "," &
		                             mvAddData_MVO[, mcMVO_ALST5_OUT] & "," &
		                             mvAddData_MVO[, mcMVO_ALST6_OUT], ",", F, F);
		                                           
		vWriteTagsStr = ::CArrayToStr(mvAddData_MVO[, mcMVO_AMMODE_IN] & "," &
		                              mvAddData_MVO[, mcMVO_MV_IN] & "," &	
		                              mvAddData_MVO[, mcMVO_ALST1_IN] & "," &
		                              mvAddData_MVO[, mcMVO_ALST2_IN] & "," &
		                              mvAddData_MVO[, mcMVO_ALST3_IN] & "," &
		                              mvAddData_MVO[, mcMVO_ALST4_IN] & "," &
		                              mvAddData_MVO[, mcMVO_ALST5_IN] & "," &
		                              mvAddData_MVO[, mcMVO_ALST6_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("仮想ﾀｸﾞの一括書込に失敗しました(MVO)");
		}
	}
	//CNTクラス////////////////////////////////////////////
	if(mvLoadFlag_CNT == T){
		vReadTags  = mvAddData_CNT[, mcCNT_RUNSTOP_OUT];
		vWriteTags = mvAddData_CNT[, mcCNT_RUNSTOP_IN];
		
		//一括読み込み(OV)
		this.ReadRefresh(vReadTags);
		vReadVals = ::GetVal(vReadTags);
		
		//一括書き込み(FB)
		if(::WriteRefresh(vWriteTags, vReadVals) == F){
			::SvsDump("仮想ﾀｸﾞの一括書込に失敗しました(CNT)");
		}
	}
	if(mvLoadFlag_PR == T){	
		//PRクラス////////////////////////////////////////////
		vReadTagsStr = ::CArrayToStr(mvAddData_PR[, mcPR_AMMODE_OUT] & "," &
		                             mvAddData_PR[, mcPR_LRMODE_OUT] & "," &
		                             mvAddData_PR[, mcPR_SVMODE_OUT] & "," &
		                             mvAddData_PR[, mcPR_SVPLC_OUT] & "," &
		                             mvAddData_PR[, mcPR_MV_OUT] & "," &
		                             mvAddData_PR[, mcPR_RATIO_OUT] & "," &
		                             mvAddData_PR[, mcPR_INBIAS_OUT] & "," &
		                             mvAddData_PR[, mcPR_OUTBIAS_OUT] & "," &
		                             mvAddData_PR[, mcPR_ALST1_OUT] & "," &
		                             mvAddData_PR[, mcPR_ALST2_OUT], ",", F, F);
		                                           
		vWriteTagsStr = ::CArrayToStr(mvAddData_PR[, mcPR_AMMODE_IN] & "," &
		                             mvAddData_PR[, mcPR_LRMODE_IN] & "," &
		                             mvAddData_PR[, mcPR_SVMODE_IN] & "," &
		                             mvAddData_PR[, mcPR_SVPLC_IN] & "," &
		                             mvAddData_PR[, mcPR_MV_IN] & "," &
		                             mvAddData_PR[, mcPR_RATIO_IN] & "," &
		                             mvAddData_PR[, mcPR_INBIAS_IN] & "," &
		                             mvAddData_PR[, mcPR_OUTBIAS_IN] & "," &
		                             mvAddData_PR[, mcPR_ALST1_IN] & "," &
		                             mvAddData_PR[, mcPR_ALST2_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("仮想ﾀｸﾞの一括書込に失敗しました(PR)");
		}
	}
	//PIDクラス////////////////////////////////////////////
	if(mvLoadFlag_PID == T){
		vReadTagsStr = ::CArrayToStr(mvAddData_PID[, mcPID_AMMODE_OUT] & "," &
		                             mvAddData_PID[, mcPID_LRMODE_OUT] & "," &
		                             mvAddData_PID[, mcPID_SVMODE_OUT] & "," &
		                             mvAddData_PID[, mcPID_SVPLC_OUT] & "," &
		                             mvAddData_PID[, mcPID_MV_OUT] & "," &
		                             mvAddData_PID[, mcPID_P_OUT] & "," &
		                             mvAddData_PID[, mcPID_I_OUT] & "," &
		                             mvAddData_PID[, mcPID_D_OUT] & "," &
		                             mvAddData_PID[, mcPID_ALST1_OUT] & "," &
		                             mvAddData_PID[, mcPID_ALST2_OUT] & "," &
		                             mvAddData_PID[, mcPID_ALST3_OUT] & "," &
		                             mvAddData_PID[, mcPID_ALST4_OUT] & "," &
		                             mvAddData_PID[, mcPID_ALST5_OUT] & "," &
		                             mvAddData_PID[, mcPID_ALST6_OUT] & "," &
		                             mvAddData_PID[, mcPID_ALST7_OUT], ",", F, F);
		                                           
		vWriteTagsStr = ::CArrayToStr(mvAddData_PID[, mcPID_AMMODE_IN] & "," &
		                              mvAddData_PID[, mcPID_LRMODE_IN] & "," &
		                              mvAddData_PID[, mcPID_SVMODE_IN] & "," &
		                              mvAddData_PID[, mcPID_SVPLC_IN] & "," &
		                              mvAddData_PID[, mcPID_MV_IN] & "," &
		                              mvAddData_PID[, mcPID_P_IN] & "," &
		                              mvAddData_PID[, mcPID_I_IN] & "," &
		                              mvAddData_PID[, mcPID_D_IN] & "," &
		                              mvAddData_PID[, mcPID_ALST1_IN] & "," &
		                              mvAddData_PID[, mcPID_ALST2_IN] & "," &
		                              mvAddData_PID[, mcPID_ALST3_IN] & "," &
		                              mvAddData_PID[, mcPID_ALST4_IN] & "," &
		                              mvAddData_PID[, mcPID_ALST5_IN] & "," &
		                              mvAddData_PID[, mcPID_ALST6_IN] & "," &
		                              mvAddData_PID[, mcPID_ALST7_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("仮想ﾀｸﾞの一括書込に失敗しました(PID)");
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////
//PV計測値を自動的に値変化させる(SVO、MVO、CNT、PR、PID)
//PIDのSV_Editの値に基づき、PV/MV/SV/DVの値を自動的に変化させる
function mDoCalculationProcess2()
{
	var vReadVals;
	var vReadVals0,vReadVals1,vReadVals2,vReadVals3;
	var vWriteVals;

	//PVIクラス////////////////////////////////////////////
	if(mvLoadFlag_PVI == T){
		//FBを読込
		this.ReadRefresh(mvAddData_PVI[, mcPVI_PVPLC]);
		vReadVals = this.GetVal(mvAddData_PVI[, mcPVI_PVPLC]);
	
		//演算
		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_PVPLC], vReadVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPVI_PV)");
		}
	}
	//SVOクラス////////////////////////////////////////////
	if(mvLoadFlag_SVO == T){
		//FBを読込
		this.ReadRefresh(mvAddData_SVO[, mcSVO_PVPLC]);
		this.ReadRefresh(mvAddData_SVO[, mcSVO_SVPLC_IN]);
		vReadVals0 = this.GetVal(mvAddData_SVO[, mcSVO_PVPLC]);
		vReadVals1 = this.GetVal(mvAddData_SVO[, mcSVO_SVPLC_IN]);

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

		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvMVO_PV); iCnt++){
			if(vReadVals1[iCnt] == T){
				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_PVPLC], vReadVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvMVO_PV)");
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_MVO[, mcMVO_MV_OUT], vReadVals0) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvMVO_MV)");
		}
	}
	//CNTクラス////////////////////////////////////////////
	if(mvLoadFlag_CNT == T){
		//FBを読込
		this.ReadRefresh(mvAddData_CNT[,mcCNT_PV]);
		this.ReadRefresh(mvAddData_CNT[,mcCNT_RUNSTOP_IN]);
		vReadVals0 = this.GetVal(mvAddData_CNT[, mcCNT_PV]);
		vReadVals1 = this.GetVal(mvAddData_CNT[, mcCNT_RUNSTOP_IN]);
	
		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvCNT_PV); iCnt++){
			//STARTの場合(現在PVに1加算)
			if(vReadVals1[iCnt] == T){
				mvCNT_PV[iCnt] = mvCNT_PV[iCnt] + 1;
				vReadVals0[iCnt] = mvCNT_PV[iCnt];
			}else{
				mvCNT_PV[iCnt] = 0;
			}
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_CNT[,mcCNT_PV], vReadVals0) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込に失敗しました(mcCNT_PV)");
		}
	}	
	//PRクラス////////////////////////////////////////////
	if(mvLoadFlag_PR == T){
		//FBを読込
		this.ReadRefresh(mvAddData_PR[, mcPR_PVPLC]);
		this.ReadRefresh(mvAddData_PR[, mcPR_SVPLC_IN]);
		this.ReadRefresh(mvAddData_PR[, mcPR_MV_IN]);
		this.ReadRefresh(mvAddData_PR[, mcPR_AMMODE_IN]);
		vReadVals0 = this.GetVal(mvAddData_PR[, mcPR_PVPLC]);
		vReadVals1 = this.GetVal(mvAddData_PR[, mcPR_SVPLC_IN]);
		vReadVals2 = this.GetVal(mvAddData_PR[, mcPR_MV_IN]);
		vReadVals3 = this.GetVal(mvAddData_PR[, mcPR_AMMODE_IN]);

		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvPR_PV); iCnt++){
			if(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_PVPLC], vReadVals0) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPR_PV)");
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PR[, mcPR_MV_OUT], vReadVals2) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPR_MV)");
		}
	}
	//PIDクラス////////////////////////////////////////////
	if(mvLoadFlag_PID == T){
		//FBを読込
		this.ReadRefresh(mvAddData_PID[, mcPID_PVPLC]);
		this.ReadRefresh(mvAddData_PID[, mcPID_SVPLC_IN]);
		this.ReadRefresh(mvAddData_PID[, mcPID_MV_IN]);
		this.ReadRefresh(mvAddData_PID[, mcPID_AMMODE_IN]);
		vReadVals0 = this.GetVal(mvAddData_PID[, mcPID_PVPLC]);
		vReadVals1 = this.GetVal(mvAddData_PID[, mcPID_SVPLC_IN]);
		vReadVals2 = this.GetVal(mvAddData_PID[, mcPID_MV_IN]);
		vReadVals3 = this.GetVal(mvAddData_PID[, mcPID_AMMODE_IN]);

		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvPID_PV); iCnt++){
			if(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);
			}
		}
		vWriteVals = ::Math.Abs(vReadVals0 - vReadVals1);

		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PID[, mcPID_PVPLC], vReadVals0) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPID_PV)");
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PID[, mcPID_MV_OUT], vReadVals2) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(mvPID_MV)");
		}
		//演算結果を一括書き込み
		if(::WriteRefresh(mvAddData_PID[, mcPID_DVPLC], 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_PVPLC] & "," &
		                             mvAddData_PVI[, mcPVI_ALST1_IN] & "," &
		                             mvAddData_PVI[, mcPVI_ALST2_IN] & "," &
		                             mvAddData_PVI[, mcPVI_ALST3_IN] & "," &
		                             mvAddData_PVI[, mcPVI_ALST4_IN], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadPV  = this.GetVal(mvAddData_PVI[, mcPVI_PVPLC]);
		vReadAL1 = this.GetVal(mvAddData_PVI[, mcPVI_ALST1_IN]);
		vReadAL2 = this.GetVal(mvAddData_PVI[, mcPVI_ALST2_IN]);
		vReadAL3 = this.GetVal(mvAddData_PVI[, mcPVI_ALST3_IN]);
		vReadAL4 = this.GetVal(mvAddData_PVI[, mcPVI_ALST4_IN]);		
		
		//演算
		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_PVPLC] & "," &
		                             mvAddData_SVO[, mcSVO_ALST1_IN] & "," &
		                             mvAddData_SVO[, mcSVO_ALST2_IN] & "," &
		                             mvAddData_SVO[, mcSVO_ALST3_IN] & "," &
		                             mvAddData_SVO[, mcSVO_ALST4_IN], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadPV  = this.GetVal(mvAddData_SVO[, mcSVO_PVPLC]);
		vReadAL1 = this.GetVal(mvAddData_SVO[, mcSVO_ALST1_IN]);
		vReadAL2 = this.GetVal(mvAddData_SVO[, mcSVO_ALST2_IN]);
		vReadAL3 = this.GetVal(mvAddData_SVO[, mcSVO_ALST3_IN]);
		vReadAL4 = this.GetVal(mvAddData_SVO[, mcSVO_ALST4_IN]);		
		
		//演算
		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], ",", 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仮想ﾀｸﾞの一括書込みに失敗しました(SVO警報)");
	  		}
		}
	}
	//MVOクラス////////////////////////////////////////////
	if(mvLoadFlag_MVO == T){
		//FBを読込
		vReadTagsStr = ::CArrayToStr(mvAddData_MVO[, mcMVO_PVPLC] & "," &
		                             mvAddData_MVO[, mcMVO_MV_IN] & "," &
		                             mvAddData_MVO[, mcMVO_ALST1_IN] & "," &
		                             mvAddData_MVO[, mcMVO_ALST2_IN] & "," &
		                             mvAddData_MVO[, mcMVO_ALST3_IN] & "," &
		                             mvAddData_MVO[, mcMVO_ALST4_IN] & "," &				
		                             mvAddData_MVO[, mcMVO_ALST5_IN] & "," &
		                             mvAddData_MVO[, mcMVO_ALST6_IN], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadPV  = this.GetVal(mvAddData_MVO[, mcMVO_PVPLC]);
		vReadMV  = this.GetVal(mvAddData_MVO[, mcMVO_MV_IN]);
		vReadAL1 = this.GetVal(mvAddData_MVO[, mcMVO_ALST1_IN]);
		vReadAL2 = this.GetVal(mvAddData_MVO[, mcMVO_ALST2_IN]);
		vReadAL3 = this.GetVal(mvAddData_MVO[, mcMVO_ALST3_IN]);
		vReadAL4 = this.GetVal(mvAddData_MVO[, mcMVO_ALST4_IN]);
		vReadAL5 = this.GetVal(mvAddData_MVO[, mcMVO_ALST5_IN]);		
		vReadAL6 = this.GetVal(mvAddData_MVO[, mcMVO_ALST6_IN]);		
		
		//演算
		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] & "," &
			                              mvAddData_MVO[iCnt, mcMVO_ALARM5] & "," &
			                              mvAddData_MVO[iCnt, mcMVO_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仮想ﾀｸﾞの一括書込みに失敗しました(MVO警報)");
	  		}
		}
	}
	//PRクラス////////////////////////////////////////////
	if(mvLoadFlag_PR == T){
		//FBを読込
		vReadTagsStr = ::CArrayToStr(mvAddData_PR[, mcPR_MV_IN] & "," &
		                             mvAddData_PR[, mcPR_ALST1_IN] & "," &
		                             mvAddData_PR[, mcPR_ALST2_IN], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadMV  = this.GetVal(mvAddData_PR[, mcPR_MV_IN]);
		vReadAL1 = this.GetVal(mvAddData_PR[, mcPR_ALST1_IN]);
		vReadAL2 = this.GetVal(mvAddData_PR[, mcPR_ALST2_IN]);
		
		//演算
		for(var iCnt=0; iCnt< ::GetValueTotalElement(mvPR_PV); iCnt++){
			vWriteTagsStr = ::CArrayToStr(mvAddData_PR[iCnt, mcPR_ALARM1] & "," &
			                              mvAddData_PR[iCnt, mcPR_ALARM2], ",", F, F);
			vWriteTags = ::CStrToArray(vWriteTagsStr, ",", F, F);
			vWriteVals = c(0, 0);
			
			if(vReadMV[iCnt] >= vReadAL1[iCnt]){
				vWriteVals[0] = 1;
			}
			if(vReadMV[iCnt] <= vReadAL2[iCnt]){
				vWriteVals[1] = 1;
			}
			
			//演算結果を一括書き込み
			if(::WriteRefresh(vWriteTags, vWriteVals) == F){
			::SvsDump("PV仮想ﾀｸﾞの一括書込みに失敗しました(PR警報)");
	  		}
		}
	}
	//PIDクラス////////////////////////////////////////////
	if(mvLoadFlag_PID == T){
		//FBを読込
		vReadTagsStr = ::CArrayToStr(mvAddData_PID[, mcPID_PVPLC] & "," &
		                             mvAddData_PID[, mcPID_DVPLC] & "," &
		                             mvAddData_PID[, mcPID_MV_IN] & "," &
		                             mvAddData_PID[, mcPID_ALST1_IN] & "," &
		                             mvAddData_PID[, mcPID_ALST2_IN] & "," &
		                             mvAddData_PID[, mcPID_ALST3_IN] & "," &
		                             mvAddData_PID[, mcPID_ALST4_IN] & "," &		
		                             mvAddData_PID[, mcPID_ALST5_IN] & "," &
		                             mvAddData_PID[, mcPID_ALST6_IN] & "," &
		                             mvAddData_PID[, mcPID_ALST7_IN], ",", F, F);
		vReadTags = ::CStrToArray(vReadTagsStr, ",", F, F);
		
		this.ReadRefresh(vReadTags);
		
		vReadPV  = this.GetVal(mvAddData_PID[, mcPID_PVPLC]);
		vReadMV  = this.GetVal(mvAddData_PID[, mcPID_MV_IN]);
		vReadDV  = this.GetVal(mvAddData_PID[, mcPID_DVPLC]);
		vReadAL1 = this.GetVal(mvAddData_PID[, mcPID_ALST1_IN]);
		vReadAL2 = this.GetVal(mvAddData_PID[, mcPID_ALST2_IN]);
		vReadAL3 = this.GetVal(mvAddData_PID[, mcPID_ALST3_IN]);
		vReadAL4 = this.GetVal(mvAddData_PID[, mcPID_ALST4_IN]);
		vReadAL5 = this.GetVal(mvAddData_PID[, mcPID_ALST5_IN]);		
		vReadAL6 = this.GetVal(mvAddData_PID[, mcPID_ALST6_IN]);		
		vReadAL7 = this.GetVal(mvAddData_PID[, mcPID_ALST7_IN]);
				
		//演算
		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("[SYSMAC:SO]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_SO = F;
			mDBG("[SYSMAC: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_PVPLC]));
			mvLoadFlag_PVI = T;
			mDBG("[SYSMAC:PVI]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_PVI = F;
			mDBG("[SYSMAC: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_PVPLC]));
			mvLoadFlag_SVO = T;
			mDBG("[SYSMAC:SVO]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_SVO = F;
			mDBG("[SYSMAC: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_PVPLC]));
			mvLoadFlag_MVO = T;
			mDBG("[SYSMAC:MVO]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_MVO = F;
			mDBG("[SYSMAC: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);
			mvLoadFlag_CNT = T;
			mvCNT_PV = ::RepeatValue(1, ::GetValueTotalElement(mvAddData_CNT[, mcCNT_PV]));
			mDBG("[SYSMAC:CNT]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_CNT = F;
			mDBG("[SYSMAC: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_PVPLC]));
			mvLoadFlag_PR = T;
			mDBG("[SYSMAC:PR]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_PR = F;
			mDBG("[SYSMAC: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_PVPLC]));
			mvLoadFlag_PID = T;
			mDBG("[SYSMAC:PID]:仮想実ﾀｸﾞ登録済み");
		}else{
			mvLoadFlag_PID = F;
			mDBG("[SYSMAC: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;
}

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