/// <summary>
/// Gets the size in bytes of a <see cref="TagDataType"/> value.
/// </summary>
/// <param name="type">The tag type.</param>
/// <returns>
/// The size of the value in bytes.
/// </returns>
public static int GetSizeInBytes(TagDataType type)
{
switch (type)
{
case TagDataType.Byte:
case TagDataType.Ascii:
case TagDataType.Undefined:
case TagDataType.SByte:
return(1);
case TagDataType.Short:
case TagDataType.SShort:
return(2);
case TagDataType.Long:
case TagDataType.SLong:
case TagDataType.Float:
case TagDataType.IFD:
return(4);
case TagDataType.Rational:
case TagDataType.SRational:
case TagDataType.Double:
return(8);
default:
return(0);
}
}
public IFDEntry(ushort tag, TagDataType type, uint count, uint offset)
{
Tag = tag;
Type = type;
Count = count;
Offset = offset;
}
/// <summary>
/// Gets the length, in bytes, of a given TIFF tag datatype.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static int AtomicLength(this TagDataType type)
{
switch (type)
{
case TagDataType.ASCII:
case TagDataType.Byte:
case TagDataType.SByte:
case TagDataType.Undefined:
return(1);
case TagDataType.Short:
case TagDataType.SShort:
return(2);
case TagDataType.Float:
case TagDataType.Long:
case TagDataType.SLong:
case TagDataType.IFD:
return(4);
case TagDataType.Double:
case TagDataType.Rational:
case TagDataType.SRational:
return(8);
default:
throw new ArgumentException($"Unknown tag datatype {type}");
}
}
private byte getType(TagDataType type)
{
switch (type)
{
case TagDataType.Bool:
return(1);
case TagDataType.Byte:
return(3);
case TagDataType.Word:
return(4);
case TagDataType.Int:
return(5);
case TagDataType.Dword:
return(6);
case TagDataType.Dint:
return(7);
case TagDataType.Float:
return(8);
case TagDataType.CharArray:
return(19);
case TagDataType.LReal:
return(15);
default:
return(0);
}
}
public IFDEntry(ushort tag, TagDataType type, uint count, uint offset)
{
this.Tag = tag;
this.Type = type;
this.Count = count;
this.Offset = offset;
}
private void OK_Click(object sender, EventArgs e)
{
byte _bereich = (byte)((pNCK.bereich_u_einheit & 0xE0) >> 5); // (bereich_u_einheit & 2#11100000) schiebe rechts um 5 Bit
byte _einheit = (byte)(pNCK.bereich_u_einheit & 0x1F); // & 2#00011111
#region TYP
TagDataType dataType = new TagDataType();
int _ArraySize = 0;
switch (pNCK.typ)
{
case 1:
dataType = TagDataType.Bool;
break;
case 3:
dataType = TagDataType.Byte; //eNCK_LE_Int8;
break;
case 4:
dataType = TagDataType.Word;
break;
case 5:
dataType = TagDataType.Int; //eNCK_LE_Int16;
break;
case 6:
dataType = TagDataType.Dword; //eNCK_LE_Uint32;
break;
case 7:
dataType = TagDataType.Dint; //eNCK_LE_Int32;
break;
case 8:
dataType = TagDataType.Float; //eNCK_LE_Float32;
break;
case 15:
dataType = TagDataType.LReal; //eNCK_LE_Float64;
break;
case 19:
dataType = TagDataType.CharArray; //eNCK_LE_String;
_ArraySize = pNCK.laenge;
break;
default:
throw new Exception("Unknown Type");
break;
}
#endregion
_libnodavevalue = new PLCNckTag()
{
TagDataType = dataType, NckArea = _bereich, NckUnit = _einheit, NckColumn = (int)pNCK.spalte, NckLine = (int)pNCK.zeile, NckModule = pNCK.bausteintyp, NckLinecount = pNCK.ZEILENANZAHL, ArraySize = _ArraySize
};
this.Close();
}
/// <summary>
/// Determines whether the values fit in the offset field.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="count">The count.</param>
/// <returns>
/// <see langword="true"/> if the values fit in the offset field; otherwise, <see langword="false"/>.
/// </returns>
public static bool ValueFitsInOffsetField(TagDataType type, uint count)
{
switch (type)
{
case TagDataType.Byte:
case TagDataType.Ascii:
case TagDataType.Undefined:
case TagDataType.SByte:
return(count <= 4);
case TagDataType.Short:
case TagDataType.SShort:
return(count <= 2);
case TagDataType.Long:
case TagDataType.SLong:
case TagDataType.Float:
case TagDataType.IFD:
return(count == 1);
case TagDataType.Rational:
case TagDataType.SRational:
case TagDataType.Double:
default:
return(false);
}
}
public PLCTag(string address, TagDataType type) : base(address, type)
{
this._type = typeof(T);
if (this._type.IsEnum)
{
_underlyingType = Enum.GetUnderlyingType(this._type);
}
this._isStructType = this._type.IsValueType && !this._type.IsEnum && !this._type.IsPrimitive && this._type != typeof(decimal);
}
public DeviceTagParam(string tagPKNO, string tagCode, string tagName, string tagAddress, TagDataType tagDataType,
DataSimplingMode simplingMode, DeviceManager deviceManager)
{
PKNO = tagPKNO;
Handel = PKNO;
Code = tagCode;
Name = tagName;
Address = tagAddress;
DataType = tagDataType;
SimplingMode = simplingMode;
_DeviceManager = deviceManager;
}
public MetadataEntry(MetadataSection section, ushort tagId, TagDataType type, byte[] data)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
Section = section;
TagId = tagId;
Type = type;
this.data = (byte[])data.Clone();
}
/// <summary>
/// Gets the default format corresponding to the tag data type.
/// </summary>
public static TagFormat GetDefault(TagDataType dataType)
{
switch (dataType)
{
case TagDataType.Int64:
return(IntNumber);
case TagDataType.ASCII:
case TagDataType.Unicode:
return(String);
default:
return(FloatNumber);
}
}
/// <summary>
/// Determines whether the <see cref="TagDataType"/> is known to GDI+.
/// </summary>
/// <param name="type">The tag type.</param>
/// <returns>
/// <see langword="true"/> if the tag type is known to GDI+; otherwise, <see langword="false"/>.
/// </returns>
public static bool IsKnownToGDIPlus(TagDataType type)
{
switch (type)
{
case TagDataType.Byte:
case TagDataType.Ascii:
case TagDataType.Short:
case TagDataType.Long:
case TagDataType.Rational:
case TagDataType.Undefined:
case TagDataType.SLong:
case TagDataType.SRational:
return(true);
default:
return(false);
}
}
public static byte GetNckType(TagDataType type)
{
switch (type)
{
case TagDataType.Bool:
return(1);
case TagDataType.Byte:
return(3);
case TagDataType.Word:
return(4);
case TagDataType.Int:
return(5);
case TagDataType.Dword:
return(6);
case TagDataType.Dint:
return(7);
case TagDataType.Float:
return(8);
case TagDataType.DateTime:
return(14);
case TagDataType.LReal:
return(15);
case TagDataType.LInt:
return(18);
case TagDataType.String:
case TagDataType.CharArray:
return(19);
default:
return(0);
}
}
public PLCNckTag GetNckTag(int unit, int rowOffset)
{
//byte SYNTAX_ID = 0x82;
byte bereich_u_einheit = (byte)(this.Bereich_u_einheit + unit);
byte _bereich = (byte)((bereich_u_einheit & 0xE0) >> 5); // (bereich_u_einheit & 2#11100000) schiebe rechts um 5 Bit
byte _einheit = (byte)(bereich_u_einheit & 0x1F); // & 2#00011111
#region TYP
TagDataType dataType = new TagDataType();
int _ArraySize = 0;
switch (this.Typ)
{
case 1:
dataType = TagDataType.Bool;
break;
case 3:
dataType = TagDataType.Byte; //eNCK_LE_Int8;
break;
case 4:
dataType = TagDataType.Word;
break;
case 5:
dataType = TagDataType.Int; //eNCK_LE_Int16;
break;
case 6:
dataType = TagDataType.Dword; //eNCK_LE_Uint32;
break;
case 7:
dataType = TagDataType.Dint; //eNCK_LE_Int32;
break;
case 8:
dataType = TagDataType.Float; //eNCK_LE_Float32;
break;
case 15:
dataType = TagDataType.LReal; //eNCK_LE_Float64;
break;
case 18:
dataType = TagDataType.LInt; //eNCK_LE_Int64;
break;
case 19:
//if (_bereich == 2)// && NC_Var.bausteintyp == 0x7f)
// dataType = TagDataType.String; //eNCK_LE_String;
//else
dataType = TagDataType.CharArray; //eNCK_LE_String;
_ArraySize = this.Laenge;
break;
default:
throw new Exception("Unknown Type");
break;
}
#endregion
return(new PLCNckTag()
{
TagDataType = dataType, NckArea = _bereich, NckUnit = _einheit, NckColumn = (int)this.Spalte, NckLine = (int)this.Zeile + rowOffset, NckModule = this.Bausteintyp, NckLinecount = this.ZEILENANZAHL, ArraySize = _ArraySize
});
}
/// <summary>
/// Sets the tag data type.
/// </summary>
public DeviceTag SetDataType(TagDataType dataType)
{
DataType = dataType;
return(this);
}
/// <summary>
/// Loads a tag definition from the Redis database.
/// </summary>
/// <param name="historian">The Redis historian to load the tag from.</param>
/// <param name="tagId">The ID of the tag to load.</param>
/// <param name="cancellationToken">The cancellation token for the request.</param>
/// <returns>
/// A task that will return the loaded tag definition.
/// </returns>
internal static async Task <RedisTagDefinition> Load(RedisHistorian historian, string tagId, CancellationToken cancellationToken)
{
var values = await historian.Connection.GetDatabase().HashGetAllAsync(historian.GetKeyForTagDefinition(tagId)).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
string name = null;
string description = null;
string units = null;
TagDataType dataType = default(TagDataType);
string stateSet = null;
bool exceptionFilterEnabled = false;
TagValueFilterDeviationType exceptionFilterLimitType = default(TagValueFilterDeviationType);
double exceptionFilterLimit = 0;
TimeSpan exceptionFilterWindowSize = default(TimeSpan);
bool compressionFilterEnabled = false;
TagValueFilterDeviationType compressionFilterLimitType = default(TagValueFilterDeviationType);
double compressionFilterLimit = 0;
TimeSpan compressionFilterWindowSize = default(TimeSpan);
DateTime createdAt = DateTime.MinValue;
string creator = null;
DateTime modifiedAt = DateTime.MinValue;
string modifiedBy = null;
foreach (var item in values)
{
switch (item.Name.ToString())
{
case "NAME":
name = item.Value;
break;
case "DESC":
description = item.Value;
break;
case "UNITS":
units = item.Value;
break;
case "TYPE":
dataType = (TagDataType)((int)item.Value);
break;
case "SSET":
stateSet = item.Value;
break;
case "EXC_ENABLED":
exceptionFilterEnabled = Convert.ToBoolean((int)item.Value);
break;
case "EXC_LIMIT_TYPE":
exceptionFilterLimitType = (TagValueFilterDeviationType)((int)item.Value);
break;
case "EXC_LIMIT":
exceptionFilterLimit = (double)item.Value;
break;
case "EXC_WINDOW":
exceptionFilterWindowSize = TimeSpan.Parse(item.Value);
break;
case "COM_ENABLED":
compressionFilterEnabled = Convert.ToBoolean((int)item.Value);
break;
case "COM_LIMIT_TYPE":
compressionFilterLimitType = (TagValueFilterDeviationType)((int)item.Value);
break;
case "COM_LIMIT":
compressionFilterLimit = (double)item.Value;
break;
case "COM_WINDOW":
compressionFilterWindowSize = TimeSpan.Parse(item.Value);
break;
case "MD_CREATEDAT":
createdAt = new DateTime((long)item.Value, DateTimeKind.Utc);
break;
case "MD_CREATEDBY":
creator = item.Value;
break;
case "MD_MODIFIEDAT":
modifiedAt = new DateTime((long)item.Value, DateTimeKind.Utc);
break;
case "MD_MODIFIEDBY":
modifiedBy = item.Value;
break;
}
}
if (String.IsNullOrWhiteSpace(name))
{
name = tagId;
}
var settings = new TagSettings()
{
Name = name,
Description = description,
Units = units,
DataType = dataType,
StateSet = stateSet,
ExceptionFilterSettings = new TagValueFilterSettingsUpdate()
{
IsEnabled = exceptionFilterEnabled,
LimitType = exceptionFilterLimitType,
Limit = exceptionFilterLimit,
WindowSize = exceptionFilterWindowSize
},
CompressionFilterSettings = new TagValueFilterSettingsUpdate()
{
IsEnabled = compressionFilterEnabled,
LimitType = compressionFilterLimitType,
Limit = compressionFilterLimit,
WindowSize = compressionFilterWindowSize
}
};
var metadata = new TagMetadata(createdAt, creator, modifiedAt, modifiedBy);
var snapshotTask = LoadSnapshotValue(historian, tagId, cancellationToken);
var lastArchivedTask = LoadLastArchivedValue(historian, tagId, cancellationToken);
var archiveCandidateTask = LoadArchiveCandidateValue(historian, tagId, cancellationToken);
await Task.WhenAll(snapshotTask, lastArchivedTask, archiveCandidateTask).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
var initialValues = new InitialTagValues(snapshotTask.Result, lastArchivedTask.Result, archiveCandidateTask.Result.Value, archiveCandidateTask.Result.CompressionAngleMinimum, archiveCandidateTask.Result.CompressionAngleMaximum);
var result = new RedisTagDefinition(historian,
tagId,
settings,
metadata,
initialValues,
null);
return(result);
}
public MetadataEntry(MetadataKey key, TagDataType type, byte[] data)
: this(key.Section, key.TagId, type, data)
{
}
public TagData(TagDataType type, decimal value)
{
this._type = type;
this._value = value;
}
private string GetValueStringFromOffset()
{
string valueString;
TagDataType type = entry.Type;
uint count = entry.Count;
uint offset = entry.Offset;
int typeSizeInBytes = TagDataTypeUtil.GetSizeInBytes(type);
if (typeSizeInBytes == 1)
{
byte[] bytes = new byte[count];
if (offsetIsBigEndian)
{
switch (count)
{
case 1:
bytes[0] = (byte)((offset >> 24) & 0x000000ff);
break;
case 2:
bytes[0] = (byte)((offset >> 24) & 0x000000ff);
bytes[1] = (byte)((offset >> 16) & 0x000000ff);
break;
case 3:
bytes[0] = (byte)((offset >> 24) & 0x000000ff);
bytes[1] = (byte)((offset >> 16) & 0x000000ff);
bytes[2] = (byte)((offset >> 8) & 0x000000ff);
break;
case 4:
bytes[0] = (byte)((offset >> 24) & 0x000000ff);
bytes[1] = (byte)((offset >> 16) & 0x000000ff);
bytes[2] = (byte)((offset >> 8) & 0x000000ff);
bytes[3] = (byte)(offset & 0x000000ff);
break;
}
}
else
{
switch (count)
{
case 1:
bytes[0] = (byte)(offset & 0x000000ff);
break;
case 2:
bytes[0] = (byte)(offset & 0x000000ff);
bytes[1] = (byte)((offset >> 8) & 0x000000ff);
break;
case 3:
bytes[0] = (byte)(offset & 0x000000ff);
bytes[1] = (byte)((offset >> 8) & 0x000000ff);
bytes[2] = (byte)((offset >> 16) & 0x000000ff);
break;
case 4:
bytes[0] = (byte)(offset & 0x000000ff);
bytes[1] = (byte)((offset >> 8) & 0x000000ff);
bytes[2] = (byte)((offset >> 16) & 0x000000ff);
bytes[3] = (byte)((offset >> 24) & 0x000000ff);
break;
}
}
if (type == TagDataType.Ascii)
{
valueString = Encoding.ASCII.GetString(bytes).TrimEnd('\0');
}
else if (count == 1)
{
valueString = bytes[0].ToString(CultureInfo.InvariantCulture);
}
else
{
StringBuilder builder = new StringBuilder();
uint lastItemIndex = count - 1;
for (int i = 0; i < count; i++)
{
builder.Append(bytes[i].ToString(CultureInfo.InvariantCulture));
if (i < lastItemIndex)
{
builder.Append(",");
}
}
valueString = builder.ToString();
}
}
else if (typeSizeInBytes == 2)
{
ushort[] values = new ushort[count];
if (offsetIsBigEndian)
{
switch (count)
{
case 1:
values[0] = (ushort)((offset >> 16) & 0x0000ffff);
break;
case 2:
values[0] = (ushort)((offset >> 16) & 0x0000ffff);
values[1] = (ushort)(offset & 0x0000ffff);
break;
}
}
else
{
switch (count)
{
case 1:
values[0] = (ushort)(offset & 0x0000ffff);
break;
case 2:
values[0] = (ushort)(offset & 0x0000ffff);
values[1] = (ushort)((offset >> 16) & 0x0000ffff);
break;
}
}
if (count == 1)
{
switch (type)
{
case TagDataType.SShort:
valueString = ((short)values[0]).ToString(CultureInfo.InvariantCulture);
break;
case TagDataType.Short:
default:
valueString = values[0].ToString(CultureInfo.InvariantCulture);
break;
}
}
else
{
switch (type)
{
case TagDataType.SShort:
valueString = ((short)values[0]).ToString(CultureInfo.InvariantCulture) + "," +
((short)values[1]).ToString(CultureInfo.InvariantCulture);
break;
case TagDataType.Short:
default:
valueString = values[0].ToString(CultureInfo.InvariantCulture) + "," +
values[1].ToString(CultureInfo.InvariantCulture);
break;
}
}
}
else
{
valueString = offset.ToString(CultureInfo.InvariantCulture);
}
return(valueString);
}
public unsafe byte[] GetValueBytesFromOffset()
{
if (!OffsetFieldContainsValue)
{
return(null);
}
TagDataType type = entry.Type;
uint count = entry.Count;
uint offset = entry.Offset;
// Paint.NET always stores data in little-endian byte order.
byte[] bytes;
if (type == TagDataType.Byte ||
type == TagDataType.Ascii ||
type == TagDataType.SByte ||
type == TagDataType.Undefined)
{
bytes = new byte[count];
if (offsetIsBigEndian)
{
switch (count)
{
case 1:
bytes[0] = (byte)((offset >> 24) & 0x000000ff);
break;
case 2:
bytes[0] = (byte)((offset >> 24) & 0x000000ff);
bytes[1] = (byte)((offset >> 16) & 0x000000ff);
break;
case 3:
bytes[0] = (byte)((offset >> 24) & 0x000000ff);
bytes[1] = (byte)((offset >> 16) & 0x000000ff);
bytes[2] = (byte)((offset >> 8) & 0x000000ff);
break;
case 4:
bytes[0] = (byte)((offset >> 24) & 0x000000ff);
bytes[1] = (byte)((offset >> 16) & 0x000000ff);
bytes[2] = (byte)((offset >> 8) & 0x000000ff);
bytes[3] = (byte)(offset & 0x000000ff);
break;
}
}
else
{
switch (count)
{
case 1:
bytes[0] = (byte)(offset & 0x000000ff);
break;
case 2:
bytes[0] = (byte)(offset & 0x000000ff);
bytes[1] = (byte)((offset >> 8) & 0x000000ff);
break;
case 3:
bytes[0] = (byte)(offset & 0x000000ff);
bytes[1] = (byte)((offset >> 8) & 0x000000ff);
bytes[2] = (byte)((offset >> 16) & 0x000000ff);
break;
case 4:
bytes[0] = (byte)(offset & 0x000000ff);
bytes[1] = (byte)((offset >> 8) & 0x000000ff);
bytes[2] = (byte)((offset >> 16) & 0x000000ff);
bytes[3] = (byte)((offset >> 24) & 0x000000ff);
break;
}
}
}
else if (type == TagDataType.Short || type == TagDataType.SShort)
{
int byteArrayLength = unchecked ((int)count) * sizeof(ushort);
bytes = new byte[byteArrayLength];
fixed(byte *ptr = bytes)
{
ushort *ushortPtr = (ushort *)ptr;
if (offsetIsBigEndian)
{
switch (count)
{
case 1:
ushortPtr[0] = (ushort)((offset >> 16) & 0x0000ffff);
break;
case 2:
ushortPtr[0] = (ushort)((offset >> 16) & 0x0000ffff);
ushortPtr[1] = (ushort)(offset & 0x0000ffff);
break;
}
}
else
{
switch (count)
{
case 1:
ushortPtr[0] = (ushort)(offset & 0x0000ffff);
break;
case 2:
ushortPtr[0] = (ushort)(offset & 0x0000ffff);
ushortPtr[1] = (ushort)((offset >> 16) & 0x0000ffff);
break;
}
}
}
}
else
{
bytes = new byte[4];
fixed(byte *ptr = bytes)
{
// The offset is stored as little-endian in memory.
*(uint *)ptr = offset;
}
}
return(bytes);
}
/// <summary>
/// インスタンスを初期化します。
/// </summary>
/// <param name="type">データ型。</param>
/// <param name="canEdit">編集可能な値ならば true。それ以外は false。</param>
internal TagInfo( TagDataType type, bool canEdit )
{
this.Type = type;
this.CanEdit = canEdit;
}
public PLCTag(string address, TagDataType type)
{
this.ChangeAddressFromString(address);
this.TagDataType = type;
}
