In References add COM Library 'CCHMIRUNTIME' (WinCC HMIRuntime 1.0 Type Library)

And below is my source what I use to read/write tags

using System;

using System.Collections.Generic;

using System.Text;

namespace HMI_Tool

{

#region CustomTag

public class CustomTag

{

public CustomTag(String TagName)

{

Runtime = new CCHMIRUNTIME.HMIRuntime();

Tag = Runtime.Tags[TagName];

Read();

}

public void Write(object Value)

{

lock (Locked)

{

Tag.Write(Value);

Read();

}

}

public object Read()

{

lock (Locked)

{

try

{

//while (Tag.QualityCode != 0x80)

//{

return Tag.Read();

//  System.Threading.Thread.Sleep(10);

//}

}

catch { }

//return new object();

return Tag.Read(CCHMIRUNTIME.HMIReadType.hmiReadCache);

}

}

private CCHMIRUNTIME.HMIRuntime Runtime { get; set; }

private CCHMIRUNTIME.IHMITag Tag { get; set; }

private object Locked = new object();

public string ErrorDescription

{

get

{

if (Tag != null) return Tag.ErrorDescription;

else return null;

}

}

public int LastError

{

get

{

if (Tag != null) return Tag.LastError;

else return 0;

}

}

public string Name

{

get

{

if (Tag != null) return Tag.Name;

else return null;

}

}

public int QualityCode

{

get

{

if (Tag != null) return Tag.QualityCode;

else return 0;

}

}

public object TimeStamp

{

get

{

if (Tag != null) return Tag.TimeStamp;

else return null;

}

}

public object Value

{

get

{

if (Tag != null) return Tag.Value;

else return null;

}

}

public String TypeOfValue

{

get

{

if (Tag != null)

{

if (Tag.Value == null) return "null";

else if (Tag.Value is Byte) return "Byte";

else if (Tag.Value is Boolean) return "Boolean";

else if (Tag.Value is Char) return "Char";

else if (Tag.Value is DateTime) return "DateTime";

else if (Tag.Value is Decimal) return "Decimal";

else if (Tag.Value is Double) return "Double";

else if (Tag.Value is Int16) return "Int16";

else if (Tag.Value is Int32) return "Int32";

else if (Tag.Value is Int64) return "Int64";

else if (Tag.Value is SByte) return "SByte";

else if (Tag.Value is Single) return "Single";

else if (Tag.Value is UInt16) return "UInt16";

else if (Tag.Value is UInt32) return "UInt32";

else if (Tag.Value is UInt64) return "UInt64";

else if (Tag.Value is bool) return "bool";

else if (Tag.Value is byte) return "byte";

else if (Tag.Value is char) return "char";

else if (Tag.Value is decimal) return "decimal";

else if (Tag.Value is double) return "double";

else if (Tag.Value is float) return "float";

else if (Tag.Value is int) return "int";

else if (Tag.Value is short) return "short";

else if (Tag.Value is string) return "String";

else if (Tag.Value is uint) return "uint";

}

return null;

}

}

}

#endregion

}

Hey there,

sure its possible to call the dmclient.dll functions from C#. For that you just only need two classes, a wrapper class and a holder class that is doing the function calls:

The wrapper:

public class dmClientDLLWrapper
{
/// <summary>
/// Struct for dmerror_enum (see dmclient.h)
/// </summary>
public enum MDM_DMERROR_ENUM
{
DM_E_OK = 0x00000000,
DM_E_CANCEL = 0x00000001,
DM_E_FILE = 0x00000002,
DM_E_UPDATE = 0x00000003,
DM_E_NO_RT_PRJ = 0x00000004,
DM_E_NOT_SUPPORTED = 0x00000005,
DM_E_ALREADY_CONNECTED = 0x00000006,
DM_E_NOT_CONNECTED = 0x00000007,
DM_E_INVALID_TAID = 0x00000008,
DM_E_INVALID_KEY = 0x00000009,
DM_E_INVALID_TYPE = 0x0000000A,
DM_E_MAX_LIMIT = 0x0000000B,
DM_E_MIN_LIMIT = 0x0000000C,
DM_E_MAX_RANGE = 0x0000000D,
DM_E_MIN_RANGE = 0x0000000E,
DM_E_ACCESS_FAULT = 0x0000000F,
DM_E_TIMEOUT = 0x00000010,
DM_E_ALREADY_EXIST = 0x00000011,
DM_E_PARAM = 0x00000012,
DM_E_INV_PRJ = 0x00000013,
DM_E_UNKNOWN = 0x00000014,
DM_E_OOM = 0x00000015,
DM_E_NOT_CREATED = 0x00000016,
DM_E_MACHINE_NOT_FOUND = 0x00000017,
DM_E_NO_INFO_FOUND = 0x00000018,
DM_E_INTERNAL = 0x00000019,
DM_E_INVALID_LOCALE = 0x0000001A,
DM_E_COMMUNICATION = 0x0000001B,
DM_E_DONT_EXIST = 0x0000001C,
DM_E_ALREADY_ACTIVATED = 0x0000001D,
DM_E_NO_OPEN_PROJECT = 0x0000001E,
DM_E_ALREADY_DEACTIVATED = 0x0000001F,
DM_E_NO_RIGHTS = 0x00000020,
DM_E_NOT_DELETED = 0x00000021,
DM_E_LICENSE = 0x00000022,
DM_E_LICENSE_LIMIT = 0x00000023,
DM_E_INVALID_OBJECTTYPE = 0x00000024,
DM_E_OP_REQUIERES_PRJEDITMODE = 0x00000025,
DM_E_INTERFACE = 0x00000026,
DM_E_UNIT_NOT_FOUND = 0x00000027,
DM_E_CONNECTION_NOT_FOUND = 0x00000028,

DM_E_NODEFAULTSERVER = 0x00000101,
DM_E_NOLOCALSERVER = 0x00000102,
DM_E_NOSERVER = 0x00000103,
DM_E_NOMC = 0x00000104,
DM_E_NOMCDEFAULTSERVER = 0x00000105,

DM_E_SYS_ERROR = 0x10000000
};

/// <summary>
/// Struct for error manclasses (see dmclient.h)
/// </summary>
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public class CMN_ERROR_MANCLASS
{
[MarshalAs(UnmanagedType.U4)]
public /*UInt32*/MDM_DMERROR_ENUM dwError1;

public UInt32 dwError2;
public UInt32 dwError3;
public UInt32 dwError4;
public UInt32 dwError5;

[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
public String szErrorText;
}

/// <summary>
/// Struct for the directory info (see dmclient.h)
/// </summary>
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DM_DIRECTORY_INFO
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string szProjectDir;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string szProjectAppDir;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string szGlobalLibDir;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string szProjectLibDir;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string szLokalProjectAppDir;
}

/// <summary>
/// Helper function for internal notification
/// </summary>
/// <param name="dwNotifyClass"></param>
/// <param name="dwNotifyCode"></param>
/// <param name="lpbyData"></param>
/// <param name="dwItems"></param>
/// <param name="lpvUser"></param>
/// <returns></returns>
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate bool DmNotifyProc(UInt32 dwNotifyClass,
UInt32 dwNotifyCode,
IntPtr lpbyData,
UInt32 dwItems,
IntPtr lpvUser);

/// <summary>
/// The connect function to connect to the so called "Data Manager"
/// </summary>
/// <param name="lpszAppName"></param>
/// <param name="lpfnNotify"></param>
/// <param name="lpvUser"></param>
/// <param name="lpdmError"></param>
/// <returns></returns>
[DllImport("dmclient.dll", EntryPoint = "DMConnectW", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Winapi)]
public static extern bool DMConnect([In] String lpszAppName,
[In] DmNotifyProc lpfnNotify,
[In] IntPtr lpvUser,
[In, Out] [MarshalAs(UnmanagedType.LPStruct)]
CMN_ERROR_MANCLASS lpdmError);


/// <summary>
/// Check the actual connection state to the "Data Manager"
/// </summary>
/// <param name="lpdmError"></param>
/// <returns></returns>
[DllImport("dmclient.dll", EntryPoint = "DMGetConnectionStateW", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Winapi)]
public static extern bool DMGetConnectionState([In, Out] [MarshalAs(UnmanagedType.LPStruct)]
CMN_ERROR_MANCLASS lpdmError);


/// <summary>
/// Get the actual runtime project file
/// </summary>
/// <param name="lpszProjectFile"></param>
/// <param name="dwBufSize"></param>
/// <param name="lpdmError"></param>
/// <returns></returns>
[DllImport("dmclient.dll", EntryPoint = "DMGetRuntimeProjectW", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]
public static extern bool DMGetRuntimeProject([Out] StringBuilder lpszProjectFile,
[In] Int32 dwBufSize,
[In, Out] [MarshalAs(UnmanagedType.LPStruct)]
CMN_ERROR_MANCLASS lpdmError);

/// <summary>
/// Get the project directory infos like the path and stuff
/// </summary>
/// <param name="lpszAppName"></param>
/// <param name="lpszProjectFile"></param>
/// <param name="lpdmDirInfo"></param>
/// <param name="lpdmError"></param>
/// <returns></returns>
[DllImport("dmclient.dll", EntryPoint = "DMGetProjectDirectoryW", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Winapi)]
public static extern bool DMGetProjectDirectory([In] String lpszAppName,
[In] String lpszProjectFile,
[In, Out] ref DM_DIRECTORY_INFO lpdmDirInfo,
[In, Out] [MarshalAs(UnmanagedType.LPStruct)] CMN_ERROR_MANCLASS lpdmError);
}
 

 And also the holder class:

class dmclientHolder
{
static DateTime localDate = DateTime.Now;

dmClientDLLWrapper.CMN_ERROR_MANCLASS err;
private static bool bRet;
private static StringBuilder projectFileBuffer;

/// <summary>
/// Constructor of the dmclientHolder that do the basic connection to the dmClientDLL
/// </summary>
public dmclientHolder()
{
err = new dmClientDLLWrapper.CMN_ERROR_MANCLASS();
bRet = dmClientDLLWrapper.DMConnect("Your app name", null, IntPtr.Zero, err);
bRet = dmClientDLLWrapper.DMGetConnectionState(err);
if (!bRet)
{
Console.WriteLine("DMConnect failed. Detailed message: " + err.szErrorText);
}
}

/// <summary>
/// Get the current runtime project of WinCC
/// </summary>
/// <returns></returns>
public string GetRuntimeProject()
{
int bufSize = 256;
projectFileBuffer = new StringBuilder(bufSize);
bRet = dmClientDLLWrapper.DMGetRuntimeProject(projectFileBuffer, bufSize, err);
if (bRet)
{
return projectFileBuffer.ToString();
}
else
{
return err.szErrorText;
}
}

/// <summary>
/// Get the current project directory of the current project running in WinCC
/// </summary>
/// <returns></returns>
public string GetProjectDirectory()
{
dmClientDLLWrapper.DM_DIRECTORY_INFO dminfo = new dmClientDLLWrapper.DM_DIRECTORY_INFO();
bRet = dmClientDLLWrapper.DMGetProjectDirectory("Your app name", projectFileBuffer.ToString(), ref dminfo, err);
if (bRet)
{
return dminfo.szProjectDir;
}
else
{
return err.szErrorText;
}
}
}

I'm sorry about the missing tabs in the code, the siemens page just deleted them in the code block... Anyway, hopefully this helps.

Greetings