├── README.md
├── Program.cs
├── .gitattributes
├── MCCommand.cs
├── LICENSE
├── Properties
    └── AssemblyInfo.cs
├── Test.Designer.cs
├── Test.cs
├── Utility.cs
├── MCProtocolDriver.csproj
├── Test.resx
└── MCProtocolDriver.cs


/README.md:
--------------------------------------------------------------------------------
1 | # MCProtocolDriver
2 | For mitsubishi PLC
3 | 


--------------------------------------------------------------------------------
/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows.Forms;
 3 | 
 4 | namespace MCProtocolDriver
 5 | {
 6 |     class Program
 7 |     {
 8 |         [STAThread]
 9 |         static void Main()
10 |         {
11 |             Application.EnableVisualStyles();
12 |             Application.SetCompatibleTextRenderingDefault(false);
13 |             Application.Run(new Test());
14 |         }
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | 
 7 | # Standard to msysgit
 8 | *.doc	 diff=astextplain
 9 | *.DOC	 diff=astextplain
10 | *.docx diff=astextplain
11 | *.DOCX diff=astextplain
12 | *.dot  diff=astextplain
13 | *.DOT  diff=astextplain
14 | *.pdf  diff=astextplain
15 | *.PDF	 diff=astextplain
16 | *.rtf	 diff=astextplain
17 | *.RTF	 diff=astextplain
18 | 


--------------------------------------------------------------------------------
/MCCommand.cs:
--------------------------------------------------------------------------------
 1 | 
 2 | namespace SYN.BC.Driver.PLC.MCProtocolDriver
 3 | {
 4 |     public class MCCommand
 5 |     {
 6 |         //Command
 7 | 
 8 |         /// <summary>
 9 |         /// 成批讀取
10 |         /// </summary>
11 |         public const string BatchRead = "0401";
12 | 
13 |         /// <summary>
14 |         /// 成批寫入
15 |         /// </summary>
16 |         public const string BatchWrite = "1401";
17 | 
18 |         /// <summary>
19 |         /// 隨機讀取
20 |         /// </summary>
21 |         public const string RandomRead = "0403";
22 | 
23 |         /// <summary>
24 |         /// 隨機寫入
25 |         /// </summary>
26 |         public const string RandomWrite = "1402";
27 | 
28 |         //Sub Command
29 |         public const string Word = "0000";
30 |         public const string Bit = "0001";
31 | 
32 |         public enum CommunicationMode
33 |         {
34 |             Binary,
35 |             ASCII,
36 |         }
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Luke
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // 組件的一般資訊是由下列的屬性集控制。
 6 | // 變更這些屬性的值即可修改組件的相關
 7 | // 資訊。
 8 | [assembly: AssemblyTitle("MCProtocolDriver")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("")]
12 | [assembly: AssemblyProduct("MCProtocolDriver")]
13 | [assembly: AssemblyCopyright("Copyright ©  2017")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // 將 ComVisible 設定為 false 會使得這個組件中的類型
18 | // 對 COM 元件而言為不可見。如果您需要從 COM 存取這個組件中
19 | // 的類型，請在該類型上將 ComVisible 屬性設定為 true。
20 | [assembly: ComVisible(false)]
21 | 
22 | // 下列 GUID 為專案公開 (Expose) 至 COM 時所要使用的 typelib ID
23 | [assembly: Guid("b865e61b-39cc-4a3f-a679-f8a74cba19f3")]
24 | 
25 | // 組件的版本資訊由下列四個值所組成: 
26 | //
27 | //      主要版本
28 | //      次要版本 
29 | //      組建編號
30 | //      修訂編號
31 | //
32 | // 您可以指定所有的值，也可以依照以下的方式，使用 '*' 將組建和修訂編號
33 | // 指定為預設值: 
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 | 


--------------------------------------------------------------------------------
/Test.Designer.cs:
--------------------------------------------------------------------------------
 1 | namespace MCProtocolDriver
 2 | {
 3 |     partial class Test
 4 |     {
 5 |         /// <summary>
 6 |         /// Required designer variable.
 7 |         /// </summary>
 8 |         private System.ComponentModel.IContainer components = null;
 9 | 
10 |         /// <summary>
11 |         /// Clean up any resources being used.
12 |         /// </summary>
13 |         /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
14 |         protected override void Dispose(bool disposing)
15 |         {
16 |             if (disposing && (components != null))
17 |             {
18 |                 components.Dispose();
19 |             }
20 |             base.Dispose(disposing);
21 |         }
22 | 
23 |         #region Windows Form Designer generated code
24 | 
25 |         /// <summary>
26 |         /// Required method for Designer support - do not modify
27 |         /// the contents of this method with the code editor.
28 |         /// </summary>
29 |         private void InitializeComponent()
30 |         {
31 |             this.SuspendLayout();
32 |             // 
33 |             // Test
34 |             // 
35 |             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
36 |             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
37 |             this.ClientSize = new System.Drawing.Size(284, 262);
38 |             this.Name = "Test";
39 |             this.Text = "Test";
40 |             this.Load += new System.EventHandler(this.Test_Load);
41 |             this.ResumeLayout(false);
42 | 
43 |         }
44 | 
45 |         #endregion
46 |     }
47 | }


--------------------------------------------------------------------------------
/Test.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Windows.Forms;
 4 | using SYN.BC.Driver.PLC.MCProtocolDriver;
 5 | using SYN.BC.Core.Common;
 6 | using SYN.BC.Driver.PLC.Mitsubishi.MappingAnalysis;
 7 | 
 8 | namespace MCProtocolDriver
 9 | {
10 |     public partial class Test : Form
11 |     {
12 |         private MCProtocol _MCP;
13 | 
14 |         public Test()
15 |         {
16 |             InitializeComponent();
17 |         }
18 | 
19 |         private void Test_Load(object sender, EventArgs e)
20 |         {
21 |             try
22 |             {
23 |                 var Parameter = new List<ConstructorParameter>();
24 |                 Parameter.Add(new ConstructorParameter() { Name = "IP", Value = "192.168.2.102" });
25 |                 Parameter.Add(new ConstructorParameter() { Name = "Port", Value = "2005" });
26 | 
27 |                 _MCP = new MCProtocol(Parameter);
28 |                 _MCP.Ini();
29 |                 bool connect = _MCP.Connect();
30 |                 short[] read = new short[1];
31 |                 for (int i = 0; i < 10; i++)
32 |                 {
33 |                     int val = _MCP.ReadWordVal("0", 4000, ref read, "ZR");
34 |                     //_MCP.ReadBitVal("0", 5000, ref read, "B");
35 |                 }
36 | 
37 | 
38 |                 //short[] wriveval = MappingAnalysisUtility.HEXStringToShortArray("010203040506");
39 |                 //_MCP.WriteWordVal("0", wriveval.Length, wriveval, "W");
40 | 
41 |                 //short[] wriveval = MappingAnalysisUtility.BinStringToShortArray("1011010");
42 |                 //_MCP.WriteBitVal("0", wriveval.Length,wriveval,"M");
43 |                 _MCP.DisConnect();
44 |             }
45 |             catch (Exception ex)
46 |             {
47 |                 Console.WriteLine(ex.ToString());
48 |             }
49 |         }
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/Utility.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Linq;
 3 | using System.Text;
 4 | 
 5 | namespace SYN.BC.Driver.PLC.MCProtocolDriver
 6 | {
 7 |     public static class Utility
 8 |     {
 9 |         /// <summary>
10 |         /// 將byte[] 轉換成MC Protocol的string
11 |         /// </summary>
12 |         /// <param name="byteAry">byte array</param>
13 |         /// <returns>string</returns>
14 |         public static string ByteToMCString(byte[] byteAry)
15 |         {
16 |             StringBuilder sb = new StringBuilder();
17 |             for(int i = 0;i<=byteAry.Length - 1; i++)
18 |             {
19 |                 sb.Append((byteAry[i] / 16).ToString("X"));
20 |                 sb.Append((byteAry[i] % 16).ToString("X"));
21 |             }
22 |             return sb.ToString();
23 |         }
24 | 
25 |         public static byte[] HexStringToByteArray(string HexStr)
26 |         {
27 |             return Enumerable.Range(0, HexStr.Length)
28 |                                  .Where(x => x % 2 == 0)
29 |                                  .Select(x => Convert.ToByte(HexStr.Substring(x, 2), 16))
30 |                                  .ToArray();
31 |         }
32 | 
33 |         /// <summary>Swaps two bytes in a byte array</summary>
34 |         /// <param name="buf">The array in which elements are to be swapped</param>
35 |         /// <param name="i">The index of the first element to be swapped</param>
36 |         /// <param name="j">The index of the second element to be swapped</param>
37 |         public static void SwapBytes(this byte[] buf, int i, int j)
38 |         {
39 |             byte temp = buf[i];
40 |             buf[i] = buf[j];
41 |             buf[j] = temp;
42 |         }
43 | 
44 |         /// <summary>
45 |         /// 取得MC Protocol回傳的Code
46 |         /// </summary>
47 |         /// <param name="Str">MC Protocol回傳的字串</param>
48 |         /// <returns>Complete Code</returns>
49 |         public static string GetCompleteCode(string Str)
50 |         {
51 |             return Str?.Substring(18, 4);
52 |         }
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/MCProtocolDriver.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
 4 |   <PropertyGroup>
 5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 7 |     <ProjectGuid>{B865E61B-39CC-4A3F-A679-F8A74CBA19F3}</ProjectGuid>
 8 |     <OutputType>WinExe</OutputType>
 9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
10 |     <RootNamespace>MCProtocolDriver</RootNamespace>
11 |     <AssemblyName>MCProtocolDriver</AssemblyName>
12 |     <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
13 |     <FileAlignment>512</FileAlignment>
14 |   </PropertyGroup>
15 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
16 |     <DebugSymbols>true</DebugSymbols>
17 |     <DebugType>full</DebugType>
18 |     <Optimize>false</Optimize>
19 |     <OutputPath>bin\Debug\</OutputPath>
20 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
21 |     <ErrorReport>prompt</ErrorReport>
22 |     <WarningLevel>4</WarningLevel>
23 |   </PropertyGroup>
24 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
25 |     <DebugType>pdbonly</DebugType>
26 |     <Optimize>true</Optimize>
27 |     <OutputPath>bin\Release\</OutputPath>
28 |     <DefineConstants>TRACE</DefineConstants>
29 |     <ErrorReport>prompt</ErrorReport>
30 |     <WarningLevel>4</WarningLevel>
31 |   </PropertyGroup>
32 |   <PropertyGroup>
33 |     <StartupObject />
34 |   </PropertyGroup>
35 |   <ItemGroup>
36 |     <Reference Include="System" />
37 |     <Reference Include="System.Core" />
38 |     <Reference Include="System.Drawing" />
39 |     <Reference Include="System.Windows.Forms" />
40 |     <Reference Include="System.Xml.Linq" />
41 |     <Reference Include="System.Data.DataSetExtensions" />
42 |     <Reference Include="Microsoft.CSharp" />
43 |     <Reference Include="System.Data" />
44 |     <Reference Include="System.Net.Http" />
45 |     <Reference Include="System.Xml" />
46 |   </ItemGroup>
47 |   <ItemGroup>
48 |     <Compile Include="MCCommand.cs" />
49 |     <Compile Include="MCProtocolDriver.cs" />
50 |     <Compile Include="Program.cs" />
51 |     <Compile Include="Properties\AssemblyInfo.cs" />
52 |     <Compile Include="Test.cs">
53 |       <SubType>Form</SubType>
54 |     </Compile>
55 |     <Compile Include="Test.Designer.cs">
56 |       <DependentUpon>Test.cs</DependentUpon>
57 |     </Compile>
58 |     <Compile Include="Utility.cs" />
59 |   </ItemGroup>
60 |   <ItemGroup>
61 |     <ProjectReference Include="..\Core\Core.csproj">
62 |       <Project>{0d3e1e22-4788-4f80-9eed-851dfbe30e2a}</Project>
63 |       <Name>Core</Name>
64 |     </ProjectReference>
65 |     <ProjectReference Include="..\MappingAnalysis\MappingAnalysis.csproj">
66 |       <Project>{f66667b7-2d75-412e-92e5-7d86e3411aab}</Project>
67 |       <Name>MappingAnalysis</Name>
68 |     </ProjectReference>
69 |     <ProjectReference Include="..\PLC\PLC.csproj">
70 |       <Project>{d2bd1fba-7398-47c6-824a-5701b09c3605}</Project>
71 |       <Name>PLC</Name>
72 |     </ProjectReference>
73 |   </ItemGroup>
74 |   <ItemGroup>
75 |     <EmbeddedResource Include="Test.resx">
76 |       <DependentUpon>Test.cs</DependentUpon>
77 |     </EmbeddedResource>
78 |   </ItemGroup>
79 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
80 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
81 |        Other similar extension points exist, see Microsoft.Common.targets.
82 |   <Target Name="BeforeBuild">
83 |   </Target>
84 |   <Target Name="AfterBuild">
85 |   </Target>
86 |   -->
87 | </Project>


--------------------------------------------------------------------------------
/Test.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
 64 |     <xsd:element name="root" msdata:IsDataSet="true">
 65 |       <xsd:complexType>
 66 |         <xsd:choice maxOccurs="unbounded">
 67 |           <xsd:element name="metadata">
 68 |             <xsd:complexType>
 69 |               <xsd:sequence>
 70 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 71 |               </xsd:sequence>
 72 |               <xsd:attribute name="name" use="required" type="xsd:string" />
 73 |               <xsd:attribute name="type" type="xsd:string" />
 74 |               <xsd:attribute name="mimetype" type="xsd:string" />
 75 |               <xsd:attribute ref="xml:space" />
 76 |             </xsd:complexType>
 77 |           </xsd:element>
 78 |           <xsd:element name="assembly">
 79 |             <xsd:complexType>
 80 |               <xsd:attribute name="alias" type="xsd:string" />
 81 |               <xsd:attribute name="name" type="xsd:string" />
 82 |             </xsd:complexType>
 83 |           </xsd:element>
 84 |           <xsd:element name="data">
 85 |             <xsd:complexType>
 86 |               <xsd:sequence>
 87 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 88 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 89 |               </xsd:sequence>
 90 |               <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
 91 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 92 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 93 |               <xsd:attribute ref="xml:space" />
 94 |             </xsd:complexType>
 95 |           </xsd:element>
 96 |           <xsd:element name="resheader">
 97 |             <xsd:complexType>
 98 |               <xsd:sequence>
 99 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
100 |               </xsd:sequence>
101 |               <xsd:attribute name="name" type="xsd:string" use="required" />
102 |             </xsd:complexType>
103 |           </xsd:element>
104 |         </xsd:choice>
105 |       </xsd:complexType>
106 |     </xsd:element>
107 |   </xsd:schema>
108 |   <resheader name="resmimetype">
109 |     <value>text/microsoft-resx</value>
110 |   </resheader>
111 |   <resheader name="version">
112 |     <value>2.0</value>
113 |   </resheader>
114 |   <resheader name="reader">
115 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 |   <resheader name="writer">
118 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
119 |   </resheader>
120 | </root>


--------------------------------------------------------------------------------
/MCProtocolDriver.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using System.Threading.Tasks;
  6 | using SYN.BC.Core.Common;
  7 | using System.Net.Sockets;
  8 | using System.Net;
  9 | using SYN.BC.Core.Log;
 10 | using System.Net.NetworkInformation;
 11 | using static SYN.BC.Driver.PLC.Utility;
 12 | using static SYN.BC.Core.Common.Constant;
 13 | using System.Threading;
 14 | 
 15 | namespace SYN.BC.Driver.PLC.MCProtocolDriver
 16 | {
 17 |     public class MCProtocol : AbstractPLCDriver
 18 |     {
 19 |         private Socket _SocketTCP;
 20 |         private IPEndPoint _TargetIPPort;
 21 |         private Task _task;
 22 |         private string _IP;
 23 |         private string _Port;
 24 |         private List<int> _PortList = new List<int>();
 25 |         private Logger _Logger;
 26 |         private Logger _DMLog;
 27 |         private ushort _ReconnectTime = 1000;
 28 | 
 29 |         private string _BasicFormat = "5000"; //ASCII Header(3E)
 30 |         private string _SubBasicFormat = "03FF00"; //請求目標模組 I/O 編號[03FF]  + 請求目標模組站號[00]
 31 |         private string _CPU_TimerStr = "0010";
 32 |         private string _NetNo="00";
 33 |         private string _PCNo = "FF";
 34 | 
 35 |         private const short _MAX_BIT_RW_POINT_ASCII = 3584; //ASCII模式Bit最大讀寫數量
 36 |         private const short _MAX_BIT_RW_POINT_BINARY = 7168; //Binary模式Bit最大讀寫數量
 37 |         private const short _MAX_WORD_RW_POINT = 960; //Word最大讀寫數量
 38 | 
 39 |         private MCCommand.CommunicationMode _Mode = MCCommand.CommunicationMode.ASCII;
 40 | 
 41 |         /// <summary>
 42 |         /// 建構MCProtocol
 43 |         /// </summary>
 44 |         /// <param name="para">參數</param>
 45 |         public MCProtocol(List<ConstructorParameter> para)
 46 |         {
 47 |             _IP = (from p in para
 48 |                         where p.Name == "IP"
 49 |                         select p.Value).FirstOrDefault();
 50 |             if (string.IsNullOrEmpty(_IP))
 51 |                 throw new Exception("[IP can not be empty!]");
 52 | 
 53 |             _Port = (from p in para
 54 |                    where p.Name == "Port"
 55 |                    select p.Value).FirstOrDefault();
 56 |             if (string.IsNullOrEmpty(_Port))
 57 |                 throw new Exception("[Port can not be empty!]");
 58 | 
 59 |             _PortList = _Port.Split(',').Select(x => Convert.ToInt32(x)).ToList();
 60 |             _Port = _PortList.First().ToString();
 61 | 
 62 |             string NetNo = (from p in para
 63 |                             where p.Name == "NetNo"
 64 |                             select p.Value).FirstOrDefault();
 65 |             if (!string.IsNullOrEmpty(NetNo)) { _NetNo = NetNo; }
 66 | 
 67 |             string PCNo = (from p in para
 68 |                             where p.Name == "PCNo"
 69 |                            select p.Value).FirstOrDefault();
 70 |             if (!string.IsNullOrEmpty(NetNo)) { _PCNo = PCNo; }
 71 |         }
 72 | 
 73 |         ~MCProtocol()
 74 |         {
 75 |             if (_SocketTCP != null && _SocketTCP.Connected) { Close(); }
 76 |         }
 77 | 
 78 |         /// <summary>
 79 |         /// 
 80 |         /// </summary>
 81 |         public override bool IsConnected
 82 |         {
 83 |             get
 84 |             {
 85 |                 if (_SocketTCP != null)
 86 |                     return _SocketTCP.Connected;
 87 |                 else
 88 |                     return false;
 89 |             }
 90 |         }
 91 | 
 92 |         /// <summary>
 93 |         /// Connect
 94 |         /// </summary>
 95 |         /// <returns>Result</returns>
 96 |         public override bool Connect()
 97 |         {
 98 |             try
 99 |             {
100 |                 _SocketTCP = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
101 |                 _SocketTCP.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, new LingerOption(false, 1));
102 |                 _SocketTCP.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 2500);
103 |                 _TargetIPPort = new IPEndPoint(IPAddress.Parse(_IP), int.Parse(_Port));
104 |                 //_SocketTCP?.Connect(_TargetIPPort);
105 | 
106 |                 IAsyncResult result = _SocketTCP.BeginConnect(_TargetIPPort, null, null);
107 |                 result.AsyncWaitHandle.WaitOne(1000, true);//只等1秒
108 | 
109 |                 if (!result.IsCompleted)
110 |                 {
111 |                     DisConnect();
112 |                 }
113 |                 //else if (_SocketTCP.Connected == true)
114 |                 //{
115 | 
116 |                 //}
117 | 
118 |                 //Start reconnect function
119 |                 if (_task.Status != TaskStatus.Running)
120 |                     _task.Start();
121 | 
122 |                 return _SocketTCP.Connected;
123 |             }
124 |             catch (Exception ex)
125 |             {
126 |                 _Logger.Error(ex);
127 |                 return false;
128 |             }
129 |         }
130 | 
131 |         /// <summary>
132 |         /// DisConnect
133 |         /// </summary>
134 |         /// <returns>Result</returns>
135 |         public override bool DisConnect()
136 |         {
137 |             try
138 |             {
139 |                 //_SocketTCP?.Shutdown(SocketShutdown.Both);
140 |                 _SocketTCP?.Close();
141 | 
142 |                 //_TcpClient?.Close();
143 |                 //_TcpClient = new TcpClient(AddressFamily.InterNetwork);
144 |                 return true;
145 |             }
146 |             catch(ObjectDisposedException)
147 |             {
148 |                 return true;
149 |             }
150 |             catch (Exception ex)
151 |             {
152 |                 throw ex;
153 |             }
154 |         }
155 | 
156 |         /// <summary>
157 |         /// Initial
158 |         /// </summary>
159 |         public override void Ini()
160 |         {
161 |             try
162 |             {
163 |                 _Logger = new Logger(nameof(MCProtocol));
164 |                 _DMLog = new Logger("DMLoger");
165 | 
166 |                 //Reconnect Function
167 |                 _task = new Task(() =>
168 |                 {
169 |                     while (true)
170 |                     {
171 |                         try
172 |                         {
173 |                             if (_SocketTCP != null && (!_SocketTCP.Connected || !PingIP(_IP)))
174 |                             {
175 |                                 _Port = Utility.getPortNo(_Port, _PortList).ToString();
176 |                                 _Logger.Warn(new LogMessage("", nameof(MCProtocol)) { Message = $"Reconnecting..., Port:{_Port}" });
177 |                                 DisConnect();
178 |                                 Connect();
179 |                             }
180 |                         }
181 |                         catch (Exception ex)
182 |                         {
183 |                             _Logger.Error(ex);
184 |                         }
185 |                         System.Threading.SpinWait.SpinUntil(() => false, _ReconnectTime);
186 |                     }
187 |                 });
188 | 
189 |             }
190 |             catch (Exception ex)
191 |             {
192 |                 throw ex;
193 |             }
194 |         }
195 | 
196 |         /// <summary>
197 |         /// Not Implemented
198 |         /// </summary>
199 |         /// <param name="Msg"></param>
200 |         /// <returns></returns>
201 |         public override long PutData(TransferMsg Msg)
202 |         {
203 |             throw new NotImplementedException();
204 |         }
205 | 
206 |         /// <summary>
207 |         /// 讀取Bit
208 |         /// </summary>
209 |         /// <param name="StartAddress">起始位址</param>
210 |         /// <param name="Size">大小</param>
211 |         /// <param name="Value">讀到的值</param>
212 |         /// <param name="Name">記憶體名稱</param>
213 |         /// <returns></returns>
214 |         public override int ReadBitVal(string StartAddress, int Size, ref short[] Value, string Name = "")
215 |         {
216 |             byte[] SendDataByte;
217 |             byte[] RecvDataByte = new byte[4999];
218 |             try
219 |             {
220 |                 if (string.IsNullOrEmpty(Name)) { throw new Exception("Device name can not be empty!"); }
221 |                 if (_SocketTCP == null)
222 |                     return -1;
223 | 
224 |                 int Address = int.Parse(StartAddress);
225 |                 int ReadAddress = Address;
226 |                 string ReadString = "";
227 |                 string Command = "";
228 |                 int ByteRead = -1;
229 |                 do
230 |                 {
231 |                     Command = CreateCommandString(MCCommand.BatchRead, MCCommand.Bit, Name, ReadAddress.ToString(), _MAX_BIT_RW_POINT_ASCII);
232 |                     ReadAddress += _MAX_BIT_RW_POINT_ASCII;
233 |                     SendDataByte = Encoding.ASCII.GetBytes(Command);
234 |                     _SocketTCP.Send(SendDataByte, SendDataByte.Length, SocketFlags.None);
235 |                     ByteRead = _SocketTCP.Receive(RecvDataByte, RecvDataByte.Length, SocketFlags.None);
236 |                     if (ByteRead > 0)
237 |                     {
238 |                         string RecvStr = Encoding.ASCII.GetString(RecvDataByte, 0, ByteRead);
239 |                         string CompleteCode = Utility.GetCompleteCode(RecvStr);
240 |                         if (CompleteCode != "0000") { return Convert.ToInt32(CompleteCode, 16); }
241 |                         ReadString += RecvStr.Substring(22);
242 |                     }
243 |                     else
244 |                     {
245 |                         _Logger.Error(new LogMessage("", nameof(MCProtocol)) { Message = $"Read Bit fail, name={Name}, Address={StartAddress}, Size={Size}" });
246 |                         return -1;
247 |                     }
248 |                 } while (ReadAddress < (Address + Size));
249 |                 Value = Enumerable.Range(0, Size).Select(x => short.Parse(ReadString[x].ToString())).ToArray();
250 |                 return 0;
251 |             }
252 |             catch (Exception ex)
253 |             {
254 |                 _Logger.Error(ex);
255 |                 throw ex;
256 |             }
257 |         }
258 | 
259 |         /// <summary>
260 |         /// Not Implemented
261 |         /// </summary>
262 |         /// <param name="StartAddress"></param>
263 |         /// <param name="Size"></param>
264 |         /// <param name="Value"></param>
265 |         /// <param name="Name"></param>
266 |         /// <returns></returns>
267 |         public override Task<int> ReadBitValAsync(string StartAddress, int Size, ref short[] Value, string Name = "")
268 |         {
269 |             throw new NotImplementedException();
270 |         }
271 | 
272 |         /// <summary>
273 |         /// 讀取Word
274 |         /// </summary>
275 |         /// <param name="StartAddress">起始位址</param>
276 |         /// <param name="Size">大小</param>
277 |         /// <param name="Value">讀到的值</param>
278 |         /// <param name="Name">記憶體名稱</param>
279 |         /// <returns>return complete code</returns>
280 |         public override int ReadWordVal(string StartAddress, int Size, ref short[] Value, string Name = "")
281 |         {
282 |             byte[] SendDataByte;
283 |             byte[] RecvDataByte= new byte[4999];
284 |             try
285 |             {
286 |                 if (string.IsNullOrEmpty(Name)) { throw new Exception("Device name can not be empty!"); }
287 | 
288 |                 int Address = int.Parse(StartAddress);
289 |                 int ReadAddress= Address;
290 |                 string ReadString = "";
291 |                 string Command = "";
292 |                 int ByteRead = -1;
293 |                 //do
294 |                 //{
295 |                 Command = CreateCommandString(MCCommand.BatchRead, MCCommand.Word, Name, ReadAddress.ToString(), Size);
296 |                 SendDataByte = Encoding.ASCII.GetBytes(Command);
297 |                 _SocketTCP?.Send(SendDataByte, SendDataByte.Length, SocketFlags.None);
298 |                 Thread.Sleep(1);
299 |                 ByteRead = _SocketTCP.Receive(RecvDataByte, RecvDataByte.Length, SocketFlags.None);
300 |                 if (ByteRead>0)
301 |                 {
302 |                     string RecvStr = Encoding.ASCII.GetString(RecvDataByte, 0, ByteRead);
303 |                     string CompleteCode = Utility.GetCompleteCode(RecvStr);
304 |                     if (CompleteCode != "0000") { return Convert.ToInt32(CompleteCode, 16); }
305 |                     ReadString += RecvStr.Substring(22);
306 |                 }
307 |                 else
308 |                 {
309 |                     _Logger.Error(new LogMessage("", nameof(MCProtocol)) { Message = $"Read Word fail, name={Name}, Address={StartAddress}, Size={Size}" });
310 |                     return -1;
311 |                 }
312 |                 //ReadAddress += _MAX_WORD_RW_POINT;
313 |                 //} while (ReadAddress < (Address + Size));
314 | 
315 |                 Value = HEXStringToShortArray(ReadString).Take(Size).ToArray();
316 |                 return 0;
317 |             }
318 |             catch(SocketException sex)
319 |             {
320 |                 _Logger.Info(new LogMessage("", nameof(MCProtocol)) { Direct = emDirect.H2E, Message = sex.ToString() });
321 |                 return -1;
322 |             }
323 |             catch (Exception ex)
324 |             {
325 |                 _Logger.Error(ex);
326 |                 throw ex;
327 |             }                
328 |         }
329 | 
330 |         /// <summary>
331 |         /// Not Implemented
332 |         /// </summary>
333 |         /// <param name="StartAddress"></param>
334 |         /// <param name="Size"></param>
335 |         /// <param name="Value"></param>
336 |         /// <param name="Name"></param>
337 |         /// <returns></returns>
338 |         public override Task<int> ReadWordValAsync(string StartAddress, int Size, ref short[] Value, string Name = "")
339 |         {
340 |             throw new NotImplementedException();
341 |         }
342 | 
343 |         public override long SetData(TransferMsg Msg)
344 |         {
345 |             throw new NotImplementedException();
346 |         }
347 | 
348 |         /// <summary>
349 |         /// 寫入Bit
350 |         /// </summary>
351 |         /// <param name="StartAddress">起始位址</param>
352 |         /// <param name="Size">寫入大小</param>
353 |         /// <param name="Value">寫入的值</param>
354 |         /// <param name="Name">記憶體名稱</param>
355 |         /// <returns>Return code</returns>
356 |         public override int WriteBitVal(string StartAddress, int Size, short[] Value, string Name = "")
357 |         {
358 |             byte[] WriteByte;
359 |             byte[] RecvDataByte = new byte[4999];
360 |             try
361 |             {
362 |                 if (string.IsNullOrEmpty(Name)) { throw new Exception("Device name can not be empty!"); }
363 |                 if (_SocketTCP == null)
364 |                     return -1;
365 | 
366 |                 int Address = int.Parse(StartAddress);
367 |                 var WriteAry = Value.Split(_MAX_BIT_RW_POINT_ASCII);
368 |                 var QArray = WriteAry.Select((val, idx) => new { Index = idx, Value = val });//產生index
369 |                 foreach (var WAry in QArray)
370 |                 {
371 |                     string WriteAddress = (Address + (WAry.Index * _MAX_BIT_RW_POINT_ASCII)).ToString();
372 |                     string Command = CreateCommandString(MCCommand.BatchWrite, MCCommand.Bit, Name, WriteAddress, WAry.Value.Count(), WAry.Value.ToArray());
373 |                     WriteByte = Encoding.ASCII.GetBytes(Command);
374 |                     _SocketTCP.Send(WriteByte, WriteByte.Length, SocketFlags.None);
375 |                     int RtnByte = _SocketTCP.Receive(RecvDataByte, RecvDataByte.Length, SocketFlags.None);
376 |                     if (RtnByte > 0)
377 |                     {
378 |                         string RecvStr = Encoding.ASCII.GetString(RecvDataByte, 0, RtnByte);
379 |                         string CompleteCode = Utility.GetCompleteCode(RecvStr);
380 |                         if (CompleteCode != "0000") { return Convert.ToInt32(CompleteCode, 16); }
381 |                     }
382 |                     else
383 |                     {
384 |                         _Logger.Error(new LogMessage("", nameof(MCProtocol)) { Message = $"Write Bit fail, name={Name}, Address={StartAddress}, Size={Size}" });
385 |                         return -1;
386 |                     }
387 |                 }
388 |                 return 0;
389 |             }
390 |             catch (Exception ex)
391 |             {
392 |                 _Logger.Error(ex);
393 |                 throw ex;
394 |             }
395 |         }
396 | 
397 |         /// <summary>
398 |         /// Not Implemented
399 |         /// </summary>
400 |         /// <param name="StartAddress"></param>
401 |         /// <param name="Size"></param>
402 |         /// <param name="Value"></param>
403 |         /// <param name="Name"></param>
404 |         /// <returns></returns>
405 |         public override Task<int> WriteBitValAsync(string StartAddress, int Size, short[] Value, string Name = "")
406 |         {
407 |             throw new NotImplementedException();
408 |         }
409 | 
410 |         /// <summary>
411 |         /// 寫入Word
412 |         /// </summary>
413 |         /// <param name="StartAddress">起始位址</param>
414 |         /// <param name="Size">寫入大小</param>
415 |         /// <param name="Value">寫入的值</param>
416 |         /// <param name="Name">記憶體名稱</param>
417 |         /// <returns>Return code</returns>
418 |         public override int WriteWordVal(string StartAddress, int Size, short[] Value, string Name = "")
419 |         {
420 |             byte[] WriteByte;
421 |             byte[] RecvDataByte = new byte[4999];
422 |             try
423 |             {
424 |                 if (string.IsNullOrEmpty(Name)) { throw new Exception("Device name can not be empty!"); }
425 | 
426 |                 int Address = (int)new System.ComponentModel.Int32Converter().ConvertFromString(StartAddress);
427 |                 var WriteAry = Value.Split(_MAX_WORD_RW_POINT);
428 |                 var QArray = WriteAry.Select((val, idx) => new { Index = idx, Value = val });//產生index
429 |                 foreach (var WAry in QArray)
430 |                 {
431 |                     string WriteAddress = (Address + (WAry.Index * _MAX_WORD_RW_POINT)).ToString();
432 |                     string Command = CreateCommandString(MCCommand.BatchWrite, MCCommand.Word, Name, WriteAddress, WAry.Value.Count(), WAry.Value.ToArray());
433 |                     WriteByte = Encoding.ASCII.GetBytes(Command);
434 |                     _SocketTCP?.Send(WriteByte, WriteByte.Length, SocketFlags.None);
435 |                     Thread.Sleep(1);
436 |                     int RtnByte = _SocketTCP.Receive(RecvDataByte, RecvDataByte.Length, SocketFlags.None);
437 |                     if (RtnByte > 0)
438 |                     {
439 |                         string RecvStr = Encoding.ASCII.GetString(RecvDataByte, 0, RtnByte);
440 |                         string CompleteCode = Utility.GetCompleteCode(RecvStr);
441 |                         if (CompleteCode != "0000") { return Convert.ToInt32(CompleteCode, 16); }
442 |                     }
443 |                     else
444 |                     {
445 |                         _Logger.Error(new LogMessage("", nameof(MCProtocol)) { Message = $"Write Word fail, name={Name}, Address={StartAddress}, Size={Size}" });
446 |                         return -1;
447 |                     }
448 |                 }
449 |                 return 0;
450 |             }
451 |             catch (Exception ex)
452 |             {
453 |                 _Logger.Error(ex);
454 |                 throw ex;
455 |             }
456 |         }
457 | 
458 |         /// <summary>
459 |         /// Not Implemented
460 |         /// </summary>
461 |         /// <param name="StartAddress"></param>
462 |         /// <param name="Size"></param>
463 |         /// <param name="Value"></param>
464 |         /// <param name="Name"></param>
465 |         /// <returns></returns>
466 |         public override Task<int> WriteWordValAsync(string StartAddress, int Size, short[] Value, string Name = "")
467 |         {
468 |             throw new NotImplementedException();
469 |         }
470 | 
471 |         /// <summary>
472 |         /// ASCII Mode
473 |         /// </summary>
474 |         /// <param name="command"></param>
475 |         /// <param name="subcommand"></param>
476 |         /// <param name="DeviceName"></param>
477 |         /// <param name="StartAddress"></param>
478 |         /// <param name="Size"></param>
479 |         /// <param name="WriteVal"></param>
480 |         /// <returns>Command String</returns>
481 |         private string CreateCommandString( string command, string subcommand, string DeviceName, string StartAddress, int Size, short[] WriteVal = null)
482 |         {
483 |             string Address;
484 |             string Name = DeviceName.PadRight(2, '*');
485 | 
486 |             if (Name == "X*" || Name == "Y*" || Name == "B*" || Name == "W*" || Name == "SB" || Name == "SW" || Name == "DX" || Name == "DY" || Name == "ZR")
487 |                 Address = int.Parse(StartAddress).ToString("X").PadLeft(6, '0');
488 |             else
489 |                 Address = int.Parse(StartAddress).ToString().PadLeft(6, '0');
490 | 
491 |             string Tmp = _CPU_TimerStr +
492 |                         command +
493 |                         subcommand +
494 |                         Name +
495 |                         Address +
496 |                         Size.ToString("X").PadLeft(4, '0');
497 | 
498 |             if (WriteVal != null) //Write Command
499 |             {
500 |                 if(subcommand == MCCommand.Bit)
501 |                 {
502 |                     var TmpAry = WriteVal.Select(x => x == 48 ? (short)0 : (short)1).ToArray(); //轉換 48=0, 49=1
503 |                     Tmp += string.Join("", TmpAry);
504 |                 }
505 |                 else //Word
506 |                 {
507 |                     byte[] Writebyte = WriteVal.SelectMany(BitConverter.GetBytes).ToArray();
508 |                     for (int i = 0; i < Writebyte.Length; i += 2) // big/little endian轉換
509 |                         Writebyte.SwapBytes(i, i + 1);
510 |                     Tmp += Utility.ByteToMCString(Writebyte);
511 |                 }
512 |             }
513 | 
514 |             string SendCMD = _BasicFormat +
515 |                             _NetNo +
516 |                             _PCNo +
517 |                             _SubBasicFormat +
518 |                             Tmp.Length.ToString("X").PadLeft(4, '0') +
519 |                             Tmp;
520 |             return SendCMD;
521 |         }
522 | 
523 |         /// <summary>
524 |         /// Connection status
525 |         /// </summary>
526 |         /// <returns></returns>
527 |         public override bool CheckStatus()
528 |         {
529 |             if (_SocketTCP != null)
530 |                 return _SocketTCP.Connected;
531 |             else
532 |                 return false;
533 |         }
534 | 
535 |         /// <summary>
536 |         /// Close connection
537 |         /// </summary>
538 |         public override void Close()
539 |         {
540 |             DisConnect();
541 |         }
542 | 
543 |         /// <summary>
544 |         /// Use Ping to check connection
545 |         /// </summary>
546 |         /// <param name="IP">IP Address</param>
547 |         /// <returns></returns>
548 |         private bool PingIP(string IP)
549 |         {
550 |             IPAddress tIP = IPAddress.Parse(IP);
551 |             Ping tPingControl = new Ping();
552 |             PingReply tReply = tPingControl.Send(tIP, 100);
553 |             tPingControl.Dispose();
554 |             
555 |             if (tReply.Status != IPStatus.Success)
556 |             {
557 |                 _Logger.Info(new LogMessage("", nameof(MCProtocol)) { Message = $"Ping {IP} {tReply.Status.ToString()}" });
558 |                 return false;
559 |             }
560 |             else
561 |                 return true;
562 |         }
563 | 
564 |         /// <summary>
565 |         /// Write Data To PLC
566 |         /// </summary>
567 |         /// <param name="Data"></param>
568 |         /// <param name="dataList"></param>
569 |         /// <returns>Error Code</returns>
570 |         public override int WriteData(TransferMsg Data, List<TagMessagePLC> dataList)
571 |         {
572 |             int returncode = -1;
573 |             foreach (TagMessagePLC taginfo in dataList)
574 |             {
575 |                 if (taginfo.IsBit)
576 |                     returncode = WriteBitVal(taginfo.Offset, taginfo.Size, taginfo.RawData, taginfo.DeviceName);
577 |                 else
578 |                     returncode = WriteWordVal(taginfo.Offset, taginfo.Size, taginfo.RawData, taginfo.DeviceName);
579 | 
580 |                 if (returncode == 0)
581 |                 {
582 |                     DMLogMessage _DM = new DMLogMessage(new List<TagMessagePLC> { taginfo }.ToArray(), Data, nameof(MCProtocol)) { Direct = emDirect.H2E };
583 |                     _DMLog.Info(_DM);
584 |                 }
585 |                 else
586 |                 {
587 |                     string[] arValueHex = Enumerable.Range(0, taginfo.RawData.Length).Select(x => taginfo.RawData[x].ToString("X4")).ToArray();
588 |                     LogMessage LM = new LogMessage(Data, nameof(MCProtocol)) { EqpID = Data.EqpID, Direct = emDirect.H2E };
589 |                     LM.Message = $"Write Data Error! code:0x{returncode.ToString("X")} Device={taginfo.DeviceName },Size={taginfo.Size},DeviceValue={string.Join(" ", arValueHex)}";
590 |                     _Logger.Error(LM);
591 |                 }
592 |             }
593 | 
594 |             return returncode;
595 |         }
596 |     }
597 | }
598 | 


--------------------------------------------------------------------------------