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);
}
private void BtnRead_Click(object sender, EventArgs e)
{
stream = new AdsStream(4);
reader = new AdsBinaryReader(stream);
try
{
client.Read(htime1, stream);
txtTime.Text = (reader.ReadPlcTIME()).ToString();
stream.Position = 0;
client.Read(hdate1, stream);
txtDate.Text = reader.ReadPlcDATE().ToString();
stream.Position = 0;
client.Read(hdate2, stream);
txtDate2.Text = reader.ReadPlcDATE().ToString();
stream.Position = 0;
}
catch (Exception err)
{
MessageBox.Show("BtnRead " + err.Message);
}
}
/**
* 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 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);
}
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();
}
private void ReadElementToStream(string elementPath, AdsStream stream)
{
try
{
int handle = _twinCatClient.CreateVariableHandle(elementPath);
try
{
_twinCatClient.Read(handle, stream);
}
finally
{
_twinCatClient.DeleteVariableHandle(handle);
}
}
catch (AdsErrorException ex)
{
_logger.ErrorFormat("Could not read element on path '{0}' because of '{1}'.", elementPath, ex.ErrorCode);
throw;
}
}
private void button1_Click(object sender, EventArgs e)
{
lstArray.Items.Clear();
client.Read(hintArray, stream);
for (int i = 0; i < 10; i++)
{
lstArray.Items.Add(Reader.ReadInt16());
}
button1.Enabled = false;
// client.ReadAny(hdintArray1, typeof(int), new int[] { 40 });
//?? how to read DINT array from plc by ReadAny method ??
}
public int ReadInt(string VarAdress)
{
int result = 0;
try
{
hVar = TwinCat3Client.CreateVariableHandle(VarAdress);
AdsStream ADSdataStream = new AdsStream(4);
BinaryReader binRead = new BinaryReader(ADSdataStream);
TwinCat3Client.Read(hVar, ADSdataStream);
ADSdataStream.Position = 0;
result = binRead.ReadInt32();
TwinCat3Client.DeleteVariableHandle(hVar);
hVar = 0;
ADSdataStream.Dispose();
binRead.Dispose();
}
catch (Exception err)
{
MessageBox.Show(err.Message);
}
return(result);
}
//readlreal
private void button_Click(object sender, EventArgs e)
{
TwinCAT_ADS_LOAD();
try
{
hvar = tcclient.CreateVariableHandle("MAIN.adsstru.KL3068_Value_Ch1");
}
catch (Exception err)
{
MessageBox.Show("get hvar error \n" + err.ToString());
}
AdsStream datastream = new AdsStream(8);
BinaryReader binread = new BinaryReader(datastream);
datastream.Position = 0;
try
{
tcclient.Read(hvar, datastream);
readlreal = binread.ReadDouble();
textBox1.Text = readlreal.ToString("0.00");
textBox6.Text = Calc_temper(readlreal).ToString("0.00") + "度";
}
catch (Exception err)
{
MessageBox.Show("read value error");
}
try
{
tcclient.DeleteVariableHandle(hvar);
}
catch (Exception err)
{
MessageBox.Show("read delect hvar error");
}
}
/// <summary>
/// Parses an PLC array of type T. Supports pointered arrays (POINTER TO ...).
/// In case of pointered array it will skipp NULL pointers and import only valid instances.
/// </summary>
/// <param name="plcPath">The path in PLC to the array.</param>
/// <param name="twinCatClient">The adsClient instance.</param>
/// <param name="typeOfElements">Marshall type representation in .NET. See Beckhoff TwinCat 3 manual for an example.</param>
/// <returns>
/// Dictionary of imported and converted (.NET type) array elements and their pathes.
/// </returns>
public static IEnumerable GetArrayElements(this TcAdsClient twinCatClient, string plcPath, Type typeOfElements)
{
var elements = new ArrayList();
TcAdsSymbolInfoLoader symbolLoader = twinCatClient.CreateSymbolInfoLoader();
TcAdsSymbolInfo arraySymbol = symbolLoader.FindSymbol(plcPath);
if (arraySymbol == null)
{
return(elements);
}
var stream = new AdsStream(8);
var reader = new AdsBinaryReader(stream);
TcAdsSymbolInfo elementSymbol = arraySymbol.FirstSubSymbol;
while (elementSymbol != null)
{
stream.Position = 0;
twinCatClient.Read(elementSymbol.IndexGroup, elementSymbol.IndexOffset, stream);
var pointerValue = PlcSystem.IsX64Mode ? reader.ReadInt64() : reader.ReadInt32();
if (pointerValue != 0)
{
string plcArrayElementPath = elementSymbol.Name;
if (elementSymbol.IsPointer)
{
plcArrayElementPath = string.Format("{0}^", plcArrayElementPath);
}
var handle = twinCatClient.CreateVariableHandle(plcArrayElementPath);
try
{
object element = twinCatClient.ReadAny(handle, typeOfElements);
elements.Add(element);
}
finally
{
twinCatClient.DeleteVariableHandle(handle);
}
}
elementSymbol = elementSymbol.NextSymbol;
}
return(elements);
}
/// <summary>
/// Parses an PLC array of type T. Supports pointered arrays (POINTER TO ...).
/// In case of pointered array it will skipp NULL pointers and import only valid instances.
/// </summary>
/// <typeparam name="T">
/// Marshall type representation in .NET. See Beckhoff TwinCat 3 manual for an example.
/// </typeparam>
/// <param name="plcPath">The path in PLC to the array.</param>
/// <param name="symbolLoader">The symbol loader instance.</param>
/// <param name="twinCatClient">The adsClient instance.</param>
/// <returns>
/// Dictionary of imported and converted (.NET type) array elements and their pathes.
/// </returns>
public static IDictionary <string, T> GetArrayElementsWithPathes <T>(this TcAdsClient twinCatClient, TcAdsSymbolInfoLoader symbolLoader, string plcPath)
{
IDictionary <string, T> array = new Dictionary <string, T>();
TcAdsSymbolInfo arraySymbol = symbolLoader.FindSymbol(plcPath);
if (arraySymbol == null)
{
return(array);
}
var stream = new AdsStream(8);
var reader = new AdsBinaryReader(stream);
TcAdsSymbolInfo elementSymbol = arraySymbol.FirstSubSymbol;
while (elementSymbol != null)
{
stream.Position = 0;
twinCatClient.Read(elementSymbol.IndexGroup, elementSymbol.IndexOffset, stream);
var pointerValue = PlcSystem.IsX64Mode ? reader.ReadInt64() : reader.ReadInt32();
if (pointerValue != 0)
{
string plcArrayElementPath = elementSymbol.Name;
if (elementSymbol.IsPointer)
{
plcArrayElementPath = string.Format("{0}^", plcArrayElementPath);
}
var handle = twinCatClient.CreateVariableHandle(plcArrayElementPath);
try
{
var element = (T)twinCatClient.ReadAny(handle, typeof(T));
array.Add(plcArrayElementPath, element);
}
finally
{
twinCatClient.DeleteVariableHandle(handle);
}
}
elementSymbol = elementSymbol.NextSymbol;
}
return(array);
}
private void button1_Click(object sender, EventArgs e) //ReadButton
{
try
{
Form1_Load(sender, e);
AdsStream adsStream = new AdsStream(30);
AdsBinaryReader reader = new AdsBinaryReader(adsStream);
adsClient.Read(varHandle, adsStream);
textBox1.Text = reader.ReadPlcAnsiString(30).ToString();
adsClient.Dispose();
}
catch (Exception err)
{
MessageBox.Show(err.Message);
}
}
static int[] ReadTimeArray()
{
TimeSpan[] timearray = new TimeSpan[80];
int[] timearray_milisecounds = new int[80];
AdsStream adsStream = new AdsStream(4);
AdsBinaryReader reader = new AdsBinaryReader(adsStream);
for (int i = 0; i < timearray.Length; i++)
{
///AdsStream adsStream = new AdsStream(4);
//AdsBinaryReader reader = new AdsBinaryReader(adsStream);
adsStream.Position = 0;
hTimeArray = ads.CreateVariableHandle("MAIN.time_array[" + (i + 1) + "]");
ads.Read(hTimeArray, adsStream);
timearray[i] = reader.ReadPlcTIME();
timearray_milisecounds[i] = Convert.ToInt32(timearray[i].TotalMilliseconds);
}
return(timearray_milisecounds);
}
/// <summary>
/// Reads a pointer value of the specified <paramref name="typeOfValue"/>.
/// </summary>
/// <param name="twinCatClient">The twin cat client to read from.</param>
/// <param name="plcPath">The path in the PC to the element.</param>
/// <param name="typeOfValue">The expected type of the value.</param>
/// <returns>
/// The value of the element at the specified <paramref name="plcPath"/>.
/// </returns>
public static object GetPointerValue(this TcAdsClient twinCatClient, string plcPath, Type typeOfValue)
{
TcAdsSymbolInfoLoader symbolLoader = twinCatClient.CreateSymbolInfoLoader();
TcAdsSymbolInfo symbol = symbolLoader.FindSymbol(plcPath);
if (symbol == null)
{
return(null);
}
var stream = new AdsStream(8);
var reader = new AdsBinaryReader(stream);
stream.Position = 0;
twinCatClient.Read(symbol.IndexGroup, symbol.IndexOffset, stream);
var pointerValue = PlcSystem.IsX64Mode ? reader.ReadInt64() : reader.ReadInt32();
if (pointerValue != 0)
{
string plcArrayElementPath = symbol.Name;
if (symbol.IsPointer)
{
plcArrayElementPath = string.Format("{0}^", plcArrayElementPath);
}
var handle = twinCatClient.CreateVariableHandle(plcArrayElementPath);
try
{
return(twinCatClient.ReadAny(handle, typeOfValue));
}
finally
{
twinCatClient.DeleteVariableHandle(handle);
}
}
return(null);
}
private void UpdateSymbols()
{
try
{
// Read Loaded TcCOM
labelTcComStatus.Text = tcClient.ReadAnyString(tcCOM_indexGroup, tcCOM_indexOffset, 255, Encoding.Default);
// Read an UINT32 Value
tcClientTaskValues.Read(task_indexGroup, task_indexOffset, readStream, 0, 8);
readStream.Position = 0;
labelSignalValue.Text = reader.ReadDouble().ToString();
}
catch
{
MessageBox.Show("Correct symbols not accessible...");
if (_cts != null)
{
_cts.Cancel();
AdsDisconnect();
}
}
}
private void AdsReadFeedBack()
{
try
{
// Get the ADS return codes and examine for errors
AdsStream rdStream = new AdsStream(rdLength);
tcClient.Read(Group, objStatusWord_axis1, rdStream);
BinaryReader reader = new BinaryReader(rdStream);
// Read the data from the ADS stream
Statusword_axis1 = reader.ReadUInt16();
ModesOfOperationDisplay_axis1 = reader.ReadByte();
PositionActualValue_axis1 = reader.ReadInt32();
RealVelocityValue_axis1 = reader.ReadInt32();
FollowingErrorActualValue_axis1 = reader.ReadUInt16();
PositionDemandValue_axis1 = reader.ReadInt32();
// FollowingErrorActualValue_axis1 = reader.ReadUInt32();
}
catch (Exception err)
{
}
}
/// <summary>
/// Read item array from TwinCAT Variables
/// </summary>
/// <param name="name"></param>
/// <param name="type"></param>
/// <param name="arrLength"></param>
/// <returns></returns>
public object[] ReadArray(string name, string type, int arrLength)
{
object[] values = new object[arrLength];
int streamLength = StreamLength(type);
using (AdsStream dataStream = new AdsStream(arrLength * streamLength))
using (AdsBinaryReader reader = new AdsBinaryReader(dataStream))
{
int varHandle = TcClient.CreateVariableHandle(name);
TcClient.Read(varHandle, dataStream);
dataStream.Position = 0;
for (int i = 0; i < arrLength; i++)
{
values[i] = ReadObjectFromReader(reader, type);
}
TcClient.DeleteVariableHandle(varHandle);
}
return(values);
}
/// <summary>
/// Determines whether the specified twinCatClient client is connected and in running state.
/// </summary>
/// <param name="twinCatClient">The twin cat client.</param>
/// <returns>
/// <c>true</c> if the specified twin cat client is connected; otherwise, <c>false</c>.
/// </returns>
public static bool IsConnected(TcAdsClient twinCatClient)
{
var dataStream = new AdsStream(2);
try
{
twinCatClient.Read((int)AdsReservedIndexGroups.DeviceData,
(int)AdsReservedIndexOffsets.DeviceDataAdsState, dataStream);
var reader = new BinaryReader(dataStream);
var plcState = (AdsState)reader.ReadInt16();
if (plcState == AdsState.Run)
{
return(true);
}
return(false);
}
catch (AdsErrorException)
{
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;
}
}
public void Read(string name, TcReadHandler handler, int length, int position = 0)
{
int handle = GetHandle(name);
if (length < 1)
{
throw new Exception("Reading length must be over 0 in UlTcAdsClient::Read");
}
lock (criticalLock)
{
using (AdsStream stream = new AdsStream(length))
{
using (AdsBinaryReader reader = new AdsBinaryReader(stream))
{
try
{
client.Read(handle, stream);
stream.Position = position;
handler(reader);
}
catch (Exception e)
{
string str = string.Format("Occurred exception({0}) in UlTcAdsClient::Read", e.ToString());
throw new Exception(str);
}
}
}
}
}
public void ReadTagSynchronously(Tag tag)
{
tag.LockValue();
try
{
lock (_lock)
{
if (!_twinCatClient.IsConnected)
{
try
{
_twinCatClient.Connect(_adsAddress, _adsPort);
_twinCatClient.Timeout = Timeout;
}
catch (AdsException e)
{
throw new PlcCommunicationException("Can't read tag synchronously. Connection to PLC failed.", _adsAddress,
_adsPort.ToString(CultureInfo.InvariantCulture), string.Empty, e);
}
}
}
// try to read UDT
if (_udtHandler.ContainsKey(tag.DataType))
{
ReadUdt(tag);
return;
}
var dataStream = new AdsStream(tag.BitSize == 0 ? 81 : tag.BitSize / 8);
try
{
int handle = _twinCatClient.CreateVariableHandle(tag.FullName());
try
{
_twinCatClient.Read(handle, dataStream);
}
finally
{
_twinCatClient.DeleteVariableHandle(handle);
}
}
catch (AdsErrorException e)
{
throw new PlcCommunicationException("Can't read tag " + tag.FullName(), _adsAddress,
_adsPort.ToString(CultureInfo.InvariantCulture), string.Empty, e);
}
ParseValueFromStream(tag, dataStream);
}
catch (Exception e)
{
if (_logger != null)
{
_logger.Warn(tag.FullName() + " value change leaded to a unhandled exception", e);
}
var exception = new PlcCommunicationException("Can't read tag " + tag.FullName(), _adsAddress,
_adsPort.ToString(CultureInfo.InvariantCulture), string.Empty, e);
exception.Tag = tag;
throw exception;
}
finally
{
tag.ReleaseValue();
}
}
