SimenssPlc.cs 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Threading;
  5. using Houdar.PLC.Driver.Simenss.Communication;
  6. using Houdar.PLC.Driver.Simenss.Protocol.Common;
  7. using Houdar.PLC.Driver.Simenss.Protocol.Iso;
  8. using Houdar.PLC.Driver.Simenss.Protocol.Negotiate;
  9. using Houdar.PLC.Driver.Simenss.Protocol.ReadData;
  10. using Houdar.PLC.Driver.Simenss.Protocol.Szl;
  11. using Houdar.PLC.Driver.Simenss.ProtocolHandle;
  12. using Houdar.PLC.Driver.Simenss;
  13. namespace Houdar.PLC.Driver.Simenss
  14. {
  15. public class SimenssPlc
  16. {
  17. public ConnectionType ConnectionType { get; private set; }
  18. public ushort SrcRef { get; set; }
  19. public ushort DstRef { get; set; }
  20. public ushort SrcTSap { get; private set; }
  21. public ushort DstTSap { get; private set; }
  22. public ushort PduRequest { get; set; }
  23. public int RecvTimeout { get; set; }
  24. public int RemotePort { get; set; }
  25. public int IsoPduSize { get; set; }
  26. // ReSharper disable once InconsistentNaming
  27. public string IP { get; private set; }
  28. public bool Connected { get
  29. {
  30. if (_socket == null) return false;
  31. return _socket.Connected;
  32. }
  33. }
  34. private Action<Houdar.PLC.Driver.Simenss.MessageEvent> _onMessageEvent;
  35. private readonly IsoSocket _socket;
  36. public SimenssPlc()
  37. {
  38. _socket = new IsoSocket();
  39. PduRequest = 480;
  40. IsoPduSize = 1024*4;
  41. RecvTimeout = 3000;
  42. RemotePort = 102;
  43. SrcRef = 0x0001; // RFC0983 states that SrcRef and DetRef should be 0
  44. // and, in any case, they are ignored.
  45. // S7 instead requires a number != 0
  46. // Libnodave uses 0x0100
  47. // S7Manager uses 0x0D00
  48. // TIA Portal V12 uses 0x1D00
  49. // WinCC uses 0x0300
  50. // Seems that every non zero value is good enough...
  51. DstRef = 0x0000;
  52. SrcTSap = 0x0100;
  53. DstTSap = 0x0000; // It's filled by connection functions
  54. ConnectionType = ConnectionType.PG;
  55. }
  56. #region 连接
  57. public void RegisterMessageEvent(Action<MessageEvent> messageAction)
  58. {
  59. if (messageAction == null) throw new ArgumentNullException("messageAction");
  60. _onMessageEvent = messageAction;
  61. }
  62. private void OnMessage(string method, string message)
  63. {
  64. if(_onMessageEvent!=null)
  65. _onMessageEvent.Invoke(new MessageEvent(method, message));
  66. }
  67. public void SetConnectionType(ConnectionType connectionType)
  68. {
  69. ConnectionType = connectionType;
  70. }
  71. public void SetConnectionParams(string ip, ushort localTsap, ushort remoteTsap)
  72. {
  73. SrcTSap = localTsap;
  74. DstTSap = remoteTsap;
  75. IP = ip;
  76. }
  77. public bool ConnectTo(string ip, int rack, int slot)
  78. {
  79. var remoteTsap = (ushort)(((ushort)ConnectionType << 8) + (rack * 0x20) + slot);
  80. SetConnectionParams(ip, SrcTSap, remoteTsap);
  81. return Connect();
  82. }
  83. //暂时用系统SOCKET测试
  84. private int _connecting;//连接中
  85. private int _processing;//处理中
  86. private string _processMehtod;
  87. public bool Connect()
  88. {
  89. try
  90. {
  91. if (Interlocked.CompareExchange(ref _connecting, 1, 0) != 0) return false;
  92. OnMessage("Connect", "正在连接");
  93. if (!_socket.Connect(IP, 102)) return false;
  94. IsoControlPduHandle pduHandle = new IsoControlPduHandle()
  95. {
  96. IsoPduSize = IsoPduSize,
  97. DstRef = DstRef,
  98. DstTSap = DstTSap,
  99. SrcRef = SrcRef,
  100. SrcTSap = SrcTSap
  101. };
  102. pduHandle.Handle(_socket);
  103. if (pduHandle.ResultCode == ResultCode.OK)
  104. {
  105. NegotiateHandle negotiateHandle = new NegotiateHandle() { PduRequest = PduRequest };
  106. negotiateHandle.Handle(_socket);
  107. if (negotiateHandle.ResultCode == ResultCode.OK)
  108. {
  109. PduRequest = negotiateHandle.Responses[0].Params.PduLength;
  110. return true;
  111. }
  112. else
  113. {
  114. OnMessage("Connect", "PDU握手失败");
  115. }
  116. }
  117. else
  118. {
  119. OnMessage("Connect", "PDU握手失败");
  120. }
  121. }
  122. catch (Exception ex)
  123. {
  124. OnMessage("Connect", ex.Message);
  125. }
  126. finally
  127. {
  128. Interlocked.CompareExchange(ref _connecting, 0, 1);
  129. }
  130. return false;
  131. }
  132. #endregion
  133. public bool GetLock(string method)
  134. {
  135. if (Interlocked.CompareExchange(ref _processing, 1, 0) != 0)
  136. {
  137. OnMessage(method, "执行失败,{_processMehtod}处理正在执行中");
  138. return false;
  139. }
  140. _processMehtod = method;
  141. return true;
  142. }
  143. public bool ReleaseLock()
  144. {
  145. _processMehtod = "";
  146. return Interlocked.CompareExchange(ref _processing, 0, 1) == 0;
  147. }
  148. #region [System Info functions]
  149. private SzlResponse ReadSzlHelper(SzlCmd szlcmd)
  150. {
  151. SzlHandle handle = new SzlHandle { SzlCmd = szlcmd };
  152. handle.Handle(_socket);
  153. return handle.SzlResponseFirst;
  154. }
  155. public SzlResponse ReadSzl(SzlCmd szlcmd)
  156. {
  157. if (!GetLock("ReadSzl"))
  158. {
  159. return null;
  160. }
  161. try
  162. {
  163. SzlHandle handle = new SzlHandle { SzlCmd = szlcmd };
  164. handle.Handle(_socket);
  165. OnMessage("ReadSzl", "{handle.ResultCode}");
  166. return handle.SzlResponseFirst;
  167. }
  168. catch (Exception ex)
  169. {
  170. OnMessage("ReadSzl", ex.Message);
  171. }
  172. finally
  173. {
  174. ReleaseLock();
  175. }
  176. return null;
  177. }
  178. public OrderInfo GetOrderCode()
  179. {
  180. OrderInfo orderCode = new OrderInfo();
  181. if (!GetLock("GetOrderCode"))
  182. {
  183. return orderCode;
  184. }
  185. try
  186. {
  187. var aaaa = ReadSzlHelper(SzlInfo.OrderCode);
  188. OnMessage("GetOrderCode", aaaa.Params.Err.ToString());
  189. if (aaaa.Params.Err != ResultCode.OK)
  190. return orderCode;
  191. orderCode.Code = Encoding.UTF8.GetString(aaaa.Data.Data, 2, 20);
  192. orderCode.V1 = aaaa.Data.Data[aaaa.Data.Data.Length - 3];
  193. orderCode.V2 = aaaa.Data.Data[aaaa.Data.Data.Length - 2];
  194. orderCode.V3 = aaaa.Data.Data[aaaa.Data.Data.Length - 1];
  195. return orderCode;
  196. }
  197. catch (Exception ex)
  198. {
  199. OnMessage("GetOrderCode", ex.Message);
  200. return orderCode;
  201. }
  202. finally
  203. {
  204. ReleaseLock();
  205. }
  206. }
  207. public CpuInfo GetCpuInfo()
  208. {
  209. CpuInfo cpuInfo = new CpuInfo();
  210. if (!GetLock("GetCpuInfo"))
  211. return cpuInfo;
  212. try
  213. {
  214. var aaaa = ReadSzlHelper(SzlInfo.CpuInfo);
  215. OnMessage("GetCpuInfo", aaaa.Params.Err.ToString());
  216. if (aaaa.Params.Err != ResultCode.OK)
  217. return cpuInfo;
  218. cpuInfo.ModuleTypeName = Encoding.UTF8.GetString(aaaa.Data.Data, 172, 32).TrimEnd('\0');
  219. cpuInfo.SerialNumber = Encoding.UTF8.GetString(aaaa.Data.Data, 138, 24).TrimEnd('\0');
  220. cpuInfo.AsName = Encoding.UTF8.GetString(aaaa.Data.Data, 2, 24).TrimEnd('\0');
  221. cpuInfo.Copyright = Encoding.UTF8.GetString(aaaa.Data.Data, 104, 26).TrimEnd('\0');
  222. cpuInfo.ModuleName = Encoding.UTF8.GetString(aaaa.Data.Data, 36, 24).TrimEnd('\0');
  223. }
  224. catch (Exception ex)
  225. {
  226. OnMessage("GetCpuInfo", ex.Message);
  227. }
  228. finally
  229. {
  230. ReleaseLock();
  231. }
  232. return cpuInfo;
  233. }
  234. public CpInfo GetCpInfo()
  235. {
  236. CpInfo info = new CpInfo();
  237. if (!GetLock("GetCpuInfo"))
  238. return info;
  239. try
  240. {
  241. var aaaa = ReadSzlHelper(SzlInfo.CpInfo);
  242. OnMessage("GetCpInfo", aaaa.Params.Err.ToString());
  243. if (aaaa.Params.Err != ResultCode.OK)
  244. return info;
  245. info.MaxPduLengt = DWordAt(aaaa.Data.Data, 2, 2);
  246. //aaaa.ResDataFirst.Data[2] * 256 + aaaa.ResDataFirst.Data[3];
  247. info.MaxConnections = DWordAt(aaaa.Data.Data, 4, 2);
  248. // aaaa.ResDataFirst.Data[4] * 256 + aaaa.ResDataFirst.Data[5];
  249. info.MaxMpiRate = DWordAt(aaaa.Data.Data, 6, 4);
  250. //aaaa.ResDataFirst.Data[6] * 256 + aaaa.ResDataFirst.Data[7];
  251. info.MaxBusRate = DWordAt(aaaa.Data.Data, 10, 4);
  252. //aaaa.ResDataFirst.Data[10] * 256 + aaaa.ResDataFirst.Data[7];
  253. }
  254. catch (Exception ex)
  255. {
  256. OnMessage("GetCpInfo", ex.Message);
  257. }
  258. finally
  259. {
  260. ReleaseLock();
  261. }
  262. return info;
  263. }
  264. #endregion
  265. private int DWordAt(byte[] buffer, int index, int length)
  266. {
  267. int value = 0;
  268. for (int i = 0; i < length; i++)
  269. {
  270. value = (value << 8) + buffer[index + i];
  271. }
  272. return value;
  273. }
  274. #region [Date/Time functions]
  275. public DateTime GetS7DateTime()
  276. {
  277. if (!GetLock("GetS7DateTime"))
  278. return DateTime.MinValue;
  279. try
  280. {
  281. GetDateTimeHandle handle = new GetDateTimeHandle();
  282. handle.Handle(_socket);
  283. OnMessage("GetS7DateTime", handle.ResultCode.ToString());
  284. if (handle.ResultCode == ResultCode.OK)
  285. {
  286. return handle.Response.GetDateTime();
  287. }
  288. else
  289. {
  290. return DateTime.MinValue;
  291. }
  292. }
  293. catch (Exception ex)
  294. {
  295. OnMessage("GetS7DateTime", ex.Message);
  296. return DateTime.MinValue;
  297. }
  298. finally
  299. {
  300. ReleaseLock();
  301. }
  302. }
  303. public bool SetS7DateTime(DateTime curDateTime)
  304. {
  305. if (!GetLock("SetS7DateTime"))
  306. return false;
  307. try
  308. {
  309. SetDateTimeHandle handle = new SetDateTimeHandle { DateTime = curDateTime };
  310. handle.Handle(_socket);
  311. OnMessage("SetS7DateTime", handle.ResultCode.ToString());
  312. return handle.ResultCode == ResultCode.OKFF;
  313. }
  314. catch (Exception ex)
  315. {
  316. OnMessage("SetS7DateTime", ex.Message);
  317. return false;
  318. }
  319. finally
  320. {
  321. ReleaseLock();
  322. }
  323. }
  324. #endregion
  325. #region [Control functions]
  326. public S7CpuStatus GetPlcStatus()
  327. {
  328. S7CpuStatus status = S7CpuStatus.Unknown;
  329. if (!GetLock("GetPlcStatus"))
  330. {
  331. return status;
  332. }
  333. try
  334. {
  335. SzlResponse first = ReadSzlHelper(SzlInfo.PlcStatus);
  336. OnMessage("GetPlcStatus", first.Params.Err.ToString());
  337. if (first.Params.Err == ResultCode.OK)
  338. {
  339. status = (S7CpuStatus)first.Data.Data[3];
  340. if (status != S7CpuStatus.Run)
  341. status = S7CpuStatus.Stop;
  342. }
  343. return status;
  344. }
  345. catch (Exception ex)
  346. {
  347. OnMessage("GetPlcStatus", ex.Message);
  348. return status;
  349. }
  350. finally
  351. {
  352. ReleaseLock();
  353. }
  354. }
  355. public bool PlcStop()
  356. {
  357. if (!GetLock("PlcStop"))
  358. return false;
  359. try
  360. {
  361. var handle = new PlcStopHandle();
  362. handle.Handle(_socket);
  363. OnMessage("PlcStop", handle.ResultCode.ToString());
  364. return handle.ResultCode == ResultCode.OK;
  365. }
  366. catch (Exception ex)
  367. {
  368. OnMessage("PlcStop", ex.Message);
  369. return false;
  370. }
  371. finally
  372. {
  373. ReleaseLock();
  374. }
  375. }
  376. public bool PlcHotStart()
  377. {
  378. if (!GetLock("PlcHotStart"))
  379. return false;
  380. try
  381. {
  382. var handle = new PlcHotStartHandle();
  383. handle.Handle(_socket);
  384. OnMessage("PlcHotStart", handle.ResultCode.ToString());
  385. return handle.ResultCode == ResultCode.OK;
  386. }
  387. catch (Exception ex)
  388. {
  389. OnMessage("PlcHotStart", ex.Message);
  390. return false;
  391. }
  392. finally
  393. {
  394. ReleaseLock();
  395. }
  396. }
  397. public bool PlcColdStart()
  398. {
  399. if (!GetLock("PlcColdStart"))
  400. return false;
  401. try
  402. {
  403. var handle = new PlcColdStartHandle();
  404. handle.Handle(_socket);
  405. OnMessage("PlcColdStart", handle.ResultCode.ToString());
  406. return handle.ResultCode == ResultCode.OK;
  407. }
  408. catch (Exception ex)
  409. {
  410. OnMessage("PlcColdStart", ex.Message);
  411. return false;
  412. }
  413. finally
  414. {
  415. ReleaseLock();
  416. }
  417. }
  418. public bool CopyRamToRom()
  419. {
  420. if (!GetLock("CopyRamToRom"))
  421. return false;
  422. try
  423. {
  424. var handle = new CopyRamToRomHandle();
  425. handle.Handle(_socket);
  426. OnMessage("CopyRamToRom", handle.ResultCode.ToString());
  427. return handle.ResultCode == ResultCode.OK;
  428. }
  429. catch (Exception ex)
  430. {
  431. OnMessage("CopyRamToRom", ex.Message);
  432. return false;
  433. }
  434. finally
  435. {
  436. ReleaseLock();
  437. }
  438. }
  439. public bool Compress()
  440. {
  441. if (!GetLock("Compress"))
  442. return false;
  443. try
  444. {
  445. var handle = new CompressHandle();
  446. handle.Handle(_socket);
  447. OnMessage("Compress", handle.Response.Header.Error.ToString());
  448. return handle.ResultCode == ResultCode.OK;
  449. }
  450. catch (Exception ex)
  451. {
  452. OnMessage("Compress", ex.Message);
  453. return false;
  454. }
  455. finally
  456. {
  457. ReleaseLock();
  458. }
  459. }
  460. #endregion
  461. #region [Security functions]
  462. public ProtectionInfo GetProtection()
  463. {
  464. ProtectionInfo info = new ProtectionInfo();
  465. if (!GetLock("GetProtection"))
  466. {
  467. return info;
  468. }
  469. try
  470. {
  471. var sss = ReadSzlHelper(SzlInfo.Protection);
  472. OnMessage("GetProtection", sss.Data.Ret.ToString());
  473. if (sss.Params.Err != ResultCode.OK) return info;
  474. info.SchSchal = (RWLevel)DWordAt(sss.Data.Data, 2, 2);
  475. info.SchPar = (ProtectionLevel)DWordAt(sss.Data.Data, 4, 2);
  476. info.SchRel = (CpuLevel)DWordAt(sss.Data.Data, 6, 2);
  477. info.BartSch = (RunStatus)DWordAt(sss.Data.Data, 8, 2);
  478. info.AnlSch = (StartupSwitch)DWordAt(sss.Data.Data, 10, 2);
  479. return info;
  480. }
  481. catch (Exception ex)
  482. {
  483. OnMessage("GetProtection", ex.Message);
  484. return info;
  485. }
  486. finally
  487. {
  488. ReleaseLock();
  489. }
  490. }
  491. public bool SetPwd(string password)
  492. {
  493. if (!GetLock("SetPwd")) return false;
  494. try
  495. {
  496. var handle = new SetPasswordHandle { Password = password };
  497. handle.Handle(_socket);
  498. OnMessage("SetPwd", handle.Response.Params.Err.ToString());
  499. return handle.ResultCode == ResultCode.OK;
  500. }
  501. catch (Exception ex)
  502. {
  503. OnMessage("SetPwd", ex.Message);
  504. return false;
  505. }
  506. finally
  507. {
  508. ReleaseLock();
  509. }
  510. }
  511. public bool ClearPwd()
  512. {
  513. if (!GetLock("ClearPwd")) return false;
  514. try
  515. {
  516. var handle = new SetPasswordHandle();
  517. handle.Handle(_socket);
  518. OnMessage("ClearPwd", handle.ResultCode.ToString());
  519. return handle.ResultCode == ResultCode.OK;
  520. }
  521. catch (Exception ex)
  522. {
  523. OnMessage("ClearPwd", ex.Message);
  524. return false;
  525. }
  526. finally
  527. {
  528. ReleaseLock();
  529. }
  530. }
  531. #endregion
  532. #region [Blocks]
  533. public ListBlocksHandle ListBlocks()
  534. {
  535. if (!GetLock("ListBlocks")) return null;
  536. try
  537. {
  538. var handle = new ListBlocksHandle();
  539. handle.Handle(_socket);
  540. OnMessage("ListBlocks", handle.ResultCode.ToString());
  541. return handle;
  542. }
  543. catch (Exception ex)
  544. {
  545. OnMessage("ListBlocks", ex.Message);
  546. return null;
  547. }
  548. finally
  549. {
  550. ReleaseLock();
  551. }
  552. }
  553. public DataBlockOfTypeHandle ListBlocksOfType(BlockType blockType)
  554. {
  555. if (!GetLock("ListBlocksOfType")) return null;
  556. try
  557. {
  558. var handle = new DataBlockOfTypeHandle();
  559. handle.BlockType = blockType;
  560. handle.Handle(_socket);
  561. OnMessage("ListBlocksOfType", handle.ResultCode.ToString());
  562. return handle;
  563. }
  564. catch (Exception ex)
  565. {
  566. OnMessage("ListBlocksOfType", ex.Message);
  567. return null;
  568. }
  569. finally
  570. {
  571. ReleaseLock();
  572. }
  573. }
  574. public DataBlockInfoHandle BlockInfoGet(ushort db, BlockType blockType)
  575. {
  576. if (!GetLock("BlockInfoHandle")) return null;
  577. try
  578. {
  579. var handle = new DataBlockInfoHandle();
  580. handle.BlockType = blockType;
  581. handle.DB = db;
  582. handle.Handle(_socket);
  583. OnMessage("BlockInfoHandle", handle.ResultCode.ToString());
  584. return handle;
  585. }
  586. catch (Exception ex)
  587. {
  588. OnMessage("BlockInfoHandle", ex.Message);
  589. return null;
  590. }
  591. finally
  592. {
  593. ReleaseLock();
  594. }
  595. }
  596. #endregion
  597. public DataItem ReadArea(AreaType area, ushort db, ushort start, ushort amount, DataType dataType)
  598. {
  599. if (!GetLock("ReadArea")) return null;
  600. try
  601. {
  602. var handle = new ReadHandle
  603. {
  604. PduLength = PduRequest,
  605. DataItem = new DataItem()
  606. {
  607. AreaType = area,
  608. Db = db,
  609. Start = start,
  610. Length = amount,
  611. DataType = dataType
  612. }
  613. };
  614. handle.Handle(_socket);
  615. OnMessage("ReadArea", handle.ResultCode.ToString());
  616. return handle.DataItem;
  617. }
  618. catch (Exception ex)
  619. {
  620. OnMessage("ReadArea", ex.Message);
  621. }
  622. finally
  623. {
  624. ReleaseLock();
  625. }
  626. return null;
  627. }
  628. public ReadMultiHandle ReadMulti(List<DataItem> items)
  629. {
  630. if (!GetLock("ReadMulti")) return null;
  631. try
  632. {
  633. var handle = new ReadMultiHandle { DataItem = items };
  634. handle.Handle(_socket);
  635. OnMessage("ReadMulti", handle.ResultCode.ToString());
  636. return handle;
  637. }
  638. catch (Exception ex)
  639. {
  640. OnMessage("ReadMulti", ex.Message);
  641. return null;
  642. }
  643. finally
  644. {
  645. ReleaseLock();
  646. }
  647. }
  648. public bool WriteArea(AreaType area, ushort db, uint start, ushort amount, DataType dataType, byte[] writeData)
  649. {
  650. if (!GetLock("WriteArea")) return false;
  651. try
  652. {
  653. var handle = new WriteHandle()
  654. {
  655. PduLength = PduRequest,
  656. DataItem = new DataItem()
  657. {
  658. AreaType = area,
  659. Db = db,
  660. Start = start,
  661. Length = amount,
  662. DataType = dataType,
  663. Data = writeData
  664. }
  665. };
  666. OnMessage("WriteArea", handle.ResultCode.ToString());
  667. handle.Handle(_socket);
  668. return handle.ResultCode == ResultCode.OK|| handle.ResultCode == ResultCode.OKFF;
  669. }
  670. catch (Exception ex)
  671. {
  672. OnMessage("WriteArea", ex.Message);
  673. return false;
  674. }
  675. finally
  676. {
  677. ReleaseLock();
  678. }
  679. }
  680. public WriteMultiHandle WriteMulti(List<DataItem> items)
  681. {
  682. if (!GetLock("WriteMulti")) return null;
  683. try
  684. {
  685. var handle = new WriteMultiHandle { DataItem = items };
  686. handle.Handle(_socket);
  687. OnMessage("WriteMulti", handle.ResultCode.ToString());
  688. return handle;
  689. }
  690. catch (Exception ex)
  691. {
  692. OnMessage("WriteMulti", ex.Message);
  693. return null;
  694. }
  695. finally
  696. {
  697. ReleaseLock();
  698. }
  699. }
  700. // ReSharper disable once InconsistentNaming
  701. public DataItem DBGet(ushort db)
  702. {
  703. //if (!GetLock("DBGet")) return null;
  704. try
  705. {
  706. var handle = new DataBlockInfoHandle();
  707. handle.BlockType = BlockType.DB;
  708. handle.DB = db;
  709. handle.Handle(_socket);
  710. if (handle.ResultCode == ResultCode.OK)
  711. {
  712. var res = ReadArea(AreaType.DB, handle.DB, 0, handle.Response.Data.Mc7Len, DataType.Byte);
  713. if (res.Err == ResultCode.OKFF)
  714. {
  715. return res;
  716. }
  717. OnMessage("DBGet", "ReadArea:{handle.ResultCode}");
  718. }
  719. else
  720. OnMessage("DBGet", "RequestBlock:{handle.ResultCode}");
  721. }
  722. catch (Exception ex)
  723. {
  724. OnMessage("DBGet", ex.Message);
  725. }
  726. //finally
  727. //{
  728. // ReleaseLock();
  729. //}
  730. return null;
  731. }
  732. // ReSharper disable once InconsistentNaming
  733. public bool DBFill(ushort db, byte value)
  734. {
  735. try
  736. {
  737. var handle = new DataBlockInfoHandle();
  738. handle.BlockType = BlockType.DB;
  739. handle.DB = db;
  740. handle.Handle(_socket);
  741. if (handle.ResultCode == ResultCode.OK)
  742. {
  743. byte[] datas = new byte[handle.Response.Data.Mc7Len];
  744. for (int i = 0; i < handle.Response.Data.Mc7Len; i++)
  745. {
  746. datas[i] = value;
  747. }
  748. return WriteArea(AreaType.DB, handle.DB, 0, handle.Response.Data.Mc7Len, DataType.Byte, datas);
  749. }
  750. else
  751. OnMessage("DBFill", "RequestBlock:{handle.ResultCode}");
  752. return false;
  753. }
  754. catch (Exception ex)
  755. {
  756. OnMessage("DBFill", ex.Message);
  757. return false;
  758. }
  759. //finally
  760. //{
  761. // ReleaseLock();
  762. //}
  763. }
  764. public bool UpLoad(BlockType blockType, ushort db, bool isFull)
  765. {
  766. UploadStartHandle handle = new UploadStartHandle();
  767. handle.BlockType = blockType;
  768. handle.BlockNum = db;
  769. handle.Handle(_socket);
  770. if (handle.ResultCode != ResultCode.OK)
  771. return false;
  772. UploadHandle handle1 = new UploadHandle();
  773. handle1.UploadID = handle.Response.Params.UploadID;
  774. handle1.Handle(_socket);
  775. return false;
  776. }
  777. }
  778. }