/LibNoDaveConnectionLibrary/Communication/PLCTag.cs

http://siemensplctoolboxlib.codeplex.com · C# · 1955 lines · 1766 code · 106 blank · 83 comment · 449 complexity · 42a50eec8ae6be44ecb2180cf581f8cc MD5 · raw file 

    

  1. /*

    2. 

  2.  This implements a high level Wrapper between libnodave.dll and applications written

    3. 

  3.  in MS .Net languages.

    4. 

  4.  

    5. 

  5.  This ConnectionLibrary was written by Jochen Kuehner

    6. 

  6.  * http://jfk-solutuions.de/

    7. 

  7.  * 

    8. 

  8.  * Thanks go to:

    9. 

  9.  * Steffen Krayer -> For his work on MC7 decoding and the Source for his Decoder

    10. 

  10.  * Zottel         -> For LibNoDave

    11. 

  11. 

    12. 

  12.  WPFToolboxForSiemensPLCs is free software; you can redistribute it and/or modify

    13. 

  13.  it under the terms of the GNU Library General Public License as published by

    14. 

  14.  the Free Software Foundation; either version 2, or (at your option)

    15. 

  15.  any later version.

    16. 

  16. 

    17. 

  17.  WPFToolboxForSiemensPLCs is distributed in the hope that it will be useful,

    18. 

  18.  but WITHOUT ANY WARRANTY; without even the implied warranty of

    19. 

  19.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20. 

  20.  GNU General Public License for more details.

    21. 

  21. 

    22. 

  22.  You should have received a copy of the GNU Library General Public License

    23. 

  23.  along with Libnodave; see the file COPYING.  If not, write to

    24. 

  24.  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  

    25. 

  25. */

    26. 

  26. using System;

    27. 

  27. using System.Collections;

    28. 

  28. using System.Collections.Generic;

    29. 

  29. using System.ComponentModel;

    30. 

  30. using System.Globalization;

    31. 

  31. using System.Text;

    32. 

  32. using System.Text.RegularExpressions;

    33. 

  33. using System.Xml.Serialization;

    34. 

  34. using DotNetSiemensPLCToolBoxLibrary.Communication.LibNoDave;

    35. 

  35. using DotNetSiemensPLCToolBoxLibrary.DataTypes;

    36. 

  36. using DotNetSiemensPLCToolBoxLibrary.General;

    37. 

  37. using DotNetSiemensPLCToolBoxLibrary.PLCs.S7_xxx.MC7;

    38. 

  38. 

    39. 

  39. 

    40. 

  40. namespace DotNetSiemensPLCToolBoxLibrary.Communication

    41. 

  41. {

    42. 

  42. #if !IPHONE

    43. 

  43.     [System.ComponentModel.Editor(typeof(PLCTagUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))]

    44. 

  44. #endif

    45. 

  45. 	[Serializable]

    46. 

  46.     public class PLCTag: INotifyPropertyChanged

    47. 

  47.     {

    48. 

  48.         internal bool raiseValueChangedEvenWhenNoChangeHappened;

    49. 

  49. 

    50. 

  50.         private string _valueName;

    51. 

  51.         /// <summary>

    52. 

  52.         /// This is a Property wich addresses the values you've read with a Name

    53. 

  53.         /// </summary>        

    54. 

  54.         public String ValueName

    55. 

  55.         {

    56. 

  56.             get { return _valueName; }

    57. 

  57.             set { _valueName = value;

    58. 

  58.             NotifyPropertyChanged("ValueName");

    59. 

  59.             }

    60. 

  60.         }

    61. 

  61. 

    62. 

  62.         private int _byteAddress;

    63. 

  63.         public int ByteAddress

    64. 

  64.         {

    65. 

  65.             get { return _byteAddress; }

    66. 

  66.             set { _byteAddress = value;

    67. 

  67.             NotifyPropertyChanged("ByteAddress"); NotifyPropertyChanged("S7FormatAddress"); 

    68. 

  68.             }

    69. 

  69.         }

    70. 

  70. 

    71. 

  71.         private int _bitAddress;

    72. 

  72.         public int BitAddress

    73. 

  73.         {

    74. 

  74.             get { return _bitAddress; }

    75. 

  75.             set { _bitAddress = value;

    76. 

  76.                 _bitAddress = _bitAddress > 7 ? 7 : _bitAddress;

    77. 

  77.                 _bitAddress = _bitAddress < 0 ? 0 : _bitAddress;

    78. 

  78. 

    79. 

  79.             NotifyPropertyChanged("BitAddress"); NotifyPropertyChanged("S7FormatAddress"); 

    80. 

  80.             }

    81. 

  81.         }

    82. 

  82. 

    83. 

  83.         private bool isSymbolicAccessKeyTag;

    84. 

  84.         public bool IsSymbolicAccessKeyTag

    85. 

  85.         {

    86. 

  86.             get

    87. 

  87.             {

    88. 

  88.                 return this.isSymbolicAccessKeyTag;

    89. 

  89.             }

    90. 

  90.             set

    91. 

  91.             {

    92. 

  92.                 this.isSymbolicAccessKeyTag = value;

    93. 

  93.                 if (!value) 

    94. 

  94.                     symbolicAccessKey = null;

    95. 

  95. 

    96. 

  96.                 NotifyPropertyChanged("SymbolicAccessKey");

    97. 

  97.                 NotifyPropertyChanged("IsSymbolicAccessKeyTag");

    98. 

  98.                 NotifyPropertyChanged("S7FormatAddress"); 

    99. 

  99.             }

    100. 

  100.         }

    101. 

  101. 

    102. 

  102.         private string symbolicAccessKey;

    103. 

  103.         public string SymbolicAccessKey

    104. 

  104.         {

    105. 

  105.             get

    106. 

  106.             {

    107. 

  107.                 return this.symbolicAccessKey;

    108. 

  108.             }

    109. 

  109.             set

    110. 

  110.             {

    111. 

  111.                 this.symbolicAccessKey = value;

    112. 

  112.                 if (!string.IsNullOrEmpty(value)) 

    113. 

  113.                     isSymbolicAccessKeyTag = true;

    114. 

  114.                 NotifyPropertyChanged("SymbolicAccessKey");

    115. 

  115.                 NotifyPropertyChanged("IsSymbolicAccessKeyTag");

    116. 

  116.                 NotifyPropertyChanged("S7FormatAddress"); 

    117. 

  117.             }

    118. 

  118.         }

    119. 

  119. 

    120. 

  120.         //For Tags used with Full Symbolic in TIA Portal

    121. 

  121. 

    122. 

  122.         private bool _itemDoesNotExist;

    123. 

  123.         [XmlIgnore]

    124. 

  124.         public virtual bool ItemDoesNotExist

    125. 

  125.         {

    126. 

  126.             get { return _itemDoesNotExist; }

    127. 

  127.             set

    128. 

  128.             {

    129. 

  129.                 if (_itemDoesNotExist != value)

    130. 

  130.                 {

    131. 

  131.                     _itemDoesNotExist = value;

    132. 

  132.                     NotifyPropertyChanged("ItemDoesNotExist");

    133. 

  133.                     NotifyPropertyChanged("ValueAsString");

    134. 

  134.                 }

    135. 

  135.             }

    136. 

  136.         }

    137. 

  137. 

    138. 

  138.         public PLCTag()

    139. 

  139.         { }

    140. 

  140. 

    141. 

  141.         public PLCTag(PLCTag oldTag)

    142. 

  142.         {

    143. 

  143.             if (oldTag != null)

    144. 

  144.             {

    145. 

  145.                 this.TagDataSource = oldTag.TagDataSource;

    146. 

  146.                 this.TagDataType = oldTag.TagDataType;

    147. 

  147.                 this.ByteAddress = oldTag.ByteAddress;

    148. 

  148.                 this.BitAddress = oldTag.BitAddress;

    149. 

  149.                 this.ArraySize = oldTag.ArraySize;

    150. 

  150.                 this.DataTypeStringFormat = oldTag.DataTypeStringFormat;

    151. 

  151.                 this.DataBlockNumber = oldTag.DataBlockNumber;

    152. 

  152.                 this.Controlvalue = oldTag.Controlvalue;

    153. 

  153.                 this.DontSplitValue = oldTag.DontSplitValue;

    154. 

  154.             }

    155. 

  155.         }

    156. 

  156. 

    157. 

  157.         /// <summary>

    158. 

  158.         /// The initalizationString can be a PLC Address like: "DB100.DBW2" or a init String like: "User,DB100.DBW2,Word,Decimal"

    159. 

  159.         /// </summary>

    160. 

  160.         /// <param name="initalizationString"></param>

    161. 

  161.         public PLCTag(string initalizationString)

    162. 

  162.         {

    163. 

  163.             if (initalizationString.Contains(","))

    164. 

  164.             {

    165. 

  165.                 string[] values = initalizationString.Split(',');

    166. 

  166.                 this.ValueName = values[0];

    167. 

  167.                 this.ChangeAddressFromString(values[1]);

    168. 

  168.                 if (values.Length > 2) this.ChangeDataTypeFromString(values[2]);

    169. 

  169.                 if (values.Length > 3) this.ChangeDataTypeStringFormatFromString(values[3]);

    170. 

  170.             }

    171. 

  171.             else

    172. 

  172.             {

    173. 

  173.                 var low = initalizationString.ToLower();

    174. 

  174.                 if (low.StartsWith("p#"))

    175. 

  175.                 {

    176. 

  176.                     if (low.Contains("bool")) this.TagDataType = TagDataType.Bool;

    177. 

  177.                     else if (low.Contains("byte")) this.TagDataType = TagDataType.Byte;

    178. 

  178.                     else if (low.Contains("dword")) this.TagDataType = TagDataType.Dword;

    179. 

  179.                     else if (low.Contains("word")) this.TagDataType = TagDataType.Word;

    180. 

  180.                     else if (low.Contains("dint")) this.TagDataType = TagDataType.Dint;

    181. 

  181.                     else if (low.Contains("int")) this.TagDataType = TagDataType.Int;

    182. 

  182.                     else if (low.Contains("time_of_day")) this.TagDataType = TagDataType.TimeOfDay;                    

    183. 

  183.                     else if (low.Contains("date")) this.TagDataType = TagDataType.Date;

    184. 

  184.                     else if (low.Contains("s5time")) this.TagDataType = TagDataType.S5Time;

    185. 

  185.                     else if (low.Contains("real")) this.TagDataType = TagDataType.Float; 

    186. 

  186.                     else if (low.Contains("time")) this.TagDataType = TagDataType.Time;                    

    187. 

  187.                 }

    188. 

  188.                 this.ChangeAddressFromString(initalizationString);

    189. 

  189.             }

    190. 

  190.         }

    191. 

  191. 

    192. 

  192.         private int _datablockNumber = 1;

    193. 

  193.         public int DataBlockNumber

    194. 

  194.         {

    195. 

  195.             get

    196. 

  196.             {

    197. 

  197.                 if (this.TagDataSource == MemoryArea.Datablock || this.TagDataSource == MemoryArea.InstanceDatablock)

    198. 

  198.                     return _datablockNumber > 0 ? _datablockNumber : 1;

    199. 

  199.                 else

    200. 

  200.                     return 0;

    201. 

  201.             }

    202. 

  202.             set { _datablockNumber = value;

    203. 

  203.             NotifyPropertyChanged("DataBlockNumber"); NotifyPropertyChanged("S7FormatAddress"); 

    204. 

  204.             }

    205. 

  205.         }

    206. 

  206. 

    207. 

  207.         private MemoryArea tagDataSource = MemoryArea.Datablock;

    208. 

  208.         public MemoryArea TagDataSource

    209. 

  209.         {

    210. 

  210.             get

    211. 

  211.             {

    212. 

  212.                 return this.tagDataSource;

    213. 

  213.             }

    214. 

  214.             set

    215. 

  215.             {

    216. 

  216.                 this.tagDataSource = value;

    217. 

  217.                 if (value == MemoryArea.Timer || value == MemoryArea.Counter)

    218. 

  218.                     if (this.TagDataType != TagDataType.Bool && this.TagDataType != TagDataType.Int && this.TagDataType != TagDataType.Word && this.TagDataType != TagDataType.S5Time && this.TagDataType != TagDataType.BCDWord)

    219. 

  219.                         this.tagDataType = value == MemoryArea.Timer ? TagDataType.S5Time : TagDataType.Int;

    220. 

  220.                 NotifyPropertyChanged("TagDataSource"); NotifyPropertyChanged("S7FormatAddress"); 

    221. 

  221.             }

    222. 

  222.         }

    223. 

  223. 

    224. 

  224. 

    225. 

  225.         private TagDisplayDataType _dataTypeStringFormat = TagDisplayDataType.Bool;

    226. 

  226.         public TagDisplayDataType DataTypeStringFormat

    227. 

  227.         {

    228. 

  228.             get

    229. 

  229.             {

    230. 

  230.                 switch (this.TagDataType)

    231. 

  231.                 {

    232. 

  232.                     case TagDataType.Bool:

    233. 

  233.                         if (_dataTypeStringFormat != TagDisplayDataType.Bool && _dataTypeStringFormat != TagDisplayDataType.Binary)

    234. 

  234.                             return TagDisplayDataType.Bool;

    235. 

  235.                         return _dataTypeStringFormat;

    236. 

  236.                     case TagDataType.S5Time:

    237. 

  237.                     case TagDataType.Time:

    238. 

  238.                         if (_dataTypeStringFormat != TagDisplayDataType.TimeSpan && _dataTypeStringFormat != TagDisplayDataType.S5Time && _dataTypeStringFormat != TagDisplayDataType.Time)

    239. 

  239.                             return TagDisplayDataType.TimeSpan;

    240. 

  240.                         return _dataTypeStringFormat;

    241. 

  241.                     case TagDataType.Date:

    242. 

  242.                         if (_dataTypeStringFormat != TagDisplayDataType.DateTime && _dataTypeStringFormat != TagDisplayDataType.S7Date)

    243. 

  243.                             return TagDisplayDataType.S7Date;

    244. 

  244.                         return _dataTypeStringFormat;                    

    245. 

  245.                     case TagDataType.TimeOfDay:

    246. 

  246.                         if (_dataTypeStringFormat != TagDisplayDataType.DateTime && _dataTypeStringFormat != TagDisplayDataType.S7TimeOfDay)

    247. 

  247.                             return TagDisplayDataType.S7TimeOfDay;

    248. 

  248.                         return _dataTypeStringFormat;

    249. 

  249.                     case TagDataType.DateTime:

    250. 

  250.                         if (_dataTypeStringFormat != TagDisplayDataType.DateTime && _dataTypeStringFormat != TagDisplayDataType.S7DateTime)

    251. 

  251.                             return TagDisplayDataType.DateTime;

    252. 

  252.                         return _dataTypeStringFormat;

    253. 

  253.                     case TagDataType.String:

    254. 

  254.                     case TagDataType.CharArray:

    255. 

  255.                         return TagDisplayDataType.String;                        

    256. 

  256.                     case TagDataType.Int:

    257. 

  257.                     case TagDataType.Dint:

    258. 

  258.                     case TagDataType.Byte:

    259. 

  259.                     case TagDataType.SByte:

    260. 

  260.                     case TagDataType.Word:

    261. 

  261.                     case TagDataType.Dword:

    262. 

  262.                     case TagDataType.BCDByte:

    263. 

  263.                     case TagDataType.BCDWord:

    264. 

  264.                     case TagDataType.BCDDWord:

    265. 

  265.                         if (_dataTypeStringFormat != TagDisplayDataType.Decimal && _dataTypeStringFormat != TagDisplayDataType.Hexadecimal && _dataTypeStringFormat != TagDisplayDataType.Float && _dataTypeStringFormat != TagDisplayDataType.Binary && _dataTypeStringFormat != TagDisplayDataType.Pointer && _dataTypeStringFormat != TagDisplayDataType.String)

    266. 

  266.                             return TagDisplayDataType.Decimal;

    267. 

  267.                         return _dataTypeStringFormat;

    268. 

  268.                     case TagDataType.Float:

    269. 

  269.                         if (_dataTypeStringFormat != TagDisplayDataType.Decimal && _dataTypeStringFormat != TagDisplayDataType.Hexadecimal && _dataTypeStringFormat != TagDisplayDataType.Float && _dataTypeStringFormat != TagDisplayDataType.Binary)

    270. 

  270.                             return TagDisplayDataType.Float;

    271. 

  271.                         return _dataTypeStringFormat;

    272. 

  272.                     case TagDataType.ByteArray:

    273. 

  273.                         return TagDisplayDataType.ByteArray;

    274. 

  274.                 }

    275. 

  275.                 return TagDisplayDataType.Decimal;

    276. 

  276.             }

    277. 

  277.             set { _dataTypeStringFormat = value; NotifyPropertyChanged("DataTypeStringFormat"); NotifyPropertyChanged("Value"); NotifyPropertyChanged("ValueAsString"); }

    278. 

  278.         }

    279. 

  279. 

    280. 

  280.         private TagDataType tagDataType;

    281. 

  281.         public virtual TagDataType TagDataType

    282. 

  282.         {

    283. 

  283.             get

    284. 

  284.             {

    285. 

  285.                 return this.tagDataType;

    286. 

  286.             }

    287. 

  287.             set

    288. 

  288.             {

    289. 

  289.                 if (value == TagDataType.Struct)

    290. 

  290.                     return;

    291. 

  291.                 //if (value == TagDataType.DateTime)

    292. 

  292.                 //    ArraySize = 1;

    293. 

  293.                 else if (value != TagDataType.Bool)

    294. 

  294.                     _bitAddress = 0;

    295. 

  295.                 //else if (value == TagDataType.CharArray || value == TagDataType.ByteArray || value == TagDataType.String)

    296. 

  296.                 //    ArraySize = _internalGetSize();

    297. 

  297.                 if (this.tagDataSource == MemoryArea.Timer || this.tagDataSource == MemoryArea.Counter)

    298. 

  298.                 {

    299. 

  299.                     if (value != TagDataType.Bool && value != TagDataType.Int && value != TagDataType.Word && value != TagDataType.S5Time && value != TagDataType.BCDWord)

    300. 

  300.                         this.tagDataType = this.TagDataSource == MemoryArea.Timer ? TagDataType.S5Time : TagDataType.Int;

    301. 

  301.                     else

    302. 

  302.                         this.tagDataType = value;

    303. 

  303. 

    304. 

  304.                 }

    305. 

  305.                 else

    306. 

  306.                     this.tagDataType = value;

    307. 

  307.                 NotifyPropertyChanged("TagDataType");

    308. 

  308.                 NotifyPropertyChanged("S7FormatAddress");

    309. 

  309.                 NotifyPropertyChanged("DataTypeStringFormat");

    310. 

  310.                 NotifyPropertyChanged("ReadByteSize");

    311. 

  311.                 NotifyPropertyChanged("ArraySize");

    312. 

  312.             }

    313. 

  313.         }

    314. 

  314.         

    315. 

  315.         //For a List of old Values...

    316. 

  316.         protected List<Object> _oldvalues;

    317. 

  317.         [XmlIgnore]

    318. 

  318.         public List<Object> OldValues

    319. 

  319.         {

    320. 

  320.             get { return _oldvalues; }

    321. 

  321.         }

    322. 

  322. 

    323. 

  323.         protected int _backupvaluescount = 0;

    324. 

  324.         public int BackupValuesCount

    325. 

  325.         {

    326. 

  326.             get

    327. 

  327.             {

    328. 

  328.                 return _backupvaluescount;

    329. 

  329.             }

    330. 

  330.             set

    331. 

  331.             {

    332. 

  332.                 _backupvaluescount = value;

    333. 

  333.                 if (value > 0 && _oldvalues == null)

    334. 

  334.                     _oldvalues = new List<object>();

    335. 

  335.                 else if (value == 0)

    336. 

  336.                     _oldvalues = null;

    337. 

  337.                 NotifyPropertyChanged("BackupValuesCount");

    338. 

  338.             }

    339. 

  339.         }

    340. 

  340. 

    341. 

  341. 

    342. 

  342.         private bool _dontSplitValue = true;

    343. 

  343.         /// <summary>

    344. 

  344.         /// This Tag can not be splittet into more then one PDU (if there are a few rest Bytes in a PDU aviable)

    345. 

  345.         /// --> If this is set, the Tag is not allowed to be bigger!

    346. 

  346.         /// This bit should be set in all Tags wich are used for indirect Addressing! (Becaus eit could be you read 2 bytes of a double, then the value chages in the plc, then you read the rest!)

    347. 

  347.         /// This is also used when Writing the Value, and when set, it is not splitted. When the Value is bigger then a PDU, an error occurs

    348. 

  348.         /// </summary>

    349. 

  349.         public virtual bool DontSplitValue

    350. 

  350.         {

    351. 

  351.             get { return _dontSplitValue; }

    352. 

  352.             set { _dontSplitValue = value; NotifyPropertyChanged("DontSplitValue"); }

    353. 

  353.         }

    354. 

  354. 

    355. 

  355.         private int _arraySize = 1;

    356. 

  356.         /// <summary>

    357. 

  357.         /// Only valid (and used!) with String, CharArray and ByteArray Type!

    358. 

  358.         /// </summary>

    359. 

  359.         public int ArraySize

    360. 

  360.         {

    361. 

  361.             get

    362. 

  362.             {

    363. 

  363.                 //if (TagDataType== TagDataType.String || TagDataType==TagDataType.CharArray|| TagDataType==TagDataType.ByteArray)

    364. 

  364.                 

    365. 

  365.                 return _arraySize; 

    366. 

  366.                 //return 1;

    367. 

  367.             }

    368. 

  368.             set

    369. 

  369.             {

    370. 

  370.                 _arraySize = value == 0 ? 1 : value;

    371. 

  371.                 NotifyPropertyChanged("ArraySize");

    372. 

  372.                 NotifyPropertyChanged("S7FormatAddress");

    373. 

  373.                 NotifyPropertyChanged("ReadByteSize");

    374. 

  374.             }

    375. 

  375.         }

    376. 

  376. 

    377. 

  377. 

    378. 

  378. 

    379. 

  379.         #region Read Write Value of the TAG

    380. 

  380.         /// <summary>

    381. 

  381.         /// Helper Property to Set the Value, because the Setter of the normal Value Sets Control Value!

    382. 

  382.         /// </summary>

    383. 

  383.         protected internal virtual Object _setValueProp

    384. 

  384.         {

    385. 

  385.             set

    386. 

  386.             {

    387. 

  387.                 _value = value;

    388. 

  388. 

    389. 

  389.                 if (_value == null)

    390. 

  390.                 {

    391. 

  391.                     NotifyPropertyChanged("Value");

    392. 

  392.                     NotifyPropertyChanged("ValueAsString");

    393. 

  393.                     

    394. 

  394.                     if (ValueChanged != null) ValueChanged(this, new ValueChangedEventArgs(_oldvalue, _value));

    395. 

  395. 

    396. 

  396.                     _oldvalue = _value;

    397. 

  397.                 }

    398. 

  398.                 else

    399. 

  399.                 {

    400. 

  400.                     if (!_value.Equals(_oldvalue) || raiseValueChangedEvenWhenNoChangeHappened)

    401. 

  401.                     {

    402. 

  402.                         NotifyPropertyChanged("Value");

    403. 

  403.                         NotifyPropertyChanged("ValueAsString");

    404. 

  404. 

    405. 

  405.                         if (ValueChanged != null) ValueChanged(this, new ValueChangedEventArgs(_oldvalue, _value));

    406. 

  406. 

    407. 

  407.                         if (MaximumReached != null && _value is IComparable && ((IComparable)_value).CompareTo(Maximum) >= 0) MaximumReached(this, new LimitReachedEventArgs(_oldvalue, Maximum));

    408. 

  408. 

    409. 

  409.                         if (MinimumReached != null && _value is IComparable && ((IComparable)_value).CompareTo(Minimum) <= 0) MinimumReached(this, new LimitReachedEventArgs(_oldvalue, Minimum));

    410. 

  410. 

    411. 

  411.                         _oldvalue = _value;

    412. 

  412.                     }

    413. 

  413. 

    414. 

  414.                     if (BackupValuesCount > 0 && _oldvalues != null)

    415. 

  415.                     {

    416. 

  416.                         _oldvalues.Add(_value);

    417. 

  417.                         if (_oldvalues.Count - _backupvaluescount > 0) _oldvalues.RemoveRange(0, _oldvalues.Count - _backupvaluescount);

    418. 

  418.                         NotifyPropertyChanged("OldValues");

    419. 

  419.                     }

    420. 

  420.                 }

    421. 

  421. 

    422. 

  422. 

    423. 

  423.             }

    424. 

  424.         }

    425. 

  425. 

    426. 

  426.         protected Object _value;

    427. 

  427.         private Object _oldvalue;

    428. 

  428.         /// <summary>

    429. 

  429.         /// Value of the Tag. The Setter of this Property sets Controlvalue, because the Tag firstly got this Value when it's written!

    430. 

  430.         /// </summary>

    431. 

  431.         public virtual Object Value

    432. 

  432.         {

    433. 

  433.             get { return _value; }

    434. 

  434.             set

    435. 

  435.             {

    436. 

  436.                 if (_controlvalue == null || !_controlvalue.Equals(value))

    437. 

  437.                 {

    438. 

  438.                     _controlvalue = value;

    439. 

  439.                     NotifyPropertyChanged("Controlvalue");

    440. 

  440.                 }

    441. 

  441.             }

    442. 

  442.         }

    443. 

  443. 

    444. 

  444.         public void ClearValue()

    445. 

  445.         {

    446. 

  446.             _value = null;

    447. 

  447.             _oldvalue = null;

    448. 

  448.         }

    449. 

  449. 

    450. 

  450.         [XmlIgnore]

    451. 

  451.         public String ValueAsString

    452. 

  452.         {

    453. 

  453.             get { return GetValueAsString(); }

    454. 

  454.             set

    455. 

  455.             {

    456. 

  456.                 ParseControlValueFromString((String) value);

    457. 

  457.                 NotifyPropertyChanged("ControlValueAsString");    

    458. 

  458.             }

    459. 

  459.         }

    460. 

  460. 

    461. 

  461.         protected Object _controlvalue;

    462. 

  462.         public virtual Object Controlvalue

    463. 

  463.         {

    464. 

  464.             get { return _controlvalue; }

    465. 

  465.             set

    466. 

  466.             {

    467. 

  467.                 if (_controlvalue == null || !_controlvalue.Equals(value))

    468. 

  468.                 {

    469. 

  469.                     _controlvalue = value;

    470. 

  470.                     //_oldvalue = null;

    471. 

  471.                     NotifyPropertyChanged("Controlvalue");

    472. 

  472.                     NotifyPropertyChanged("ControlValueAsString");    

    473. 

  473.                 }

    474. 

  474.             }

    475. 

  475.         }

    476. 

  476. 

    477. 

  477.         [XmlIgnore]

    478. 

  478.         public String ControlValueAsString

    479. 

  479.         {

    480. 

  480.             get { return Controlvalue != null ? GetValueAsString(_controlvalue) : null; }

    481. 

  481.             set

    482. 

  482.             {

    483. 

  483.                 ParseControlValueFromString((String)value);

    484. 

  484.                 NotifyPropertyChanged("ControlValueAsString");

    485. 

  485.             }

    486. 

  486.         }

    487. 

  487. 

    488. 

  488.         #endregion

    489. 

  489. 

    490. 

  490.         [XmlIgnore]

    491. 

  491.         public string S7FormatAddress

    492. 

  492.         {

    493. 

  493.             get

    494. 

  494.             {

    495. 

  495.                 int aksz = _internalGetSize();

    496. 

  496.                 StringBuilder ret = new StringBuilder();

    497. 

  497. 

    498. 

  498.                 if (aksz == 3 || (aksz > 4 && this.TagDataSource != MemoryArea.Timer && this.TagDataSource != MemoryArea.Counter))

    499. 

  499.                     ret.Append("P#");

    500. 

  500. 

    501. 

  501.                 if (this.TagDataSource == MemoryArea.Datablock || this.TagDataSource == MemoryArea.InstanceDatablock)

    502. 

  502.                 {

    503. 

  503.                     if (this.TagDataSource == MemoryArea.InstanceDatablock)

    504. 

  504.                         ret.Append("DI");

    505. 

  505.                     else

    506. 

  506.                         ret.Append("DB");

    507. 

  507.                     ret.Append(this.DataBlockNumber);

    508. 

  508.                     ret.Append(".");

    509. 

  509.                     if (this.TagDataSource == MemoryArea.InstanceDatablock)

    510. 

  510.                         ret.Append("DI");

    511. 

  511.                     else

    512. 

  512.                         ret.Append("DB");

    513. 

  513.                     if (this.TagDataType == TagDataType.Bool || aksz == 3 || aksz > 4)

    514. 

  514.                         ret.Append("X");

    515. 

  515.                 }

    516. 

  516. 

    517. 

  517.                 switch (this.TagDataSource)

    518. 

  518.                 {

    519. 

  519.                     case MemoryArea.Inputs:

    520. 

  520.                         ret.Append("E");

    521. 

  521.                         break;

    522. 

  522.                     case MemoryArea.Outputs:

    523. 

  523.                         ret.Append("A");

    524. 

  524.                         break;

    525. 

  525.                     case MemoryArea.Flags:

    526. 

  526.                         ret.Append("M");

    527. 

  527.                         break;

    528. 

  528.                     case MemoryArea.Timer:

    529. 

  529.                         ret.Append("T");

    530. 

  530.                         break;

    531. 

  531.                     case MemoryArea.Counter:

    532. 

  532.                         ret.Append("Z");

    533. 

  533.                         break;

    534. 

  534.                     case MemoryArea.LocalData:

    535. 

  535.                         ret.Append("L");

    536. 

  536.                         break;

    537. 

  537.                     case MemoryArea.PreviousLocalData:

    538. 

  538.                         ret.Append("V");

    539. 

  539.                         break;

    540. 

  540.                 }

    541. 

  541. 

    542. 

  542.                 if (this.TagDataType == TagDataType.Bool && ArraySize < 2)

    543. 

  543.                 {

    544. 

  544.                     ret.Append(ByteAddress);

    545. 

  545.                     if (this.TagDataSource != MemoryArea.Timer && this.TagDataSource != MemoryArea.Counter)

    546. 

  546.                     {

    547. 

  547.                         ret.Append(".");

    548. 

  548.                         ret.Append(BitAddress);

    549. 

  549.                     }

    550. 

  550.                 }

    551. 

  551.                 else if (this.TagDataSource != MemoryArea.Counter && this.TagDataSource != MemoryArea.Timer)

    552. 

  552.                 {

    553. 

  553. 

    554. 

  554.                     if (aksz == 3 || aksz > 4)

    555. 

  555.                     {

    556. 

  556.                         ret.Append(ByteAddress);

    557. 

  557.                         ret.Append(".");

    558. 

  558.                         ret.Append(BitAddress);

    559. 

  559.                         ret.Append(" BYTE ");

    560. 

  560.                         ret.Append(_internalGetSize().ToString());

    561. 

  561.                     }

    562. 

  562.                     else if (aksz == 4)

    563. 

  563.                     {

    564. 

  564.                         ret.Append("D");

    565. 

  565.                         ret.Append(ByteAddress);

    566. 

  566.                     }

    567. 

  567.                     else if (aksz == 1)

    568. 

  568.                     {

    569. 

  569.                         ret.Append("B");

    570. 

  570.                         ret.Append(ByteAddress);

    571. 

  571.                     }

    572. 

  572.                     else

    573. 

  573.                     {

    574. 

  574.                         ret.Append("W");

    575. 

  575.                         ret.Append(ByteAddress);

    576. 

  576.                     }

    577. 

  577.                 }

    578. 

  578.                 else

    579. 

  579.                 {

    580. 

  580.                     ret.Append(ByteAddress);

    581. 

  581.                 }

    582. 

  582. 

    583. 

  583.                 if (isSymbolicAccessKeyTag)

    584. 

  584.                 {

    585. 

  585.                     ret.Append(" (" + symbolicAccessKey + ")");

    586. 

  586.                 }

    587. 

  587. 

    588. 

  588.                 return ret.ToString();

    589. 

  589.             }

    590. 

  590. 

    591. 

  591.             set

    592. 

  592.             {

    593. 

  593.                 ChangeAddressFromString(value);     

    594. 

  594.                 NotifyPropertyChanged("SymbolicAccessKey"); 

    595. 

  595.                 NotifyPropertyChanged("S7FormatAddress"); 

    596. 

  596.                 NotifyPropertyChanged("ReadByteSize"); 

    597. 

  597.                 NotifyPropertyChanged("ArraySize");

    598. 

  598.             }

    599. 

  599.         }

    600. 

  600. 

    601. 

  601.         public string GetControlValueAsString()

    602. 

  602.         {

    603. 

  603.             return GetValueAsString(this.Controlvalue);

    604. 

  604.         }

    605. 

  605. 

    606. 

  606.         public void ParseControlValueFromString(string myValue)

    607. 

  607.         {

    608. 

  608.             string myValueStrip = myValue.ToLower().Trim();

    609. 

  609.             switch (this.TagDataType)

    610. 

  610.             {

    611. 

  611.                 case TagDataType.S5Time:

    612. 

  612.                 case TagDataType.Time:

    613. 

  613.                     if (myValueStrip.Contains("t#") || myValueStrip.Contains("s5t#"))

    614. 

  614.                     {

    615. 

  615.                         Controlvalue = Helper.GetTimespanFromS5TimeorTime(myValue);

    616. 

  616.                     }

    617. 

  617.                     else

    618. 

  618.                     {

    619. 

  619.                         TimeSpan ret;

    620. 

  620.                         TimeSpan.TryParse(myValue, out ret);

    621. 

  621.                         Controlvalue = ret;

    622. 

  622.                     }                        

    623. 

  623.                     break;

    624. 

  624.                 case TagDataType.BCDWord:                

    625. 

  625.                 case TagDataType.Int:

    626. 

  626.                     if (myValueStrip.Contains("w#16#") || myValueStrip.Contains("dw#16#"))

    627. 

  627.                     {

    628. 

  628.                         Controlvalue = Convert.ToInt16(Helper.GetIntFromHexString(myValue));

    629. 

  629.                     }

    630. 

  630.                     else if (myValue.StartsWith("2#"))

    631. 

  631.                     {

    632. 

  632.                         Controlvalue = Convert.ToInt16(Helper.GetIntFromBinString(myValue));

    633. 

  633.                     }

    634. 

  634.                     else

    635. 

  635.                     {

    636. 

  636.                         Int16 ret;

    637. 

  637.                         Int16.TryParse(myValue, out ret);

    638. 

  638.                         Controlvalue = ret;

    639. 

  639.                     }

    640. 

  640.                     break;

    641. 

  641.                 case TagDataType.BCDDWord:

    642. 

  642.                 case TagDataType.Dint:

    643. 

  643.                     if (myValueStrip.Contains("w#16#") || myValueStrip.Contains("dw#16#"))

    644. 

  644.                         Controlvalue = Convert.ToInt32(Helper.GetIntFromHexString(myValue));

    645. 

  645.                     else if (myValue.StartsWith("2#"))

    646. 

  646.                         Controlvalue = Convert.ToInt32(Helper.GetIntFromBinString(myValue));

    647. 

  647.                     else

    648. 

  648.                         try

    649. 

  649.                         {

    650. 

  650.                             if (!string.IsNullOrEmpty(myValue))

    651. 

  651.                                 Controlvalue = Int32.Parse(myValue);

    652. 

  652.                         } catch (Exception) {}

    653. 

  653.                     break;                

    654. 

  654.                 case TagDataType.Byte:

    655. 

  655.                     if (myValueStrip.Contains("w#16#") || myValueStrip.Contains("dw#16#"))

    656. 

  656.                     {

    657. 

  657.                         Controlvalue = Convert.ToByte(Helper.GetUIntFromHexString(myValue));

    658. 

  658.                     }

    659. 

  659.                     else if (myValue.StartsWith("2#"))

    660. 

  660.                     {

    661. 

  661.                         Controlvalue = Convert.ToByte(Helper.GetIntFromBinString(myValue));

    662. 

  662.                     }

    663. 

  663.                     else

    664. 

  664.                     {

    665. 

  665.                         Byte ret;

    666. 

  666.                         Byte.TryParse(myValue, out ret);

    667. 

  667.                         Controlvalue = ret;

    668. 

  668.                     }

    669. 

  669.                     break;

    670. 

  670.                 case TagDataType.BCDByte:

    671. 

  671.                 case TagDataType.SByte:

    672. 

  672.                     if (myValueStrip.Contains("w#16#") || myValueStrip.Contains("dw#16#"))

    673. 

  673.                     {

    674. 

  674.                         Controlvalue = Convert.ToSByte(Helper.GetIntFromHexString(myValue));

    675. 

  675.                     }

    676. 

  676.                     else if (myValue.StartsWith("2#"))

    677. 

  677.                     {

    678. 

  678.                         Controlvalue = Convert.ToSByte(Helper.GetIntFromBinString(myValue));

    679. 

  679.                     }

    680. 

  680.                     else

    681. 

  681.                     {

    682. 

  682.                         SByte ret;

    683. 

  683.                         SByte.TryParse(myValue, out ret);

    684. 

  684.                         Controlvalue = ret;

    685. 

  685.                     }

    686. 

  686.                     break;                               

    687. 

  687.                 case TagDataType.Word:

    688. 

  688.                     if (myValueStrip.Contains("w#16#") || myValueStrip.Contains("dw#16#"))

    689. 

  689.                     {

    690. 

  690.                         Controlvalue = Convert.ToUInt16(Helper.GetUIntFromHexString(myValue));

    691. 

  691.                     }

    692. 

  692.                     else if (myValue.StartsWith("2#"))

    693. 

  693.                     {

    694. 

  694.                         Controlvalue = Convert.ToUInt16(Helper.GetIntFromBinString(myValue));

    695. 

  695.                     }

    696. 

  696.                     else

    697. 

  697.                     {

    698. 

  698.                         UInt16 ret;

    699. 

  699.                         UInt16.TryParse(myValue, out ret);

    700. 

  700.                         Controlvalue = ret;

    701. 

  701.                     }

    702. 

  702.                     break;                              

    703. 

  703.                 case TagDataType.Dword:

    704. 

  704.                     if (myValueStrip.Contains("w#16#") || myValueStrip.Contains("dw#16#"))

    705. 

  705.                     {

    706. 

  706.                         Controlvalue = Convert.ToUInt32(Helper.GetUIntFromHexString(myValue));

    707. 

  707.                     }

    708. 

  708.                     else if (myValue.StartsWith("2#"))

    709. 

  709.                     {

    710. 

  710.                         Controlvalue = Convert.ToUInt32(Helper.GetIntFromBinString(myValue));

    711. 

  711.                     }

    712. 

  712.                     else

    713. 

  713.                     {

    714. 

  714.                         UInt32 ret;

    715. 

  715.                         UInt32.TryParse(myValue, out ret);

    716. 

  716.                         Controlvalue = ret;

    717. 

  717.                     }

    718. 

  718.                     break;

    719. 

  719.                 case TagDataType.Bool:

    720. 

  720.                     if (myValue=="1")

    721. 

  721.                         Controlvalue = true;

    722. 

  722.                     else if (myValue=="0")

    723. 

  723.                         Controlvalue = false;

    724. 

  724.                     else

    725. 

  725.                     {

    726. 

  726.                         bool bvalue;

    727. 

  727.                         bool.TryParse(myValue, out bvalue);

    728. 

  728.                         Controlvalue = bvalue;

    729. 

  729.                     }

    730. 

  730.                     break;

    731. 

  731.                 case TagDataType.String:

    732. 

  732.                 case TagDataType.CharArray:

    733. 

  733.                     Controlvalue = myValue;

    734. 

  734.                     break;             

    735. 

  735.                 case TagDataType.DateTime:            

    736. 

  736.                 case TagDataType.Date:

    737. 

  737.                 case TagDataType.TimeOfDay:

    738. 

  738.                     if (myValueStrip.StartsWith("d#"))

    739. 

  739.                         Controlvalue = Helper.GetDateTimeFromDateString(myValue);

    740. 

  740.                     else if (myValueStrip.StartsWith("tod#"))

    741. 

  741.                         Controlvalue = Helper.GetDateTimeFromTimeOfDayString(myValue);

    742. 

  742.                     else if (myValueStrip.StartsWith("dt#"))

    743. 

  743.                         Controlvalue = Helper.GetDateTimeFromDateAndTimeString(myValue);

    744. 

  744.                     else if (!string.IsNullOrEmpty(myValue))

    745. 

  745.                         try

    746. 

  746.                         {

    747. 

  747.                             if (!string.IsNullOrEmpty(myValue))

    748. 

  748.                                 Controlvalue = DateTime.Parse(myValue);

    749. 

  749.                         }

    750. 

  750.                         catch (Exception) { }

    751. 

  751.                     break;

    752. 

  752.                 case TagDataType.ByteArray:

    753. 

  753.                     {

    754. 

  754.                         if (myValueStrip.Length > 2 && myValueStrip[0] == '{' && myValueStrip[myValueStrip.Length - 1] == '}')

    755. 

  755.                             myValueStrip = myValueStrip.Substring(1, myValueStrip.Length - 2);

    756. 

  756.                         string[] vals = myValueStrip.Split(',');

    757. 

  757.                         byte[] wrt = new byte[vals.Length];

    758. 

  758.                         int i = 0;

    759. 

  759. 

    760. 

  760.                         foreach (string val in vals)

    761. 

  761.                         {

    762. 

  762.                             try

    763. 

  763.                             {

    764. 

  764.                                 wrt[i++] = Convert.ToByte(val);

    765. 

  765.                             }

    766. 

  766.                             catch (Exception)

    767. 

  767.                             { }

    768. 

  768.                         }

    769. 

  769.                         Controlvalue = wrt;

    770. 

  770.                     }

    771. 

  771.                     break;

    772. 

  772.                 case TagDataType.Float:

    773. 

  773.                     {

    774. 

  774.                         Single val;

    775. 

  775.                         Controlvalue = Single.TryParse(myValue, out val);

    776. 

  776.                         Controlvalue = val;

    777. 

  777.                     }

    778. 

  778.                     break;

    779. 

  779. /* 

    780. 

  780.  *  case TagDataType.TimeOfDay:    

    781. 

  781.     case TagDataType.Float:

    782. 

  782.     */

    783. 

  783.             }

    784. 

  784.         }

    785. 

  785. 

    786. 

  786.         private string GetValueAsString(object myValue)

    787. 

  787.         {

    788. 

  788.             if (myValue != null)

    789. 

  789.             {

    790. 

  790.                 switch (this.TagDataType)

    791. 

  791.                 {

    792. 

  792.                     case TagDataType.String:

    793. 

  793.                     case TagDataType.CharArray:

    794. 

  794.                         return myValue.ToString();

    795. 

  795.                     case TagDataType.ByteArray:

    796. 

  796.                         {

    797. 

  797.                             StringBuilder sb = new StringBuilder();

    798. 

  798.                             sb.Append("{");

    799. 

  799.                             foreach (Byte bt in ((System.Byte[])myValue))

    800. 

  800.                             {

    801. 

  801.                                 if (sb.Length > 1) sb.Append(";");

    802. 

  802.                                 sb.Append(bt.ToString());

    803. 

  803.                             }

    804. 

  804.                             sb.Append("}");

    805. 

  805.                             return sb.ToString();

    806. 

  806.                         }

    807. 

  807. 

    808. 

  808.                     case TagDataType.S5Time:

    809. 

  809.                     case TagDataType.Time:

    810. 

  810.                     case TagDataType.Bool:

    811. 

  811.                     case TagDataType.DateTime:

    812. 

  812.                     case TagDataType.Date:

    813. 

  813.                     case TagDataType.TimeOfDay:

    814. 

  814.                     case TagDataType.Int:

    815. 

  815.                     case TagDataType.Dint:

    816. 

  816.                     case TagDataType.Byte:

    817. 

  817.                     case TagDataType.SByte:

    818. 

  818.                     case TagDataType.Word:

    819. 

  819.                     case TagDataType.Dword:

    820. 

  820.                     case TagDataType.Float:

    821. 

  821.                     case TagDataType.BCDByte:

    822. 

  822.                     case TagDataType.BCDWord:

    823. 

  823.                     case TagDataType.BCDDWord:

    824. 

  824.                         if (ArraySize < 2)

    825. 

  825.                         {

    826. 

  826.                             return this.GetValueAsStringInternal(myValue);

    827. 

  827.                         }

    828. 

  828.                         else

    829. 

  829.                         {

    830. 

  830.                             string ret = "";

    831. 

  831.                             var ienumer = myValue as IEnumerable;

    832. 

  832.                             if (ienumer != null)

    833. 

  833.                             {

    834. 

  834.                                 var enumer = ienumer.GetEnumerator();

    835. 

  835.                                 for (int i = 0; i < ArraySize; i++)

    836. 

  836.                                 {

    837. 

  837.                                     if (enumer.MoveNext())

    838. 

  838.                                     {

    839. 

  839.                                         if (ret != "") ret += ";";

    840. 

  840.                                         ret += this.GetValueAsStringInternal(enumer.Current);

    841. 

  841.                                     }

    842. 

  842.                                 }

    843. 

  843.                                 return ret;

    844. 

  844.                             }

    845. 

  845.                         }

    846. 

  846.                         break;

    847. 

  847.                 }

    848. 

  848.             }

    849. 

  849. 

    850. 

  850.             return "";

    851. 

  851.         }

    852. 

  852. 

    853. 

  853. 

    854. 

  854.         private string GetValueAsStringInternal(object myValue)

    855. 

  855.         {

    856. 

  856.             if (myValue != null)

    857. 

  857.             {

    858. 

  858.                 switch (this.TagDataType)

    859. 

  859.                 {

    860. 

  860.                     case TagDataType.S5Time:

    861. 

  861.                         {

    862. 

  862.                             if (DataTypeStringFormat == TagDisplayDataType.S5Time)

    863. 

  863.                             {

    864. 

  864.                                 var bt = new byte[2];

    865. 

  865.                                 libnodave.putS5Timeat(bt, 0, (TimeSpan)myValue);

    866. 

  866.                                 return Helper.GetS5Time(bt[0], bt[1]);

    867. 

  867.                             }

    868. 

  868.                             return ((TimeSpan)myValue).ToString();

    869. 

  869.                         }

    870. 

  870.                     case TagDataType.Time:

    871. 

  871.                         {

    872. 

  872.                             var tm = (TimeSpan)myValue;

    873. 

  873.                             var ret = new StringBuilder("T#");

    874. 

  874.                             if (tm.TotalMilliseconds < 0) ret.Append("-");

    875. 

  875.                             if (tm.Days != 0) ret.Append(tm.Days + "D");

    876. 

  876.                             if (tm.Hours != 0) ret.Append(tm.Hours + "H");

    877. 

  877.                             if (tm.Minutes != 0) ret.Append(tm.Minutes + "M");

    878. 

  878.                             if (tm.Seconds != 0) ret.Append(tm.Seconds + "S");

    879. 

  879.                             if (tm.Milliseconds != 0) ret.Append(tm.Milliseconds + "MS");

    880. 

  880.                             return ret.ToString();

    881. 

  881.                         }                                         

    882. 

  882.                     case TagDataType.Bool:

    883. 

  883.                         if (DataTypeStringFormat == TagDisplayDataType.Binary)

    884. 

  884.                         {

    885. 

  885.                             if (((bool)myValue) == true)

    886. 

  886.                                 return "1";

    887. 

  887.                             return "0";

    888. 

  888.                         }

    889. 

  889.                         return myValue.ToString();

    890. 

  890.                     case TagDataType.DateTime:

    891. 

  891.                     case TagDataType.Date:

    892. 

  892.                     case TagDataType.TimeOfDay:

    893. 

  893.                         if (DataTypeStringFormat == TagDisplayDataType.S7DateTime)

    894. 

  894.                         {

    895. 

  895.                             DateTime ak = (DateTime) myValue;

    896. 

  896.                             StringBuilder sb = new StringBuilder();

    897. 

  897.                             sb.Append("DT#");

    898. 

  898.                             sb.Append(ak.Year.ToString().Substring(2));

    899. 

  899.                             sb.Append("-");

    900. 

  900.                             sb.Append(ak.Month);

    901. 

  901.                             sb.Append("-");

    902. 

  902.                             sb.Append(ak.Day);

    903. 

  903.                             sb.Append("-");

    904. 

  904.                             sb.Append(ak.Hour);

    905. 

  905.                             sb.Append(":");

    906. 

  906.                             sb.Append(ak.Minute);

    907. 

  907.                             sb.Append(":");

    908. 

  908.                             sb.Append(ak.Second);

    909. 

  909.                             sb.Append(".");

    910. 

  910.                             sb.Append(ak.Millisecond.ToString().PadRight(3, '0'));

    911. 

  911.                             return sb.ToString();

    912. 

  912.                         }

    913. 

  913.                         else if (DataTypeStringFormat == TagDisplayDataType.S7Date)

    914. 

  914.                         {

    915. 

  915.                             DateTime ak = (DateTime)myValue;

    916. 

  916.                             StringBuilder sb = new StringBuilder();

    917. 

  917.                             sb.Append("D#");

    918. 

  918.                             sb.Append(ak.Year);

    919. 

  919.                             sb.Append("-");

    920. 

  920.                             sb.Append(ak.Month);

    921. 

  921.                             sb.Append("-");

    922. 

  922.                             sb.Append(ak.Day);                            

    923. 

  923.                             return sb.ToString();

    924. 

  924.                         }

    925. 

  925.                         else if (DataTypeStringFormat == TagDisplayDataType.S7TimeOfDay)

    926. 

  926.                         {

    927. 

  927.                             DateTime ak = (DateTime)myValue;

    928. 

  928.                             StringBuilder sb = new StringBuilder();

    929. 

  929.                             sb.Append("TOD#");                            

    930. 

  930.                             sb.Append(ak.Hour);

    931. 

  931.                             sb.Append(":");

    932. 

  932.                             sb.Append(ak.Minute);

    933. 

  933.                             sb.Append(":");

    934. 

  934.                             sb.Append(ak.Second);

    935. 

  935.                             sb.Append(".");

    936. 

  936.                             sb.Append(ak.Millisecond.ToString().PadRight(3, '0'));

    937. 

  937.                             return sb.ToString();

    938. 

  938.                         }

    939. 

  939.                         return myValue.ToString();

    940. 

  940.                     

    941. 

  941.                     case TagDataType.Int:

    942. 

  942.                     case TagDataType.Dint:

    943. 

  943.                     case TagDataType.Byte:

    944. 

  944.                     case TagDataType.SByte:

    945. 

  945.                     case TagDataType.Word:

    946. 

  946.                     case TagDataType.Dword:

    947. 

  947.                     case TagDataType.Float:

    948. 

  948.                     case TagDataType.BCDByte:

    949. 

  949.                     case TagDataType.BCDWord:

    950. 

  950.                     case TagDataType.BCDDWord:

    951. 

  951.                         IFormattable val = myValue as IFormattable ?? 0;

    952. 

  952.                         switch (DataTypeStringFormat)

    953. 

  953.                         {

    954. 

  954.                             case TagDisplayDataType.String:

    955. 

  955.                                 switch (this.TagDataType)

    956. 

  956.                                 {

    957. 

  957.                                     case TagDataType.Int:

    958. 

  958.                                         return Encoding.ASCII.GetString(BitConverter.GetBytes((Int16)myValue));

    959. 

  959.                                     case TagDataType.Dint:

    960. 

  960.                                         return Encoding.ASCII.GetString(BitConverter.GetBytes((Int32)myValue));

    961. 

  961.                                     case TagDataType.Byte:

    962. 

  962.                                         return Encoding.ASCII.GetString(new []{(Byte)myValue});

    963. 

  963.                                     case TagDataType.SByte:

    964. 

  964.                                         return Encoding.ASCII.GetString(new[] { BitConverter.GetBytes((SByte)myValue)[0] });

    965. 

  965.                                     case TagDataType.Word:

    966. 

  966.                                         return Encoding.ASCII.GetString(BitConverter.GetBytes((UInt16)myValue));

    967. 

  967.                                     case TagDataType.Dword:

    968. 

  968.                                         return Encoding.ASCII.GetString(BitConverter.GetBytes((UInt32)myValue));

    969. 

  969.                                     case TagDataType.Float:

    970. 

  970.                                         return Encoding.ASCII.GetString(BitConverter.GetBytes((Single)myValue));

    971. 

  971.                                     case TagDataType.BCDByte:

    972. 

  972.                                         return Encoding.ASCII.GetString(BitConverter.GetBytes((Byte)myValue));

    973. 

  973.                                     case TagDataType.BCDWord:

    974. 

  974.                                         return Encoding.ASCII.GetString(BitConverter.GetBytes((UInt16)myValue));

    975. 

  975.                                     case TagDataType.BCDDWord:

    976. 

  976.                                         return Encoding.ASCII.GetString(BitConverter.GetBytes((UInt32)myValue));                                        

    977. 

  977.                                 }

    978. 

  978.                                 break;

    979. 

  979.                             case TagDisplayDataType.Pointer:

    980. 

  980.                                 return "P#" + (Convert.ToInt32(myValue) / 8).ToString() + "." + (Convert.ToInt32(myValue) % 8).ToString();

    981. 

  981.                                 break;

    982. 

  982.                             case TagDisplayDataType.Hexadecimal:

    983. 

  983.                                 string ad = "";

    984. 

  984.                                 switch (_internalGetSize())

    985. 

  985.                                 {

    986. 

  986.                                     case 1:

    987. 

  987.                                         ad = "B#16#";

    988. 

  988.                                         break;

    989. 

  989.                                     case 2:

    990. 

  990.                                         ad = "W#16#";

    991. 

  991.                                         break;

    992. 

  992.                                     case 4:

    993. 

  993.                                         ad = "DW#16#";

    994. 

  994.                                         break;

    995. 

  995.                                 }

    996. 

  996.                                 return ad + val.ToString("X", NumberFormatInfo.CurrentInfo).PadLeft(_internalGetSize() * 2, '0');

    997. 

  997.                             case TagDisplayDataType.Binary:

    998. 

  998.                                 byte[] bt = new byte[] { };

    999. 

  999.                                 switch (this.TagDataType)

    1000. 

  1000.                                 {

    1001. 

  1001.                                     case TagDataType.Int:

    1002. 

  1002.                                         bt = BitConverter.GetBytes((Int16)myValue);

    1003. 

  1003.                                         break;

    1004. 

  1004.                                     case TagDataType.Dint:

    1005. 

  1005.                                         bt = BitConverter.GetBytes((Int32)myValue);

    1006. 

  1006.                                         break;

    1007. 

  1007.                                     case TagDataType.Byte:

    1008. 

  1008.                                         bt = new byte[] { (byte)myValue };

    1009. 

  1009.                                         break;

    1010. 

  1010.                                     case TagDataType.SByte:

    1011. 

  1011.                                         bt = new byte[] { (byte)myValue };

    1012. 

  1012.                                         break;

    1013. 

  1013.                                     case TagDataType.Word:

    1014. 

  1014.                                         bt = BitConverter.GetBytes((UInt16)myValue);

    1015. 

  1015.                                         break;

    1016. 

  1016.                                     case TagDataType.Dword:

    1017. 

  1017.                                         bt = BitConverter.GetBytes((UInt32)myValue);

    1018. 

  1018.                                         break;

    1019. 

  1019.                                     case TagDataType.Float:

    1020. 

  1020.                                         bt = BitConverter.GetBytes((float)myValue);

    1021. 

  1021.                                         break;

    1022. 

  1022.                                     case TagDataType.BCDByte:

    1023. 

  1023.                                         bt = BitConverter.GetBytes((byte)myValue);

    1024. 

  1024.                                         break;

    1025. 

  1025.                                     case TagDataType.BCDWord:

    1026. 

  1026.                                         bt = BitConverter.GetBytes((Int16)myValue);

    1027. 

  1027.                                         break;

    1028. 

  1028.                                     case TagDataType.BCDDWord:

    1029. 

  1029.                                         bt = BitConverter.GetBytes((Int32)myValue);

    1030. 

  1030.                                         break;

    1031. 

  1031.                                 }

    1032. 

  1032.                                 string ret = "";

    1033. 

  1033.                                 foreach (byte b in bt)

    1034. 

  1034.                                 {

    1035. 

  1035.                                     if (ret != "") ret = "_" + ret;

    1036. 

  1036.                                     ret = libnodave.dec2bin(b).Substring(0, 4) + "_" + libnodave.dec2bin(b).Substring(4, 4) + ret;

    1037. 

  1037. 

    1038. 

  1038.                                 }

    1039. 

  1039.                                 return "2#" + ret;

    1040. 

  1040. 

    1041. 

  1041.                         }

    1042. 

  1042.                         return val.ToString();                    

    1043. 

  1043.                 }

    1044. 

  1044.             }

    1045. 

  1045.             return "";

    1046. 

  1046.         }

    1047. 

  1047. 

    1048. 

  1048.         public string GetValueAsString()

    1049. 

  1049.         {

    1050. 

  1050.             if (ItemDoesNotExist)

    1051. 

  1051.                 return "Item does not exist on the PLC!";

    1052. 

  1052.             return GetValueAsString(this.Value);

    1053. 

  1053.         }       

    1054. 

  1054. 

    1055. 

  1055.         public override string ToString()

    1056. 

  1056.         {           

    1057. 

  1057.             string old = "";

    1058. 

  1058.             if (_oldvalues != null)

    1059. 

  1059.             {

    1060. 

  1060.                 old = "   -- Old-Values: ";

    1061. 

  1061.                 foreach (var oldvalue in _oldvalues)

    1062. 

  1062.                 {

    1063. 

  1063.                     old += oldvalue.ToString() + ",";

    1064. 

  1064.                 }

    1065. 

  1065.                 old += "";

    1066. 

  1066.             }

    1067. 

  1067. 

    1068. 

  1068.             if (Value != null)

    1069. 

  1069.             {                

    1070. 

  1070.                 return S7FormatAddress + " = " + GetValueAsString() + old;

    1071. 

  1071.             }

    1072. 

  1072.             return S7FormatAddress;

    1073. 

  1073.         }

    1074. 

  1074. 

    1075. 

  1075.         public void ChangeAddressFromString(String newPlcAddress)

    1076. 

  1076.         {

    1077. 

  1077.             var plcAddress = newPlcAddress;

    1078. 

  1078.             if (plcAddress.Contains("("))

    1079. 

  1079.             {

    1080. 

  1080.                 var pos = newPlcAddress.IndexOf('(');

    1081. 

  1081.                 plcAddress = newPlcAddress.Substring(0, pos);

    1082. 

  1082.                 symbolicAccessKey = newPlcAddress.Substring(pos + 1, newPlcAddress.Length - pos - 2);

    1083. 

  1083.                 isSymbolicAccessKeyTag = true;

    1084. 

  1084.             }

    1085. 

  1085. 

    1086. 

  1086.             if (plcAddress.StartsWith("%")) 

    1087. 

  1087.                 plcAddress = plcAddress.Substring(1);

    1088. 

  1088.             

    1089. 

  1089.             try

    1090. 

  1090.             {

    1091. 

  1091.                 if (!string.IsNullOrEmpty(plcAddress))

    1092. 

  1092.                 {

    1093. 

  1093.                     plcAddress = plcAddress.Trim();

    1094. 

  1094.                     if (plcAddress.Length > 1 && plcAddress.Substring(0, 2).ToLower() == "p#")

    1095. 

  1095.                     {

    1096. 

  1096.                         string[] myPlcAddress = plcAddress.ToLower().Replace("byte", " byte ").Replace("  ", " ").Replace("p#", "").Split(' ');

    1097. 

  1097.                         BitAddress = 0;

    1098. 

  1098.                         if (!myPlcAddress[0].Contains("db"))

    1099. 

  1099.                         {

    1100. 

  1100.                             this.DataBlockNumber = 0;

    1101. 

  1101.                             var tmp = myPlcAddress[0].Split('.')[0];

    1102. 

  1102.                             if (tmp.Contains("e") || tmp.Contains("i"))

    1103. 

  1103.                                 this.TagDataSource = MemoryArea.Inputs;

    1104. 

  1104.                             else if (tmp.Contains("a") || tmp.Contains("q"))

    1105. 

  1105.                                 this.TagDataSource = MemoryArea.Outputs;

    1106. 

  1106.                             else if (tmp.Contains("l"))

    1107. 

  1107.                                 this.TagDataSource = MemoryArea.LocalData;

    1108. 

  1108.                             else if (tmp.Contains("v"))

    1109. 

  1109.                                 this.TagDataSource = MemoryArea.PreviousLocalData;

    1110. 

  1110.                             else if (tmp.Contains("m"))

    1111. 

  1111.                                 this.TagDataSource = MemoryArea.Flags;

    1112. 

  1112.                             else if (tmp.Contains("t"))

    1113. 

  1113.                                 this.TagDataSource = MemoryArea.Timer;

    1114. 

  1114.                             else if (tmp.Contains("z") || tmp.Contains("c"))

    1115. 

  1115.                                 this.TagDataSource = MemoryArea.Counter;

    1116. 

  1116.                             ByteAddress = Convert.ToInt32(Regex.Replace(myPlcAddress[0].Split('.')[0], "[a-z]", ""));

    1117. 

  1117.                         }

    1118. 

  1118.                         else

    1119. 

  1119.                         {

    1120. 

  1120.                             this.TagDataSource = MemoryArea.Datablock;

    1121. 

  1121.                             this.DataBlockNumber = Convert.ToInt32(myPlcAddress[0].Split('.')[0].Replace("db", ""));

    1122. 

  1122.                             ByteAddress = Convert.ToInt32(myPlcAddress[0].Split('.')[1].Replace("dbx", ""));

    1123. 

  1123.                         }

    1124. 

  1124.                         ArraySize = Convert.ToInt32(myPlcAddress[2]);

    1125. 

  1125. 

    1126. 

  1126.                         var tsize = 1;

    1127. 

  1127.                         switch (myPlcAddress[1])

    1128. 

  1128.                         {

    1129. 

  1129.                             case "word":

    1130. 

  1130.                             case "int":

    1131. 

  1131.                             case "date":

    1132. 

  1132.                             case "s5time":

    1133. 

  1133.                                 tsize = 2;

    1134. 

  1134.                                 break;

    1135. 

  1135.                             case "real":

    1136. 

  1136.                             case "dword":

    1137. 

  1137.                             case "dint":

    1138. 

  1138.                             case "time":

    1139. 

  1139.                             case "time_of_day":

    1140. 

  1140.                                 tsize = 4;

    1141. 

  1141.                                 break;

    1142. 

  1142.                         }

    1143. 

  1143. 

    1144. 

  1144.                         var baseS = _internalGetBaseTypeSize();

    1145. 

  1145.                         if (baseS > 0) ArraySize = ArraySize / baseS;

    1146. 

  1146. 

    1147. 

  1147.                         ArraySize = ArraySize * tsize;

    1148. 

  1148. 

    1149. 

  1149.                         //if (this.TagDataType != TagDataType.ByteArray && this.TagDataType != TagDataType.CharArray && this.TagDataType != TagDataType.String && this.TagDataType != TagDataType.DateTime)

    1150. 

  1150.                         //    this.TagDataType = TagDataType.ByteArray;

    1151. 

  1151.                         //if (ArraySize != 8 && this.TagDataType == TagDataType.DateTime)

    1152. 

  1152.                         //    this.TagDataType = TagDataType.ByteArray;

    1153. 

  1153. 

    1154. 

  1154.                         if (this.TagDataType == TagDataType.String)

    1155. 

  1155.                             ArraySize -= 2;

    1156. 

  1156.                     }

    1157. 

  1157.                     else

    1158. 

  1158.                     {

    1159. 

  1159.                         string[] myPlcAddress = plcAddress.ToUpper().Trim().Replace(" ", "").Split('.');

    1160. 

  1160.                         if (myPlcAddress.Length >= 2 && (myPlcAddress[0].Contains("DB") || myPlcAddress[0].Contains("DI")))

    1161. 

  1161.                         {

    1162. 

  1162.                             this.TagDataSource = MemoryArea.Datablock;

    1163. 

  1163.                             this.DataBlockNumber = Convert.ToInt32(myPlcAddress[0].Replace("DB", "").Replace("DI", "").Trim());

    1164. 

  1164.                             if (myPlcAddress[1].Contains("DBW"))

    1165. 

  1165.                             {

    1166. 

  1166.                                 if (this.TagDataType == TagDataType.String || this.TagDataType == TagDataType.CharArray || this.TagDataType == TagDataType.ByteArray)

    1167. 

  1167.                                     ArraySize = 2;

    1168. 

  1168.                                 else 

    1169. 

  1169.                                     ArraySize = 1;

    1170. 

  1170.                                 if (this._internalGetSize() != 2)

    1171. 

  1171.                                     this.TagDataType = TagDataType.Word;

    1172. 

  1172.                             }

    1173. 

  1173.                             else if (myPlcAddress[1].Contains("DBB"))

    1174. 

  1174.                             {

    1175. 

  1175.                                 ArraySize = 1;

    1176. 

  1176.                                 if (this.TagDataType == TagDataType.Bool || this._internalGetSize() != 1)

    1177. 

  1177.                                     this.TagDataType = TagDataType.Byte;

    1178. 

  1178.                             }

    1179. 

  1179.                             else if (myPlcAddress[1].Contains("DBD"))

    1180. 

  1180.                             {

    1181. 

  1181.                                 if (this.TagDataType == TagDataType.String || this.TagDataType == TagDataType.CharArray || this.TagDataType == TagDataType.ByteArray)

    1182. 

  1182.                                     ArraySize = 4;

    1183. 

  1183.                                 else 

    1184. 

  1184.                                     ArraySize = 1;

    1185. 

  1185.                                 if (this._internalGetSize() != 4)

    1186. 

  1186.                                     this.TagDataType = TagDataType.Dword;

    1187. 

  1187.                             }

    1188. 

  1188.                             else if (myPlcAddress[1].Contains("DBX"))

    1189. 

  1189.                             {

    1190. 

  1190.                                 ArraySize = 1;

    1191. 

  1191.                                 this.TagDataType = TagDataType.Bool;

    1192. 

  1192.                                 if (myPlcAddress.Length > 2)

    1193. 

  1193.                                     this.BitAddress = Convert.ToInt32(myPlcAddress[2]);

    1194. 

  1194.                                 else

    1195. 

  1195.                                     this.BitAddress = 0;

    1196. 

  1196.                             }

    1197. 

  1197.                             this.ByteAddress = Convert.ToInt32(myPlcAddress[1].Replace("DBW", "").Replace("DBD", "").Replace("DBX", "").Replace("DBB", "").Trim());

    1198. 

  1198.                         }

    1199. 

  1199.                         else

    1200. 

  1200.                         {

    1201. 

  1201.                             if (myPlcAddress[0].Contains("E") || myPlcAddress[0].Contains("I"))

    1202. 

  1202.                                 this.TagDataSource = MemoryArea.Inputs;

    1203. 

  1203.                             else if (myPlcAddress[0].Contains("A") || myPlcAddress[0].Contains("Q"))

    1204. 

  1204.                                 this.TagDataSource = MemoryArea.Outputs;

    1205. 

  1205.                             else if (myPlcAddress[0].Contains("M"))

    1206. 

  1206.                                 this.TagDataSource = MemoryArea.Flags;

    1207. 

  1207.                             else if (myPlcAddress[0].Contains("T"))

    1208. 

  1208.                                 this.TagDataSource = MemoryArea.Timer;

    1209. 

  1209.                             else if (myPlcAddress[0].Contains("Z") || myPlcAddress[0].Contains("C"))

    1210. 

  1210.                                 this.TagDataSource = MemoryArea.Counter;

    1211. 

  1211. 

    1212. 

  1212.                             if (myPlcAddress[0].Contains("W"))

    1213. 

  1213.                             {

    1214. 

  1214.                                 if (this.TagDataType == TagDataType.String || this.TagDataType == TagDataType.CharArray || this.TagDataType == TagDataType.ByteArray)

    1215. 

  1215.                                     ArraySize = 2;

    1216. 

  1216.                                 else 

    1217. 

  1217.                                     ArraySize = 1;

    1218. 

  1218.                                 if (_internalGetSize() != 2)

    1219. 

  1219.                                     this.TagDataType = TagDataType.Int;

    1220. 

  1220.                             }

    1221. 

  1221.                             else if (myPlcAddress[0].Contains("DBB"))

    1222. 

  1222.                             {

    1223. 

  1223.                                 ArraySize = 1;

    1224. 

  1224.                                 if (this.TagDataType == TagDataType.Bool || this._internalGetSize() != 1)

    1225. 

  1225.                                     this.TagDataType = TagDataType.Byte;

    1226. 

  1226.                             }

    1227. 

  1227.                             else if (myPlcAddress[0].Contains("D"))

    1228. 

  1228.                             {

    1229. 

  1229.                                 if (this.TagDataType == TagDataType.String || this.TagDataType == TagDataType.CharArray || this.TagDataType == TagDataType.ByteArray)

    1230. 

  1230.                                     ArraySize = 4;

    1231. 

  1231.                                 else

    1232. 

  1232.                                     ArraySize = 1;

    1233. 

  1233.                                 if (_internalGetSize() != 4)

    1234. 

  1234.                                     this.TagDataType = TagDataType.Dint;

    1235. 

  1235.                             }

    1236. 

  1236.                             else if (myPlcAddress[0].Contains("B"))

    1237. 

  1237.                             {

    1238. 

  1238.                                 ArraySize = 1;

    1239. 

  1239.                                 if (this.TagDataType == TagDataType.Bool || this._internalGetSize() != 1)

    1240. 

  1240.                                     this.TagDataType = TagDataType.Byte;

    1241. 

  1241.                             }

    1242. 

  1242.                             else if (!myPlcAddress[0].Contains("T") && !myPlcAddress[0].Contains("Z"))

    1243. 

  1243.                             {

    1244. 

  1244.                                 ArraySize = 1;

    1245. 

  1245.                                 this.TagDataType = TagDataType.Bool;

    1246. 

  1246.                                 if (myPlcAddress.Length >= 2)

    1247. 

  1247.                                     this.BitAddress = Convert.ToInt32(myPlcAddress[1]);

    1248. 

  1248.                                 else

    1249. 

  1249.                                     this.BitAddress = 0;

    1250. 

  1250.                             }

    1251. 

  1251.                             else if (myPlcAddress[0].Contains("T"))

    1252. 

  1252.                             {

    1253. 

  1253.                                 ArraySize = 1;

    1254. 

  1254.                                 this.TagDataType = TagDataType.S5Time;

    1255. 

  1255.                             }

    1256. 

  1256.                             else if (myPlcAddress[0].Contains("Z") || myPlcAddress[0].Contains("C"))

    1257. 

  1257.                             {

    1258. 

  1258.                                 ArraySize = 1;

    1259. 

  1259.                                 this.TagDataType = TagDataType.Int;

    1260. 

  1260.                             }

    1261. 

  1261.                             else

    1262. 

  1262.                             {

    1263. 

  1263.                                 ArraySize = 1;

    1264. 

  1264.                                 if (_internalGetSize() != 1)

    1265. 

  1265.                                     this.TagDataType = TagDataType.Bool;

    1266. 

  1266.                             }

    1267. 

  1267. 

    1268. 

  1268.                             this.ByteAddress = Convert.ToInt32(Regex.Replace(myPlcAddress[0].ToLower(), "[a-z]", "").Trim());

    1269. 

  1269. 

    1270. 

  1270.                             if (this.TagDataType == TagDataType.String)

    1271. 

  1271.                                 ArraySize -= 2;

    1272. 

  1272.                         }

    1273. 

  1273.                     }

    1274. 

  1274.                 }

    1275. 

  1275.             }

    1276. 

  1276.             catch(Exception)

    1277. 

  1277.             {

    1278. 

  1278.                 if (plcAddress!=null)

    1279. 

  1279.                     if (plcAddress.ToLower().Contains("p#"))

    1280. 

  1280.                     {

    1281. 

  1281.                         this.TagDataType = TagDataType.ByteArray;

    1282. 

  1282.                         this.ArraySize = 10;

    1283. 

  1283.                     }

    1284. 

  1284.             }

    1285. 

  1285.         }

    1286. 

  1286. 

    1287. 

  1287.         public void ChangeDataTypeFromString(String datatype)

    1288. 

  1288.         {

    1289. 

  1289.             if (!string.IsNullOrEmpty(datatype))

    1290. 

  1290.             {

    1291. 

  1291.                 TagDataType tp = TagDataType.Word;

    1292. 

  1292.                 datatype = datatype.ToLower().Trim().Replace(" ", "");

    1293. 

  1293.                 switch (datatype)

    1294. 

  1294.                 {

    1295. 

  1295.                     case "bool":

    1296. 

  1296.                         tp = TagDataType.Bool;

    1297. 

  1297.                         break;

    1298. 

  1298.                     case "word":

    1299. 

  1299.                         tp = TagDataType.Word;

    1300. 

  1300.                         break;

    1301. 

  1301.                     case "int":

    1302. 

  1302.                     case "integer":

    1303. 

  1303.                         tp = TagDataType.Int;

    1304. 

  1304.                         break;

    1305. 

  1305.                     case "dword":

    1306. 

  1306.                         tp = TagDataType.Dword;

    1307. 

  1307.                         break;

    1308. 

  1308.                     case "dint":

    1309. 

  1309.                         tp = TagDataType.Dint;

    1310. 

  1310.                         break;

    1311. 

  1311.                     case "byte":

    1312. 

  1312.                         tp = TagDataType.Byte;

    1313. 

  1313.                         break;

    1314. 

  1314.                     case "sbyte":

    1315. 

  1315.                         tp = TagDataType.SByte;

    1316. 

  1316.                         break;

    1317. 

  1317.                     case "string":

    1318. 

  1318.                         tp = TagDataType.String;

    1319. 

  1319.                         break;

    1320. 

  1320.                     case "time":

    1321. 

  1321.                         tp = TagDataType.Time;

    1322. 

  1322.                         break;

    1323. 

  1323.                     case "s5time":

    1324. 

  1324.                         tp = TagDataType.S5Time;

    1325. 

  1325.                         break;

    1326. 

  1326.                     case "timeofday":

    1327. 

  1327.                         tp = TagDataType.TimeOfDay;

    1328. 

  1328.                         break;

    1329. 

  1329.                     case "date":

    1330. 

  1330.                         tp = TagDataType.Date;

    1331. 

  1331.                         break;

    1332. 

  1332.                     case "bcdbyte":

    1333. 

  1333.                     case "bcd":

    1334. 

  1334.                         tp = TagDataType.BCDByte;

    1335. 

  1335.                         break;

    1336. 

  1336.                     case "bcdword":

    1337. 

  1337.                         tp = TagDataType.BCDWord;

    1338. 

  1338.                         break;

    1339. 

  1339.                     case "bcddword":

    1340. 

  1340.                         tp = TagDataType.BCDDWord;

    1341. 

  1341.                         break;

    1342. 

  1342.                     case "datetime":

    1343. 

  1343.                     case "dateandtime":

    1344. 

  1344.                         tp = TagDataType.DateTime;

    1345. 

  1345.                         break;

    1346. 

  1346.                     case "char":

    1347. 

  1347.                     case "chararray":

    1348. 

  1348.                         tp = TagDataType.CharArray;

    1349. 

  1349.                         break;

    1350. 

  1350.                     case "bytearray":

    1351. 

  1351.                         tp = TagDataType.ByteArray;

    1352. 

  1352.                         break;

    1353. 

  1353.                     case "float":

    1354. 

  1354.                     case "real":

    1355. 

  1355.                         tp = TagDataType.Float;

    1356. 

  1356.                         break;

    1357. 

  1357.                 }

    1358. 

  1358.                 this.TagDataType = tp;

    1359. 

  1359.             }

    1360. 

  1360.         }

    1361. 

  1361. 

    1362. 

  1362.         public void ChangeDataTypeStringFormatFromString(String datatype)

    1363. 

  1363.         {

    1364. 

  1364.             if (!string.IsNullOrEmpty(datatype))

    1365. 

  1365.             {

    1366. 

  1366.                 TagDisplayDataType tp = TagDisplayDataType.Decimal;

    1367. 

  1367.                 datatype = datatype.ToLower().Trim().Replace(" ", "");

    1368. 

  1368.                 switch (datatype.Replace(" ", "").Replace("_", "").Trim())

    1369. 

  1369.                 {

    1370. 

  1370.                     case "decimal":

    1371. 

  1371.                     case "dec":

    1372. 

  1372.                         tp = TagDisplayDataType.Decimal;

    1373. 

  1373.                         break;

    1374. 

  1374.                     case "hexadecimal":

    1375. 

  1375.                     case "hex":

    1376. 

  1376.                         tp = TagDisplayDataType.Hexadecimal;

    1377. 

  1377.                         break;

    1378. 

  1378.                     case "binary":

    1379. 

  1379.                     case "bin":

    1380. 

  1380.                         tp = TagDisplayDataType.Binary;

    1381. 

  1381.                         break;

    1382. 

  1382.                     case "pointer":

    1383. 

  1383.                         tp = TagDisplayDataType.Pointer;

    1384. 

  1384.                         break;

    1385. 

  1385.                     case "bool":

    1386. 

  1386.                         tp = TagDisplayDataType.Bool;

    1387. 

  1387.                         break;

    1388. 

  1388.                     case "byte":

    1389. 

  1389.                     case "bytearray":

    1390. 

  1390.                         tp = TagDisplayDataType.ByteArray;

    1391. 

  1391.                         break;

    1392. 

  1392.                     case "datetime":

    1393. 

  1393.                         tp = TagDisplayDataType.DateTime;

    1394. 

  1394.                         break;

    1395. 

  1395.                     case "date":

    1396. 

  1396.                     case "s7date":

    1397. 

  1397.                         tp = TagDisplayDataType.S7Date;

    1398. 

  1398.                         break;

    1399. 

  1399.                     case "s7timeofday":

    1400. 

  1400.                     case "timeofday":

    1401. 

  1401.                         tp = TagDisplayDataType.S7TimeOfDay;

    1402. 

  1402.                         break;

    1403. 

  1403.                     case "float":

    1404. 

  1404.                     case "real":

    1405. 

  1405.                         tp = TagDisplayDataType.Float;

    1406. 

  1406.                         break;

    1407. 

  1407.                     case "s5time":

    1408. 

  1408.                         tp = TagDisplayDataType.S5Time;

    1409. 

  1409.                         break;

    1410. 

  1410.                     case "s7datetime":

    1411. 

  1411.                     case "dateandtime":

    1412. 

  1412.                         tp = TagDisplayDataType.S7DateTime;

    1413. 

  1413.                         break;

    1414. 

  1414.                     case "string":

    1415. 

  1415.                     case "strg":

    1416. 

  1416.                         tp = TagDisplayDataType.String;

    1417. 

  1417.                         break;

    1418. 

  1418.                     case "time":

    1419. 

  1419.                     case "s7time":

    1420. 

  1420.                         tp = TagDisplayDataType.Time;

    1421. 

  1421.                         break;

    1422. 

  1422.                     case "timespan":

    1423. 

  1423.                         tp = TagDisplayDataType.TimeSpan;

    1424. 

  1424.                         break;

    1425. 

  1425.                 }

    1426. 

  1426.                 this.DataTypeStringFormat = tp;

    1427. 

  1427.             }

    1428. 

  1428.         }

    1429. 

  1429. 

    1430. 

  1430.         public static PLCTag GetPLCTagFromString(String plcAddress)

    1431. 

  1431.         {

    1432. 

  1432.             PLCTag retValue = new PLCTag();

    1433. 

  1433.             retValue.ChangeAddressFromString(plcAddress);

    1434. 

  1434.             return retValue;

    1435. 

  1435.         }

    1436. 

  1436. 

    1437. 

  1437.         public bool LimitControlValuesRange { get; set; }

    1438. 

  1438. 

    1439. 

  1439.         internal virtual void _putControlValueIntoBuffer(byte[] buff, int startpos)

    1440. 

  1440.         {

    1441. 

  1441.             if (this.ArraySize == 1 || this.TagDataType == TagDataType.String || this.TagDataType == TagDataType.ByteArray)

    1442. 

  1442.             {

    1443. 

  1443.                 _putControlValueIntoBuffer(buff, startpos, Controlvalue);

    1444. 

  1444.             }

    1445. 

  1445.             else

    1446. 

  1446.             {

    1447. 

  1447.                 int n = 0;

    1448. 

  1448.                 foreach (var ctlVal in (IEnumerable)Controlvalue)

    1449. 

  1449.                 {

    1450. 

  1450.                     _putControlValueIntoBuffer(buff, startpos + (n * this._internalGetBaseTypeSize()), ctlVal);

    1451. 

  1451.                     n++;

    1452. 

  1452.                     if (n >= ArraySize) break;

    1453. 

  1453.                 }                

    1454. 

  1454.             }

    1455. 

  1455.         }

    1456. 

  1456. 

    1457. 

  1457. 

    1458. 

  1458.         internal virtual void _putControlValueIntoBuffer(byte[] buff, int startpos, object ctlValue)

    1459. 

  1459.         {

    1460. 

  1460.             if (ctlValue != null)

    1461. 

  1461.                 switch (this.TagDataType)

    1462. 

  1462.                 {

    1463. 

  1463.                     case TagDataType.Word:

    1464. 

  1464.                         libnodave.putU16at(buff, startpos, Convert.ToUInt16(ctlValue));

    1465. 

  1465.                         break;

    1466. 

  1466.                     case TagDataType.String:

    1467. 

  1467.                         libnodave.putS7Stringat(buff, startpos, ctlValue.ToString(), ArraySize);

    1468. 

  1468.                         break;

    1469. 

  1469.                     case TagDataType.CharArray:

    1470. 

  1470.                         libnodave.putStringat(buff, startpos, ctlValue.ToString(), ArraySize);

    1471. 

  1471.                         break;

    1472. 

  1472.                     case TagDataType.ByteArray:

    1473. 

  1473.                         {

    1474. 

  1474.                             byte[] tmp = (byte[])ctlValue;

    1475. 

  1475.                             for (int n = 0; n < ArraySize; n++)

    1476. 

  1476.                             {

    1477. 

  1477.                                 if (n > tmp.Length)

    1478. 

  1478.                                     buff[startpos + n] = 0x00;

    1479. 

  1479.                                 else

    1480. 

  1480.                                     buff[startpos + n] = tmp[n];

    1481. 

  1481.                             }

    1482. 

  1482.                         }

    1483. 

  1483.                         break;

    1484. 

  1484.                     case TagDataType.Bool:

    1485. 

  1485.                         bool tmp1 = false;

    1486. 

  1486.                         tmp1 = Convert.ToBoolean(ctlValue);

    1487. 

  1487.                         buff[startpos] = Convert.ToByte(tmp1);

    1488. 

  1488.                         break;

    1489. 

  1489.                     case TagDataType.Byte:

    1490. 

  1490.                         buff[startpos] = Convert.ToByte(ctlValue);

    1491. 

  1491.                         break;

    1492. 

  1492.                     case TagDataType.SByte:

    1493. 

  1493.                         buff[startpos] = (Byte)Convert.ToSByte(ctlValue);

    1494. 

  1494.                         break;

    1495. 

  1495.                     case TagDataType.Time:

    1496. 

  1496.                         libnodave.putTimeat(buff, startpos, (TimeSpan)ctlValue);

    1497. 

  1497.                         break;

    1498. 

  1498.                     case TagDataType.TimeOfDay:

    1499. 

  1499.                         libnodave.putTimeOfDayat(buff, startpos, (DateTime)ctlValue);

    1500. 

  1500.                         break;

    1501. 

  1501.                     case TagDataType.BCDByte:

    1502. 

  1502.                         libnodave.putBCD8at(buff, startpos, Convert.ToInt32(ctlValue));

    1503. 

  1503.                         break;

    1504. 

  1504.                     case TagDataType.Int:

    1505. 

  1505.                         libnodave.putS16at(buff, startpos, Convert.ToInt16(ctlValue));

    1506. 

  1506.                         break;

    1507. 

  1507.                     case TagDataType.S5Time:

    1508. 

  1508.                         //if (Controlvalue.GetType() == typeof(TimeSpan))

    1509. 

  1509.                         libnodave.putS5Timeat(buff, startpos, (TimeSpan)ctlValue);

    1510. 

  1510.                         //else

    1511. 

  1511.                         //    libnodave.putS5Timeat(buff, startpos, TimeSpan.Parse(Controlvalue.ToString()));

    1512. 

  1512.                         break;

    1513. 

  1513.                     case TagDataType.BCDWord:

    1514. 

  1514.                         libnodave.putBCD16at(buff, startpos, Convert.ToInt32(ctlValue));

    1515. 

  1515.                         break;

    1516. 

  1516.                     case TagDataType.BCDDWord:

    1517. 

  1517.                         libnodave.putBCD32at(buff, startpos, Convert.ToInt32(ctlValue));

    1518. 

  1518.                         break;

    1519. 

  1519.                     case TagDataType.Dint:

    1520. 

  1520.                         libnodave.putS32at(buff, startpos, Convert.ToInt32(ctlValue));

    1521. 

  1521.                         break;

    1522. 

  1522.                     case TagDataType.Dword:

    1523. 

  1523.                         libnodave.putU32at(buff, startpos, Convert.ToUInt32(ctlValue));

    1524. 

  1524.                         break;

    1525. 

  1525.                     case TagDataType.Float:

    1526. 

  1526.                         libnodave.putFloatat(buff, startpos, Convert.ToSingle(ctlValue));

    1527. 

  1527.                         break;

    1528. 

  1528.                     case TagDataType.DateTime:

    1529. 

  1529.                         //if (Controlvalue.GetType() == typeof(DateTime))

    1530. 

  1530.                         libnodave.putDateTimeat(buff, startpos, (DateTime)ctlValue);

    1531. 

  1531.                         //else

    1532. 

  1532.                         //    libnodave.putDateTimeat(buff, startpos, Convert.ToDateTime(Controlvalue));

    1533. 

  1533.                         break;

    1534. 

  1534.                     case TagDataType.Date:

    1535. 

  1535.                         //if (Controlvalue.GetType() == typeof(DateTime))

    1536. 

  1536.                         libnodave.putDateat(buff, startpos, (DateTime)ctlValue);

    1537. 

  1537.                         //else

    1538. 

  1538.                         //    libnodave.putDateTimeat(buff, startpos, Convert.ToDateTime(Controlvalue));

    1539. 

  1539.                         break;

    1540. 

  1540.                 }

    1541. 

  1541.         }

    1542. 

  1542. 

    1543. 

  1543.         /// <summary>

    1544. 

  1544.         /// This Parses the PLCTag From a Byte Array

    1545. 

  1545.         /// this is used, when the Tag is not Read via my Functions, but the PLCTags are used as Wrapper

    1546. 

  1546.         /// </summary>

    1547. 

  1547.         /// <param name="buff"></param>

    1548. 

  1548.         /// <param name="startpos"></param>

    1549. 

  1549.         public void ParseValueFromByteArray(byte[] buff, int startpos)

    1550. 

  1550.         {

    1551. 

  1551.             _readValueFromBuffer(buff, startpos);

    1552. 

  1552.         }

    1553. 

  1553. 

    1554. 

  1554.         internal virtual void _readValueFromBuffer(byte[] buff, int startpos)

    1555. 

  1555.         {

    1556. 

  1556.             switch (this.TagDataType)

    1557. 

  1557.             {

    1558. 

  1558.                 case TagDataType.String:                    

    1559. 

  1559.                     {

    1560. 

  1560.                         var sb = new StringBuilder();

    1561. 

  1561.                         int size = ArraySize > buff[startpos + 1] ? buff[startpos+1] : ArraySize;

    1562. 

  1562.                         for (var n = 2; n < size+2; n++)

    1563. 

  1563.                             sb.Append((char) buff[n + startpos]);

    1564. 

  1564.                         _setValueProp = sb.ToString();

    1565. 

  1565.                     }

    1566. 

  1566.                     break;

    1567. 

  1567.                 case TagDataType.CharArray:

    1568. 

  1568.                     {

    1569. 

  1569.                         var sb = new StringBuilder();

    1570. 

  1570.                         for (var n = 0; n < ((buff.Length - startpos) < ArraySize ? buff.Length - startpos : ArraySize); n++)

    1571. 

  1571.                             sb.Append((char)buff[n + startpos]);

    1572. 

  1572.                         _setValueProp = sb.ToString();

    1573. 

  1573.                     }

    1574. 

  1574.                     break;

    1575. 

  1575.                 case TagDataType.ByteArray:

    1576. 

  1576.                     {

    1577. 

  1577.                         var val = new Byte[ArraySize];

    1578. 

  1578.                         Array.Copy(buff, startpos, val, 0, ArraySize);

    1579. 

  1579. 

    1580. 

  1580.                         /*

    1581. 

  1581.                         for (var n = 0; n < ArraySize; n++)

    1582. 

  1582.                             val[n] = buff[n + startpos];

    1583. 

  1583.                         */

    1584. 

  1584.                         _setValueProp = val;

    1585. 

  1585.                     }

    1586. 

  1586.                     break;

    1587. 

  1587. 

    1588. 

  1588.                 case TagDataType.Bool:                   

    1589. 

  1589.                 case TagDataType.Byte:                   

    1590. 

  1590.                 case TagDataType.SByte:

    1591. 

  1591.                 case TagDataType.Time:

    1592. 

  1592.                 case TagDataType.Date:

    1593. 

  1593.                 case TagDataType.TimeOfDay:

    1594. 

  1594.                 case TagDataType.Word:

    1595. 

  1595.                 case TagDataType.BCDByte:

    1596. 

  1596.                 case TagDataType.Int:

    1597. 

  1597.                 case TagDataType.S5Time:

    1598. 

  1598.                 case TagDataType.BCDWord:

    1599. 

  1599.                 case TagDataType.BCDDWord:

    1600. 

  1600.                 case TagDataType.Dint:

    1601. 

  1601.                 case TagDataType.Dword:

    1602. 

  1602.                 case TagDataType.Float:

    1603. 

  1603.                 case TagDataType.DateTime:

    1604. 

  1604.                     {

    1605. 

  1605.                         if (ArraySize<2)

    1606. 

  1606.                         {

    1607. 

  1607.                             switch (this.TagDataType)

    1608. 

  1608.                             {

    1609. 

  1609.                                 case TagDataType.Bool:

    1610. 

  1610.                                     _setValueProp = libnodave.getBit(buff[startpos], BitAddress);

    1611. 

  1611.                                     break;

    1612. 

  1612.                                 case TagDataType.Byte:

    1613. 

  1613.                                     _setValueProp = buff[startpos];

    1614. 

  1614.                                     break;

    1615. 

  1615.                                 case TagDataType.SByte:

    1616. 

  1616.                                     _setValueProp = libnodave.getS8from(buff, startpos);

    1617. 

  1617.                                     break;

    1618. 

  1618.                                 case TagDataType.Time:

    1619. 

  1619.                                     _setValueProp = libnodave.getTimefrom(buff, startpos);

    1620. 

  1620.                                     break;

    1621. 

  1621.                                 case TagDataType.Date:

    1622. 

  1622.                                     _setValueProp = libnodave.getDatefrom(buff, startpos);

    1623. 

  1623.                                     break;

    1624. 

  1624.                                 case TagDataType.TimeOfDay:

    1625. 

  1625.                                     _setValueProp = libnodave.getTimeOfDayfrom(buff, startpos);

    1626. 

  1626.                                     break;

    1627. 

  1627.                                 case TagDataType.Word:

    1628. 

  1628.                                     _setValueProp = libnodave.getU16from(buff, startpos);

    1629. 

  1629.                                     break;

    1630. 

  1630.                                 case TagDataType.BCDByte:

    1631. 

  1631.                                     _setValueProp = libnodave.getBCD8from(buff, startpos);

    1632. 

  1632.                                     break;

    1633. 

  1633.                                 case TagDataType.Int:

    1634. 

  1634.                                     _setValueProp = libnodave.getS16from(buff, startpos);

    1635. 

  1635.                                     break;

    1636. 

  1636.                                 case TagDataType.S5Time:

    1637. 

  1637.                                     _setValueProp = libnodave.getS5Timefrom(buff, startpos);

    1638. 

  1638.                                     break;

    1639. 

  1639.                                 case TagDataType.BCDWord:

    1640. 

  1640.                                     _setValueProp = libnodave.getBCD16from(buff, startpos);

    1641. 

  1641.                                     break;

    1642. 

  1642.                                 case TagDataType.BCDDWord:

    1643. 

  1643.                                     _setValueProp = libnodave.getBCD32from(buff, startpos);

    1644. 

  1644.                                     break;

    1645. 

  1645.                                 case TagDataType.Dint:

    1646. 

  1646.                                     _setValueProp = libnodave.getS32from(buff, startpos);

    1647. 

  1647.                                     break;

    1648. 

  1648.                                 case TagDataType.Dword:

    1649. 

  1649.                                     _setValueProp = libnodave.getU32from(buff, startpos);

    1650. 

  1650.                                     break;

    1651. 

  1651.                                 case TagDataType.Float:

    1652. 

  1652.                                     _setValueProp = libnodave.getFloatfrom(buff, startpos);

    1653. 

  1653.                                     break;

    1654. 

  1654.                                 case TagDataType.DateTime:

    1655. 

  1655.                                     _setValueProp = libnodave.getDateTimefrom(buff, startpos);

    1656. 

  1656.                                     break;

    1657. 

  1657.                             }

    1658. 

  1658.                         }

    1659. 

  1659.                         else

    1660. 

  1660.                         {

    1661. 

  1661.                             switch (this.TagDataType)

    1662. 

  1662.                             {

    1663. 

  1663.                                 case TagDataType.Bool:

    1664. 

  1664.                                     {

    1665. 

  1665.                                         var values = new List<bool>();

    1666. 

  1666.                                         var akBit = BitAddress;

    1667. 

  1667.                                         var akbyte = startpos;

    1668. 

  1668.                                         for (int n = 0; n < ArraySize; n++)

    1669. 

  1669.                                         {

    1670. 

  1670.                                             values.Add(libnodave.getBit(buff[akbyte], akBit));

    1671. 

  1671.                                             akBit++;

    1672. 

  1672.                                             if (akBit>7)

    1673. 

  1673.                                             {

    1674. 

  1674.                                                 akBit = 0;

    1675. 

  1675.                                                 akbyte++;

    1676. 

  1676.                                             }

    1677. 

  1677.                                         }

    1678. 

  1678. 

    1679. 

  1679.                                         _setValueProp = values.ToArray();

    1680. 

  1680.                                         break;

    1681. 

  1681.                                     }

    1682. 

  1682.                                 case TagDataType.Byte:

    1683. 

  1683.                                     {

    1684. 

  1684.                                         var values = new List<Byte>();

    1685. 

  1685.                                         var mSize = _internalGetBaseTypeSize();

    1686. 

  1686.                                         for (int n = 0; n < ArraySize; n++)

    1687. 

  1687.                                             values.Add(buff[startpos + n * mSize]);

    1688. 

  1688.                                         _setValueProp = values.ToArray();

    1689. 

  1689.                                         break;

    1690. 

  1690.                                     }                                                                        

    1691. 

  1691.                                 case TagDataType.SByte:

    1692. 

  1692.                                     {

    1693. 

  1693.                                         var values = new List<SByte>();

    1694. 

  1694.                                         var mSize = _internalGetBaseTypeSize();

    1695. 

  1695.                                         for (int n = 0; n < ArraySize; n++) 

    1696. 

  1696.                                             values.Add(libnodave.getS8from(buff, startpos + n * mSize));

    1697. 

  1697.                                         _setValueProp = values.ToArray();

    1698. 

  1698.                                         break;

    1699. 

  1699.                                     }                                     

    1700. 

  1700.                                 case TagDataType.Time:

    1701. 

  1701.                                     {

    1702. 

  1702.                                         var values = new List<TimeSpan>();

    1703. 

  1703.                                         var mSize = _internalGetBaseTypeSize();

    1704. 

  1704.                                         for (int n = 0; n < ArraySize; n++)

    1705. 

  1705.                                             values.Add(libnodave.getTimefrom(buff, startpos + n * mSize));

    1706. 

  1706.                                         _setValueProp = values.ToArray();

    1707. 

  1707.                                         break;

    1708. 

  1708.                                     }                                     

    1709. 

  1709.                                 case TagDataType.Date:

    1710. 

  1710.                                     {

    1711. 

  1711.                                         var values = new List<DateTime>();

    1712. 

  1712.                                         var mSize = _internalGetBaseTypeSize();

    1713. 

  1713.                                         for (int n = 0; n < ArraySize; n++)

    1714. 

  1714.                                             values.Add(libnodave.getDatefrom(buff, startpos + n * mSize));

    1715. 

  1715.                                         _setValueProp = values.ToArray();

    1716. 

  1716.                                         break;

    1717. 

  1717.                                     } 

    1718. 

  1718.                                 case TagDataType.TimeOfDay:

    1719. 

  1719.                                     {

    1720. 

  1720.                                         var values = new List<DateTime>();

    1721. 

  1721.                                         var mSize = _internalGetBaseTypeSize();

    1722. 

  1722.                                         for (int n = 0; n < ArraySize; n++)

    1723. 

  1723.                                             values.Add(libnodave.getTimeOfDayfrom(buff, startpos + n * mSize));

    1724. 

  1724.                                         _setValueProp = values.ToArray();

    1725. 

  1725.                                         break;

    1726. 

  1726.                                     } 

    1727. 

  1727.                                 case TagDataType.Word:

    1728. 

  1728.                                     {

    1729. 

  1729.                                         var values = new List<UInt16>();

    1730. 

  1730.                                         var mSize = _internalGetBaseTypeSize();

    1731. 

  1731.                                         for (int n = 0; n < ArraySize; n++)

    1732. 

  1732.                                             values.Add(libnodave.getU16from(buff, startpos + n * mSize));

    1733. 

  1733.                                         _setValueProp = values.ToArray();

    1734. 

  1734.                                         break;

    1735. 

  1735.                                     } 

    1736. 

  1736.                                 case TagDataType.BCDByte:

    1737. 

  1737.                                     {

    1738. 

  1738.                                         var values = new List<int>();

    1739. 

  1739.                                         var mSize = _internalGetBaseTypeSize();

    1740. 

  1740.                                         for (int n = 0; n < ArraySize; n++)

    1741. 

  1741.                                             values.Add(libnodave.getBCD8from(buff, startpos + n * mSize));

    1742. 

  1742.                                         _setValueProp = values.ToArray();

    1743. 

  1743.                                         break;

    1744. 

  1744.                                     } 

    1745. 

  1745.                                 case TagDataType.Int:

    1746. 

  1746.                                     {

    1747. 

  1747.                                         var values = new List<Int16>();

    1748. 

  1748.                                         var mSize = _internalGetBaseTypeSize();

    1749. 

  1749.                                         for (int n = 0; n < ArraySize; n++)

    1750. 

  1750.                                             values.Add(libnodave.getS16from(buff, startpos + n * mSize));

    1751. 

  1751.                                         _setValueProp = values.ToArray();

    1752. 

  1752.                                         break;

    1753. 

  1753.                                     } 

    1754. 

  1754.                                 case TagDataType.S5Time:

    1755. 

  1755.                                     {

    1756. 

  1756.                                         var values = new List<TimeSpan>();

    1757. 

  1757.                                         var mSize = _internalGetBaseTypeSize();

    1758. 

  1758.                                         for (int n = 0; n < ArraySize; n++)

    1759. 

  1759.                                             values.Add(libnodave.getS5Timefrom(buff, startpos + n * mSize));

    1760. 

  1760.                                         _setValueProp = values.ToArray();

    1761. 

  1761.                                         break;

    1762. 

  1762.                                     } 

    1763. 

  1763.                                 case TagDataType.BCDWord:

    1764. 

  1764.                                     {

    1765. 

  1765.                                         var values = new List<Int32>();

    1766. 

  1766.                                         var mSize = _internalGetBaseTypeSize();

    1767. 

  1767.                                         for (int n = 0; n < ArraySize; n++)

    1768. 

  1768.                                             values.Add(libnodave.getBCD16from(buff, startpos + n * mSize));

    1769. 

  1769.                                         _setValueProp = values.ToArray();

    1770. 

  1770.                                         break;

    1771. 

  1771.                                     } 

    1772. 

  1772.                                 case TagDataType.BCDDWord:

    1773. 

  1773.                                     {

    1774. 

  1774.                                         var values = new List<Int32>();

    1775. 

  1775.                                         var mSize = _internalGetBaseTypeSize();

    1776. 

  1776.                                         for (int n = 0; n < ArraySize; n++)

    1777. 

  1777.                                             values.Add(libnodave.getBCD32from(buff, startpos + n * mSize));

    1778. 

  1778.                                         _setValueProp = values.ToArray();

    1779. 

  1779.                                         break;

    1780. 

  1780.                                     } 

    1781. 

  1781.                                 case TagDataType.Dint:

    1782. 

  1782.                                     {

    1783. 

  1783.                                         var values = new List<Int32>();

    1784. 

  1784.                                         var mSize = _internalGetBaseTypeSize();

    1785. 

  1785.                                         for (int n = 0; n < ArraySize; n++)

    1786. 

  1786.                                             values.Add(libnodave.getS32from(buff, startpos + n * mSize));

    1787. 

  1787.                                         _setValueProp = values.ToArray();

    1788. 

  1788.                                         break;

    1789. 

  1789.                                     } 

    1790. 

  1790.                                 case TagDataType.Dword:

    1791. 

  1791.                                     {

    1792. 

  1792.                                         var values = new List<UInt32>();

    1793. 

  1793.                                         var mSize = _internalGetBaseTypeSize();

    1794. 

  1794.                                         for (int n = 0; n < ArraySize; n++)

    1795. 

  1795.                                             values.Add(libnodave.getU32from(buff, startpos + n * mSize));

    1796. 

  1796.                                         _setValueProp = values.ToArray();

    1797. 

  1797.                                         break;

    1798. 

  1798.                                     } 

    1799. 

  1799.                                 case TagDataType.Float:

    1800. 

  1800.                                     {

    1801. 

  1801.                                         var values = new List<float>();

    1802. 

  1802.                                         var mSize = _internalGetBaseTypeSize();

    1803. 

  1803.                                         for (int n = 0; n < ArraySize; n++)

    1804. 

  1804.                                             values.Add(libnodave.getFloatfrom(buff, startpos + n * mSize));

    1805. 

  1805.                                         _setValueProp = values.ToArray();

    1806. 

  1806.                                         break;

    1807. 

  1807.                                     } 

    1808. 

  1808.                                 case TagDataType.DateTime:

    1809. 

  1809.                                     {

    1810. 

  1810.                                         var values = new List<DateTime>();

    1811. 

  1811.                                         var mSize = _internalGetBaseTypeSize();

    1812. 

  1812.                                         for (int n = 0; n < ArraySize; n++)

    1813. 

  1813.                                             values.Add(libnodave.getDateTimefrom(buff, startpos + n * mSize));

    1814. 

  1814.                                         _setValueProp = values.ToArray();

    1815. 

  1815.                                         break;

    1816. 

  1816.                                     } 

    1817. 

  1817.                             }

    1818. 

  1818.                         }

    1819. 

  1819.                     }

    1820. 

  1820.                     break;                

    1821. 

  1821.             }

    1822. 

  1822. 

    1823. 

  1823.         }

    1824. 

  1824. 

    1825. 

  1825.         [XmlIgnore]

    1826. 

  1826.         public int ReadByteSize { get { return _internalGetSize(); } }

    1827. 

  1827. 

    1828. 

  1828.         internal virtual int _internalGetSize()

    1829. 

  1829.         {            

    1830. 

  1830.             switch (this.TagDataType)

    1831. 

  1831.             {

    1832. 

  1832.                 case TagDataType.String:

    1833. 

  1833.                     return ArraySize + 2;                   

    1834. 

  1834.                 case TagDataType.CharArray:

    1835. 

  1835.                 case TagDataType.ByteArray:

    1836. 

  1836.                     return ArraySize;                    

    1837. 

  1837.                 case TagDataType.Byte:

    1838. 

  1838.                 case TagDataType.SByte:

    1839. 

  1839.                 case TagDataType.BCDByte:                                       

    1840. 

  1840.                 case TagDataType.Word:                

    1841. 

  1841.                 case TagDataType.BCDWord:

    1842. 

  1842.                 case TagDataType.Int:

    1843. 

  1843.                 case TagDataType.S5Time:

    1844. 

  1844.                 case TagDataType.Date:                                          

    1845. 

  1845.                 case TagDataType.Dint:

    1846. 

  1846.                 case TagDataType.Dword:

    1847. 

  1847.                 case TagDataType.Time:                

    1848. 

  1848.                 case TagDataType.TimeOfDay:

    1849. 

  1849.                 case TagDataType.Float: 

    1850. 

  1850.                 case TagDataType.BCDDWord:                    

    1851. 

  1851.                 case TagDataType.DateTime:

    1852. 

  1852.                     return _internalGetBaseTypeSize() * ArraySize;

    1853. 

  1853.                 case TagDataType.Bool:

    1854. 

  1854.                     {

    1855. 

  1855.                         var akbyte = 1;

    1856. 

  1856.                         var akBit = BitAddress;

    1857. 

  1857.                         for (int i = 0; i < ArraySize; i++)

    1858. 

  1858.                         {

    1859. 

  1859.                             if (akBit > 7)

    1860. 

  1860.                             {

    1861. 

  1861.                                 akbyte++;

    1862. 

  1862.                                 akBit = 0;

    1863. 

  1863.                             }

    1864. 

  1864.                             akBit++;

    1865. 

  1865.                         }

    1866. 

  1866.                         return akbyte;

    1867. 

  1867.                     }

    1868. 

  1868.             }

    1869. 

  1869.             return 0;

    1870. 

  1870.         }

    1871. 

  1871. 

    1872. 

  1872.         internal virtual int _internalGetBaseTypeSize()

    1873. 

  1873.         {

    1874. 

  1874.             switch (this.TagDataType)

    1875. 

  1875.             {

    1876. 

  1876.                 case TagDataType.Byte:

    1877. 

  1877.                 case TagDataType.SByte:

    1878. 

  1878.                 case TagDataType.BCDByte:

    1879. 

  1879.                     return 1;

    1880. 

  1880.                 case TagDataType.Word:

    1881. 

  1881.                 case TagDataType.BCDWord:

    1882. 

  1882.                 case TagDataType.Int:

    1883. 

  1883.                 case TagDataType.S5Time:

    1884. 

  1884.                 case TagDataType.Date:

    1885. 

  1885.                     return 2;

    1886. 

  1886.                 case TagDataType.Dint:

    1887. 

  1887.                 case TagDataType.Dword:

    1888. 

  1888.                 case TagDataType.Time:

    1889. 

  1889.                 case TagDataType.TimeOfDay:

    1890. 

  1890.                 case TagDataType.Float:

    1891. 

  1891.                 case TagDataType.BCDDWord:

    1892. 

  1892.                     return 4;

    1893. 

  1893.                 case TagDataType.DateTime:

    1894. 

  1894.                     return 8;

    1895. 

  1895.             }

    1896. 

  1896.             return 0;

    1897. 

  1897.         }

    1898. 

  1898. 

    1899. 

  1899.         #region Events for Tag Checking 

    1900. 

  1900. 

    1901. 

  1901.         private bool _raiseValueChangedOnFirstRead = true;

    1902. 

  1902.         public bool RaiseValueChangedOnFirstRead

    1903. 

  1903.         {

    1904. 

  1904.             get { return _raiseValueChangedOnFirstRead; }

    1905. 

  1905.             set { _raiseValueChangedOnFirstRead = value; }

    1906. 

  1906.         }

    1907. 

  1907. 

    1908. 

  1908.         public delegate void ValueChangedEventHandler(PLCTag Sender, ValueChangedEventArgs e);

    1909. 

  1909.         public class ValueChangedEventArgs

    1910. 

  1910.         {

    1911. 

  1911.             public ValueChangedEventArgs(object OldValue, object NewValue)

    1912. 

  1912.             {

    1913. 

  1913.                 this.OldValue = OldValue;

    1914. 

  1914.                 this.NewValue = NewValue;

    1915. 

  1915.             }

    1916. 

  1916.             public object OldValue;

    1917. 

  1917.             public object NewValue;

    1918. 

  1918.         }

    1919. 

  1919.         public event ValueChangedEventHandler ValueChanged;

    1920. 

  1920. 

    1921. 

  1921.         public object Maximum { get; set; }

    1922. 

  1922.         public object Minimum { get; set; }

    1923. 

  1923. 

    1924. 

  1924.         public delegate void LimitReachedEventHandler(PLCTag Sender, LimitReachedEventArgs e);

    1925. 

  1925.         public class LimitReachedEventArgs

    1926. 

  1926.         {

    1927. 

  1927.             public LimitReachedEventArgs(object Value, object Limit)

    1928. 

  1928.             {

    1929. 

  1929.                 this.Value = Value;

    1930. 

  1930.                 this.Limit = Limit;

    1931. 

  1931.             }

    1932. 

  1932.             public object Value;

    1933. 

  1933.             public object Limit;

    1934. 

  1934.         }

    1935. 

  1935.         public event LimitReachedEventHandler MaximumReached;

    1936. 

  1936.         public event LimitReachedEventHandler MinimumReached;

    1937. 

  1937. 

    1938. 

  1938.         #endregion

    1939. 

  1939. 

    1940. 

  1940.         #region PropertyChanged

    1941. 

  1941. 

    1942. 

  1942.         public event PropertyChangedEventHandler PropertyChanged;

    1943. 

  1943. 

    1944. 

  1944.         protected void NotifyPropertyChanged(String info)

    1945. 

  1945.         {

    1946. 

  1946.             if (PropertyChanged != null)

    1947. 

  1947.             {

    1948. 

  1948.                 PropertyChanged(this, new PropertyChangedEventArgs(info));

    1949. 

  1949.             }

    1950. 

  1950.         }

    1951. 

  1951. 

    1952. 

  1952.         #endregion

    1953. 

  1953. 

    1954. 

  1954.     }                   

    1955. 

  1955. }
    1956.