static void CreateHandles()
{
hWriteColumn = ads.CreateVariableHandle("MAIN.ExcelInfo.ColumnNumber");
hColumnName = ads.CreateVariableHandle("MAIN.ExcelInfo.ColumnName");
hReady = ads.CreateVariableHandle("MAIN.ExcelInfo.bReady");
hexcelpath = ads.CreateVariableHandle("MAIN.ExcelInfo.path");
}
public AdsKid(TcAdsClient MOM, int KidIndex)
{
LastPolled.Start();
if (!Connected)
{
try
{
this.Mom = MOM;
this.kidIndex = KidIndex;
TargetPosAddr = MOM.CreateVariableHandle("MAIN.Kid[" + kidIndex + "].targetpos_FromMom_Raw");
CurrentPosAddr = MOM.CreateVariableHandle("MAIN.Kid[" + kidIndex + "].HomedPosition_toMom");
ModeVelAddr = MOM.CreateVariableHandle("MAIN.Kid[" + kidIndex + "].ModeVel_FromMom");
ModeAccelAddr = MOM.CreateVariableHandle("MAIN.Kid[" + kidIndex + "].ModeAccel_FromMom");
ModeDecelAddr = MOM.CreateVariableHandle("MAIN.Kid[" + kidIndex + "].ModeDecel_FromMom");
DeadManPressedAddr = Mom.CreateVariableHandle("MAIN.Kid[" + KidIndex + "].RMT_DeadManPressed");
ScalingIntAddr = Mom.CreateVariableHandle("MAIN.Kid[" + KidIndex + "].ScalingNumber");
MomControlAddr = Mom.CreateVariableHandle("MAIN.Kid[" + KidIndex + "].CheckIn.MomControl");
string checkStr = MOM.ReadAny(TargetPosAddr, typeof(int)).ToString();
// TcAdsSymbolInfoLoader tcl = MOM.CreateSymbolInfoLoader();
// TcAdsSymbolInfo tci = tcl.FindSymbol("MAIN.Kid[" + KidIndex + "].SCALINGINT");
currentPosition = int.Parse(MOM.ReadAny(CurrentPosAddr, typeof(int)).ToString());
targetPosition = currentPosition;
Connected = true;
}
catch
{
Connected = false;
throw;
}
}
}
private void CreateHandles(TcAdsClient ads)
{
hDB = ads.CreateVariableHandle("MAIN.ConnectDB.DBInfo.MYSQLConnectionInfo.DB");
hServer = ads.CreateVariableHandle("MAIN.ConnectDB.DBInfo.MYSQLConnectionInfo.server");
hUser = ads.CreateVariableHandle("MAIN.ConnectDB.DBInfo.MYSQLConnectionInfo.user");
hPassword = ads.CreateVariableHandle("MAIN.ConnectDB.DBInfo.MYSQLConnectionInfo.password");
}
private void SQLLiveDataDump()
{
int nVar = ReadNSqlTypes();
string queryF;
string query = "INSERT INTO " + SchemaName + "." + TableRT + " (";
//ManageTime
string date = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");
string queryT = "'" + date + "'";
var SQLList = GetPLCSymbolsLiveSQL();
//Get columns Names
string NameCol = string.Join(" , ", SQLList.ToArray());
string NameColClean = "RecordTime ," + cleaner(NameCol);
string queryN = NameColClean + ") VALUES ( ";
query += queryN + queryT;
foreach (string TagSQL in SQLList)
{
string value = adsClient.ReadAny(adsClient.CreateVariableHandle(TagSQL.ToString()), typeof(int)).ToString();
query += (", '" + value.ToString() + "' ");
}
queryF = query + ");";
insertinsql(queryF);
//listBoxDBLog.Items.Add("Row inserted with data from" +date);
}
private void buttonConnect_Click(object sender, EventArgs e)
{
// luodaan AdsClient-olio yhteyttä varten
adsClient = new TcAdsClient();
// otetaan yhteys TwinCAT PLC:hen portin 851 kautta
adsClient.Connect(851);
// luodaan PLC:n muuttujiin viittaavat "osoittimet"
startHandle = adsClient.CreateVariableHandle("MAIN.start");
stopHandle = adsClient.CreateVariableHandle("MAIN.reset");
// Luodaan tapahtumankäsittelijä. Parametrina näyttöä päivittävän metodin nimi
adsClient.AdsNotification += new AdsNotificationEventHandler(UpdateVariables);
// avataan Ads-stream (luettava byte-määrä pitänee antaa parametrina
this.adsStream = new AdsStream(24);
binReader = new BinaryReader(this.adsStream);
/*
* timeHi: UDINT; // aika
* timeLo: UDINT; // aika
* measurement1: REAL; // mittaus 1
* measurement2: REAL; // mittaus 2
* measurement3: REAL; // mittaus 3
* counter: INT; // juokseva numero
* arrayValue: INT; // jotain
* */
measurementDataHandle = adsClient.AddDeviceNotification("MAIN.measurementData", this.adsStream, 0, 24,
AdsTransMode.Cyclic, 100, 0, null);
buttonConnect.Enabled = false;
buttonSetSR1.Enabled = true;
buttonResetSR1.Enabled = false;
}
/// <summary>
/// 写单个D-INT(PLC定义的INT和DINT类型)
/// </summary>
/// <param name="socket"></param>
/// <param name="address">地址格式(MAIN.dint1 (MAIN目录标签 ,dint1在MAIN这个目录定义的dint1这个名)) </param>
/// <param name="values">数值</param>
/// <returns></returns>
public bool WriteSingleIntD(TcAdsClient tac, string address, int values)
{
try
{
int NUMBER = tac.CreateVariableHandle(address);
tac.WriteAny(tac.CreateVariableHandle(address), values);
return(true);
}
catch
{
return(false);
}
}
public bool ReadBool(string pou, string variableName)
{
try
{
var hVar = _tcClient.CreateVariableHandle(pou + "." + variableName);
var readVariable = _tcClient.ReadAny(hVar, typeof(bool));
_tcClient.DeleteVariableHandle(hVar);
return(bool.Parse(readVariable.ToString()));
}
catch (AdsErrorException)
{
Debug.LogError("TC Read Error - Bool" + pou + "." + variableName);
return(false);
}
}
/**
* Reads one variable from the PLC. The variable must be declared as a REAL.
*
* Input:
* tcAds - TwinCat ADS client object
* var - The variable name (as a string) to be read from the PLC. E.g "MAIN.var1"
* vartype - The variable type as declared in the PLC. REAL is the only supported variable type.
* More types can be added by making changes where appropriate.
*
* Output: Floating value representing the value in the PLC.
*
**/
static float readByString(TcAdsClient tcAds, string var, string vartype)
{
int hVar = 0;
try
{
hVar = tcAds.CreateVariableHandle(var);
}
catch (Exception err)
{
Console.WriteLine(err);
}
if (vartype == "REAL")
{
// creates a stream with a length of 4 byte
AdsStream ds = new AdsStream(4);
BinaryReader br = new BinaryReader(ds);
tcAds.Read(hVar, ds);
try
{
tcAds.DeleteVariableHandle(hVar);
}
catch (Exception err)
{
Console.WriteLine(err);
}
return(br.ReadSingle());
}
else
{
Console.WriteLine("Error: Variable type not implemented!");
return(0.0F);
}
}
//TcAdsClient tcClient = new TcAdsClient();
//AdsStream dataStream = new AdsStream(4);
//AdsBinaryReader binReader = new AdsBinaryReader(dataStream);
public bool writeToPLCInt(string sName, int iValue)
{
TcAdsClient tcClient = new TcAdsClient();
AdsStream dataStream = new AdsStream(4);
AdsBinaryReader binReader = new AdsBinaryReader(dataStream);
int iHandle = 0;
tcClient.Connect(851);
iHandle = tcClient.CreateVariableHandle(sName);
try
{
tcClient.WriteAny(iHandle, iValue);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
tcClient.DeleteVariableHandle(iHandle);
tcClient.Dispose();
}
return(true);
}
public bool writeToPLCString(string sName, string sValue)
{
bool bret = true;
TcAdsClient tcClient = new TcAdsClient();
AdsStream dataStream = new AdsStream(100);
AdsBinaryReader binReader = new AdsBinaryReader(dataStream);
int iHandle = 0;
tcClient.Connect(851);
iHandle = tcClient.CreateVariableHandle(sName);
try
{
tcClient.WriteAnyString(iHandle, sValue, sValue.Length, Encoding.Default);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
bret = false;
}
finally
{
tcClient.DeleteVariableHandle(iHandle);
tcClient.Dispose();
}
return(bret);
}
public static void WriteBusQueue(List <string> list)
{
try
{
WriteTwincat("GVL.EraseTable", true);
TcAdsClient client = new TcAdsClient();
client.Connect(amsnetid, Convert.ToInt32(amsnetport));
int handle = client.CreateVariableHandle("GVL.DataFromBus");
foreach (string el in list)
{
AdsStream stream = new AdsStream(500);
AdsBinaryWriter writer = new AdsBinaryWriter(stream);
writer.WritePlcString(el, 500, Encoding.Unicode);
client.Write(handle, stream);
stream.Dispose();
writer.Dispose();
Thread.Sleep(10);
}
client.DeleteVariableHandle(handle);
client.Dispose();
}
catch (Exception ex)
{
Console.WriteLine("BusWrite: " + ex.Message);
}
}
public int GetHandle(string name)
{
if (IsConnected() == false)
{
throw new Exception("ADS connection is not established in UlTcAdsClient::GetHandle");
}
lock (criticalLock)
{
if (handles.ContainsKey(name) == false)
{
try
{
int handle = client.CreateVariableHandle(name);
handles.Add(name, handle);
}
catch (Exception e)
{
string str = string.Format("Occurred exception({0}) in UlTcAdsClient::GetHandle", e.ToString());
throw new Exception(str);
}
}
}
return(handles[name]);
}
public bool IsHeartBeatAlive()
{
try
{
AdsStream dataStream = new AdsStream(4);
AdsBinaryReader binReader = new AdsBinaryReader(dataStream);
int iHandle = 0;
int iValue = 0;
iHandle = _tcAds.CreateVariableHandle("TwinCAT_SystemInfoVarList._AppInfo.OnlineChangeCnt");
_tcAds.Read(iHandle, dataStream);
iValue = binReader.ReadInt32();
dataStream.Position = 0;
if (iValue != _onlineChangeCount)
{
_onlineChangeCount = iValue;
isHierarchieLoaded = false;
}
}
catch (Exception e)
{
DiagnosticWindow.AddToDebug(e.Message);
return(false);
}
return(true);
}
public void ConnectPLC()
{
adsClient = new TcAdsClient();
AMSNETID = Config.Instance.AMSNETID;
PORT = Config.Instance.port;
try
{
adsClient.Connect(AMSNETID, PORT);
ReceiceHandle = adsClient.CreateVariableHandle(Config.Instance.ReceiceHandle);
SendHandle = adsClient.CreateVariableHandle(Config.Instance.SendHandle);
timer1.Enabled = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public bool GetSmokeFlag()
{
try
{
int handle_g_SetState = tcclient.CreateVariableHandle("MAIN.smokeFlag");
AdsStream dataStream = new AdsStream(1);
BinaryReader binRead = new BinaryReader(dataStream);
tcclient.Read(handle_g_SetState, dataStream);
dataStream.Position = 0;
smokeflag = binRead.ReadBoolean();
}
catch (Exception)
{
MessageBox.Show("ADS read value smokeFlag error");
}
return(smokeflag);
}
private void DateTime_Load(object sender, EventArgs e)
{
CheckForIllegalCrossThreadCalls = false;
client = new TcAdsClient();
client.Connect(851);
try
{
htime1 = client.CreateVariableHandle("MAIN.time1");
hdate1 = client.CreateVariableHandle("MAIN.date1");
hdate2 = client.CreateVariableHandle("MAIN.date2");
}
catch (Exception err)
{
MessageBox.Show("DateTime Form load " + err.Message);
}
}
private void Form1_Load(object sender, System.EventArgs e)
{
try
{
adsClient = new TcAdsClient();
// PLC1 Port - TwinCAT 3=851
adsClient.Connect(851);
intStart = adsClient.CreateVariableHandle("GVLLighting.StartLight");
intStop = adsClient.CreateVariableHandle("GVLLighting.StopLight");
intStatus = adsClient.CreateVariableHandle("GVLLighting.LightingStatus");
}
catch (Exception err)
{
MessageBox.Show(err.Message);
}
}
static void Main(string[] args)
{
TcAdsClient tcClient = new TcAdsClient();
AdsStream dataStream = new AdsStream(4);
AdsBinaryReader binReader = new AdsBinaryReader(dataStream);
int handle = 0;
int iValue = 0;
int exValue = 0;
string variable, adres;
DateTime now = DateTime.Now;
Console.WriteLine("Podaj adres serwera ADS: ");
adres = Console.ReadLine();
Console.WriteLine("Podaj nazwe zmienna do zapysywania w bazie danych: ");
variable = Console.ReadLine();
FileStream File = new FileStream("data.txt", FileMode.OpenOrCreate, FileAccess.Write);
StreamWriter writer = new StreamWriter(File);
writer.WriteLine(adres + " 801 " + variable + " " + now.ToString("F"));
try
{
tcClient.Connect(adres, 801);
handle = tcClient.CreateVariableHandle(variable);
Console.WriteLine("Czekam na znak");
do
{
tcClient.Read(handle, dataStream);
iValue = binReader.ReadInt32();
dataStream.Position = 0;
if (iValue != exValue)
{
writer.WriteLine(iValue + " " + now.ToString("F"));
}
Console.WriteLine("Aktualna wartosc wynosi: " + iValue);
exValue = iValue;
} while (Console.ReadKey().Key.Equals(ConsoleKey.Enter));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + " xdddd");
}
finally
{
writer.Close();
tcClient.DeleteVariableHandle(handle);
tcClient.Dispose();
}
Console.ReadKey();
}
public void WriteValue(X parameterName, object value, bool selfVerify = false)
{
var att = parameterName.GetAttribute <TypeAttribute>();
if (att.RWStatus == TypeAttribute.RW.ReadOnly)
{
return;
}
var pName = $"{att.SourceFunction}.{parameterName}";
var writeId = _tcClient.CreateVariableHandle(pName);
_tcClient.WriteAny(writeId, value);
_tcClient.DeleteVariableHandle(writeId);
if (selfVerify)
{
OnChange(parameterName);
}
}
/// <summary>
/// Subscribe to an observable and write the emitted values to a PLC variable
///
/// Use this method to regularly write values to PLC variable. For one-off writes, use the Write() method
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="variableName">Name of the PLC variable</param>
/// <param name="observable">Observable that emits values to write</param>
/// <param name="scheduler">Scheduler to execute the subscription on. By default uses the scheduler the Observable runs on</param>
/// <returns>An IDisposable that can be disposed when it's no longer desired to write the values in the observable</returns>
public IDisposable StreamTo <T>(string variableName, IObservable <T> observable, IScheduler scheduler = null)
{
scheduler = scheduler ?? Scheduler.Immediate;
int variableHandle = _client.CreateVariableHandle(variableName);
var subscription = observable.ObserveOn(scheduler).Subscribe(value => WriteWithHandle(variableHandle, value));
// Return an IDisposable that, when disposed, stops listening to the Observable but also deletes the variable handle
return(new CompositeDisposable(subscription, Disposable.Create(() => _client.DeleteVariableHandle(variableHandle))));
}
public async Task <T[]> ReadArray <T>(string PLCName, int size)
{
string plcname = "." + PLCName;
return(await Task.Run(() =>
{
try
{
int handle = Tcads.CreateVariableHandle(plcname);
T[] returnData = (T[])Tcads.ReadAny(handle, typeof(T[]), new int[] { size });
Tcads.DeleteVariableHandle(handle);
return returnData;
}
catch (Exception ex)
{
ErrorFile.ErrorLog(ex.Message, ADS.Logfilepath);
return default;
}
}));
}
/// <summary>
/// 写单个M-布尔(PLC定义的Bool类型)
/// </summary>
/// <param name="socket"></param>
/// <param name="address"></param>
/// <param name="values">值</param>
/// <returns></returns>
public bool WriteSingleBoolM(TcAdsClient tac, string address, int values)
{
try
{
tac.WriteAny(tac.CreateVariableHandle(address), values == 1 ? true : false);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// 读单个D-双精浮点数(PLC定义的LREAL类型)
/// </summary>
/// <param name="socket"></param>
/// <param name="address">地址格式(MAIN.dint1 (MAIN目录标签 ,dint1在MAIN这个目录定义的dint1这个名)) </param>
/// <returns></returns>
public Double ReadSingleDoubleD(TcAdsClient tac, string address)
{
try
{
int number = tac.CreateVariableHandle(address);
return(Convert.ToDouble(tac.ReadAny(number, typeof(Double))));
}
catch
{
return(-1);
}
}
/// <summary>
/// 读字符串-(PLC定义的STRING类型)
/// </summary>
/// <param name="socket"></param>
/// <param name="address">地址格式(MAIN.dint1 (MAIN目录标签 ,dint1在MAIN这个目录定义的dint1这个名)) </param>
/// <returns></returns>
public String ReadString(TcAdsClient tac, string address)
{
try
{
int number = tac.CreateVariableHandle(address);
return(tac.ReadAny(number, typeof(String), new int[] { 9999 }).ToString());
}
catch
{
return("");
}
}
/// <summary>
/// 写单个D-32位无符号整数(PLC定义的USINT类型)
/// </summary>
/// <param name="socket"></param>
/// <param name="address">地址格式(MAIN.dint1 (MAIN目录标签 ,dint1在MAIN这个目录定义的dint1这个名)) </param>
/// <param name="values">数值</param>
/// <returns></returns>
public bool WriteSingleUsintD(TcAdsClient tac, string address, int values)
{
try
{
tac.WriteAny(tac.CreateVariableHandle(address), Convert.ToByte(values));
return(true);
}
catch
{
return(false);
}
}
private void Form1_Load(object sender, EventArgs e)
{
adsClient = new TcAdsClient();
notificationHandles = new ArrayList();
try
{
adsClient.AdsNotificationEx += new AdsNotificationExEventHandler(adsClient_AdsNotificationEx);
button4.Enabled = false;
button6.Enabled = false;
adsClient.Connect(801);
hbool1 = adsClient.CreateVariableHandle("MAIN.bool1");
hint1 = adsClient.CreateVariableHandle("MAIN.int1");
hstr1 = adsClient.CreateVariableHandle("MAIN.str1");
hlreal1 = adsClient.CreateVariableHandle("MAIN.lreal1");
hcomplexStruct = adsClient.CreateVariableHandle("MAIN.ComplexStruct1");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// 写单个D-双精浮点数(PLC定义的LREAL类型)
/// </summary>
/// <param name="socket"></param>
/// <param name="address">地址格式(MAIN.dint1 (MAIN目录标签 ,dint1在MAIN这个目录定义的dint1这个名)) </param>
/// <param name="values">值</param>
/// <returns></returns>
public bool WriteSingleDoubleD(TcAdsClient tac, string address, double values)
{
try
{
tac.WriteAny(tac.CreateVariableHandle(address), values);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// 写字符串-(PLC定义的STRING类型)
/// </summary>
/// <param name="socket"></param>
/// <param name="address">地址格式(MAIN.dint1 (MAIN目录标签 ,dint1在MAIN这个目录定义的dint1这个名)) </param>
/// <param name="values">值</param>
/// <returns></returns>
public bool WriteString(TcAdsClient tac, string address, string values)
{
try
{
tac.WriteAny(tac.CreateVariableHandle(address), values, new int[] { values.Length });
return(true);
}
catch
{
return(false);
}
}
public void AddCoil(TwinCATCoil mTwinCATCoil)
{
if (mTwinCATCoil.CoilMode == TwinCATCoil.Mode.Read)
{
ToRead.Add(mTwinCATCoil);
}
else
{
ToNotice.Add(mTwinCATCoil);
}
try
{
mTwinCATCoil.CoilHandle = adsClient.CreateVariableHandle(mTwinCATCoil.CoilName);
}
catch (Exception ex)
{
Console.WriteLine(System.DateTime.Now.ToString() + " " + "变量" + mTwinCATCoil.CoilName + "失败");
Trace.Write(ex, "AddCoil");
}
mTwinCATCoil.CoilUpdate += mTwinCATCoil_CoilUpdate;
}
/// <summary>
/// 读单个D-32位无符号整数(PLC定义的USINT类型)
/// </summary>
/// <param name="socket"></param>
/// <param name="address">地址格式(MAIN.dint1 (MAIN目录标签 ,dint1在MAIN这个目录定义的dint1这个名)) </param>
/// <returns></returns>
public int ReadSingleUsintD(TcAdsClient tac, string address)
{
try
{
int number = tac.CreateVariableHandle(address);
return(Convert.ToInt32(tac.ReadAny(number, typeof(Byte))));
}
catch
{
return(-1);
}
}
/**
* Reads one variable from the PLC. The variable must be declared as a REAL.
*
* Input:
* tcAds - TwinCat ADS client object
* var - The variable name (as a string) to be read from the PLC. E.g "MAIN.var1"
* vartype - The variable type as declared in the PLC. REAL is the only supported variable type.
* More types can be added by making changes where appropriate.
*
* Output: Floating value representing the value in the PLC.
*
**/
static float readByString(TcAdsClient tcAds,string var,string vartype)
{
int hVar = 0;
try
{
hVar = tcAds.CreateVariableHandle(var);
}
catch (Exception err)
{
Console.WriteLine(err);
}
if (vartype == "REAL")
{
// creates a stream with a length of 4 byte
AdsStream ds = new AdsStream(4);
BinaryReader br = new BinaryReader(ds);
tcAds.Read(hVar, ds);
try
{
tcAds.DeleteVariableHandle(hVar);
}
catch (Exception err)
{
Console.WriteLine(err);
}
return br.ReadSingle();
}
else {
Console.WriteLine("Error: Variable type not implemented!");
return 0.0F;
}
}
public override void init()
{
adsClient = new TcAdsClient();
nameDict["MAIN.MDF_WhichStack"] = typeof(int);
nameDict["MAIN.MDF_WhichDish"] = typeof(int);
nameDict["MAIN.MDF_RunningError"] = typeof(int);
nameDict["MAIN.MDF_online_state"] = typeof(int);
nameDict["MAIN.MDF_Command_response"] = typeof(String);
nameDict["MAIN.MDF_bar_code"] = typeof(string);
nameDict["MAIN.MDF_Motor_1_cur"] = typeof(float);
nameDict["MAIN.MDF_Motor_2_cur"] = typeof(float);
nameDict["MAIN.MDF_Motor_3_cur"] = typeof(float);
nameDict["MAIN.MDF_Motor_4_cur"] = typeof(float);
nameDict["MAIN.CCS_to_MDF_command_listen"] = typeof(String);
nameDict["MAIN.CCS_to_MDF_NumsperStack_listen"] = typeof(int);
nameDict["MAIN.CCS_to_MDF_VolsperDish_listen"] = typeof(float);
cmdString = "MAIN.MDF_Command_response";
try
{
adsClient.Connect(801);
adsClient.AdsNotificationEx += new AdsNotificationExEventHandler(handleNotification);
foreach (String s in nameDict.Keys)
{
handleMap[s] = adsClient.CreateVariableHandle(s);
if (nameDict[s] == typeof(string))
{
adsClient.AddDeviceNotificationEx(s, AdsTransMode.OnChange, 100, 0, s, nameDict[s],new int[]{ConstSettings.StringLength});
}
else
{
adsClient.AddDeviceNotificationEx(s, AdsTransMode.OnChange, 100, 0, s, nameDict[s]);
}
}
adsClient.WriteAny(handleMap["MAIN.MDF_online_state"], 1);
}
catch (Exception ex)
{
}
}
public BeckHoff(TcAdsClient adsClient)
{
this.adsClient = adsClient;
foreach (String name in plcVariableNameTypes)
{
Type t = typeof(int);
if(name.StartsWith(BOOL_TOKON)){
t = typeof(Boolean);
}
String varName = name.Substring(1);
plcVariableNames.Add(varName);
plcVarTypeMap.Add(varName,t);
createPlcAccessHandle(varName);
}
mWriteFlagHandle = adsClient.CreateVariableHandle(".WriteFlag");
initThreadHold();
initVarDescription();
}
