【2023】 JAVA und SPS realisieren die Kommunikation zum Lesen und Schreiben von Daten, am Beispiel von Mitsubishi PLC

1. Erstellen Sie ein Maven-Projekt und führen Sie Abhängigkeiten ein

        <!-- https://mvnrepository.com/artifact/com.github.dathlin/HslCommunication -->
        <dependency>
            <groupId>com.github.dathlin</groupId>
            <artifactId>HslCommunication</artifactId>
            <version>3.3.1</version>
        </dependency>

Für die SPS-Verbindung müssen zwei Konzepte verstanden werden: lange Verbindung und kurze Verbindung . Um die aktuelle Kommunikationssituation besser darzustellen, habe ich die gesamte Kommunikation in vier Teile unterteilt: Verbindung, Senden, Empfangen und Trennen.

• Kurze Verbindung: verbinden, senden, empfangen, trennen, verbinden, senden, empfangen, trennen, verbinden, senden, empfangen, trennen, verbinden, senden, empfangen, trennen ... Endlosschleife
• Lange Verbindung: verbinden, senden, empfangen, senden, empfangen, senden, empfangen, senden, empfangen, senden, empfangen, senden, empfangen, senden, empfangen, senden, empfangen, senden, empfangen ... trennen

Schauen wir uns dann die ungewöhnliche Situation an. Die Ausnahme der kurzen Verbindung ist einfacher zu handhaben. Wie auch immer, jede Anfrage wird zuerst verbunden. Der Schlüssel besteht darin, die ungewöhnlich lange Verbindung der langen Verbindung zu betrachten
: Verbinden, Senden, Empfangen, senden, empfangen... Ausnahme, Verbindung, Senden, empfangen, senden, empfangen, Ausnahme, verbinden, verbinden, verbinden... Empfangen, senden, empfangen, senden, empfangen, senden, empfangen, senden, empfangen... Hier trennen Nachdem die erste Ausnahme aufgetreten ist, erfolgt das Lesen und Schreiben der zweiten
sofort. Nach erfolgreicher Verbindung schlagen Lese- und Schreibvorgänge nach Auslösen der zweiten Ausnahme ständig fehl, was bedeutet, dass die Verbindung nicht immer hergestellt werden kann.
Für HSL-Komponenten ist keine wiederholte Verbindung zum Server oder zur SPS erforderlich. Unabhängig davon, ob es sich um eine kurze oder eine lange Verbindung handelt, ist es in Ordnung, ständig zu lesen und zu schreiben. Das Ergebnis des Lesens und Schreibens wird beurteilt. Auch wenn Wenn eine Ausnahme auftritt, schlägt das Lesen und Schreiben fehl. Bestehen Sie immer darauf. Wenn das Netzwerk in Ordnung ist, werden das Lesen und Schreiben erfolgreich fortgesetzt.

2. Verbinden und kommunizieren Sie über Code

• Stellen Sie eine kurze Verbindung her

// 实例化对象，指定PLC的ip地址和端口号
MelsecMcNet melsecMc = new MelsecMcNet( "192.168.1.110", 6000 );
// 举例读取D100的值
short D100 = melsecMc.ReadInt16( "D100" ).Content;

• Verwirklichen Sie eine lange Verbindung

// 实例化对象，指定PLC的ip地址和端口号
MelsecMcNet melsecMc = new MelsecMcNet( "192.168.1.110", 6000 );
// 如果网络不太理想，配置了两个端口，一个有问题，立即切换另一个的话，可以配置如下的代码
// melsecMc.GetPipeSocket( ).SetMultiPorts( new int[] { 6000, 6001 } );

// 连接对象
OperateResult connect = melsecMc.ConnectServer( );
if (!connect.IsSuccess)    //用于判断是否连接成功，返回true/false
{
    
    
    Console.WriteLine( "connect failed:" + connect.Message );
    return;
}

// 举例读取D100的值
short D100 = melsecMc.ReadInt16( "D100" ).Content;

// 实际上所有的读写都是返回是否成功的标记的，在实际的开发中，需要严格的判定，怎么判定呢？如下的代码
OperateResult<short> readD100 = melsecMc.ReadInt16( "D100" );
if (readD100.IsSuccess)
{
    
    
    // 读取成功，这时候获取Content才是正确的值
    short value = readD100.Content;
}
else
{
    
    
    // 读取失败，如果仍然坚持去获取Content的值，就为0
}

// 读写是否成功的情况，应用于几乎所有的读写代码，只要看清楚返回的数据类型即可
melsecMc.ConnectClose( );

3. Grundlegendes Lesebeispiel

MelsecMcNet melsec_net = new MelsecMcNet( "192.168.0.100", 6000 );
melsec_net.SetPersistentConnection( );                                           // 设置长连接的操作

// 此处以D寄存器作为示例，此处没有判断是否读写成功，所以是有风险的，如果通讯失败，所有的值都不是正确的
short short_D1000 = melsec_net.ReadInt16( "D1000" ).Content;                     // 读取D1000的short值 
ushort ushort_D1000 = melsec_net.ReadUInt16( "D1000" ).Content;                  // 读取D1000的ushort值
int int_D1000 = melsec_net.ReadInt32( "D1000" ).Content;                         // 读取D1000-D1001组成的int数据
uint uint_D1000 = melsec_net.ReadUInt32( "D1000" ).Content;                      // 读取D1000-D1001组成的uint数据
float float_D1000 = melsec_net.ReadFloat( "D1000" ).Content;                     // 读取D1000-D1001组成的float数据
long long_D1000 = melsec_net.ReadInt64( "D1000" ).Content;                       // 读取D1000-D1003组成的long数据
ulong ulong_D1000 = melsec_net.ReadUInt64( "D1000" ).Content;                    // 读取D1000-D1003组成的long数据
double double_D1000 = melsec_net.ReadDouble( "D1000" ).Content;                  // 读取D1000-D1003组成的double数据
string str_D1000 = melsec_net.ReadString( "D1000", 10 ).Content;                 // 读取D1000-D1009组成的条码数据

// 读取数组
short[] short_D1000_array = melsec_net.ReadInt16( "D1000", 10 ).Content;         // 读取D1000的short值 
ushort[] ushort_D1000_array = melsec_net.ReadUInt16( "D1000", 10 ).Content;      // 读取D1000的ushort值
int[] int_D1000_array = melsec_net.ReadInt32( "D1000", 10 ).Content;             // 读取D1000-D1001组成的int数据
uint[] uint_D1000_array = melsec_net.ReadUInt32( "D1000", 10 ).Content;          // 读取D1000-D1001组成的uint数据
float[] float_D1000_array = melsec_net.ReadFloat( "D1000", 10 ).Content;         // 读取D1000-D1001组成的float数据
long[] long_D1000_array = melsec_net.ReadInt64( "D1000", 10 ).Content;           // 读取D1000-D1003组成的long数据
ulong[] ulong_D1000_array = melsec_net.ReadUInt64( "D1000", 10 ).Content;        // 读取D1000-D1003组成的long数据
double[] double_D1000_array = melsec_net.ReadDouble( "D1000", 10 ).Content;      // 读取D1000-D1003组成的double数据

4. Lesen Sie die Demo im Detail

Gängige Methoden

• setNetworkNumber(): Legen Sie die Netzwerknummer fest
• ConnectServer(): Wechseln Sie die Verbindung von einer kurzen Verbindung zu einer langen Verbindung. Sie müssen die Verbindung trennen und erneut herstellen
• SetPersistentConnection(): Der Vorgang zum Einrichten einer langen Verbindung muss nicht getrennt und erneut verbunden werden
• IsSuccess: Stellen Sie fest, ob die Verbindung erfolgreich ist
• readDie Methoden am Anfang sind alle Lesemethoden.
• writeDie Methoden am Anfang sind alle Schreibmethoden

public class MelsenMcClent {
    
    

    private MelsecMcNet clent;
    private String ip;
    private int port;

    /**
     * 初始化连接对象
     * @author zhengfuping
     * @date 2023/1/9 8:07
     * @version 1.0
     */
    public boolean iniConnet(String ip,int port){
    
    
        clent = new MelsecMcNet(ip, port);
        this.ip = ip;
        this.port = port;
        clent.setNetworkStationNumber((byte) 0x00);
        clent.setSleepTime(10);
        OperateResult connet = clent.ConnectServer();
        return connet.IsSuccess;
    }
    /**
     * @description: TODO 重试连接
     * @author zhengfuping
     * @date 2023/1/9 8:07
     * @version 1.0
     */
    public boolean restartConnet(){
    
    
        OperateResult connet = clent.ConnectServer();
        if(connet != null && connet.IsSuccess){
    
    
            return true;
        }else{
    
    
            clent = new MelsecMcNet(this.ip, this.port);
            clent.setNetworkStationNumber((byte) 0x00);
            clent.setSleepTime(10);
            connet = clent.ConnectServer();
            return connet.IsSuccess;
        }
    }

    /**
     * 读取字符串
     * */
    public String read(String address,int length){
    
    
        OperateResultExOne<String> result = clent.ReadString(address,(short)length);
        return result.Content.trim();
    }
    /**
     * 读取32位数字
     * */
    public Integer readInt32(String address){
    
    
        OperateResultExOne<Integer> result = clent.ReadInt32(address);
        return result.Content;
    }
    /**
     * 读取16位数字
     * */
    public Short readInt16(String address){
    
    
        OperateResultExOne<Short> result = clent.ReadInt16(address);
        return result.Content;
    }
    /**
     * 读取浮点数
     * */
    public Float readFloat(String address){
    
    
        OperateResultExOne<Float> result = clent.ReadFloat(address);
        return result.Content;
    }

    /**
     * 写入字符串
     * */
    public boolean write(String address,String dataVal){
    
    
        OperateResult result = clent.Write(address, dataVal);
        return result.IsSuccess;
    }
    /**
     * 写入数字
     * */
    public boolean write(String address,short dataVal){
    
    
        OperateResult result = clent.Write(address, dataVal);
        return result.IsSuccess;
    }

//下面的或者工具类对象可以自己根据业务情况设置，一般三菱PLC是一个端口只能有一个客户端去连接
  /**
     * 创建单例
     * */
    private static class Interior{
    
    
        private static MelsenMcClent CLENT = new MelsenMcClent();

        public static MelsenMcClent getConnect(String state){
    
    
            MelsenMcClent writeClent;
            if (state.equals("Write")){
    
    
                writeClent = getWriteClent();
            }else if (state.equals("Read")){
    
    
                writeClent = getReadClent();
            }else {
    
    
                writeClent = null;
            }
            return writeClent;
        }

        /**
         * 写入对象
         * */
        private static MelsenMcClent getWriteClent(){
    
    
            MelsenMcClent writeClent=Interior.CLENT;
            writeClent.iniConnet("192.168.120.158", 4000);
            return writeClent;
        }
        /**读取对象*/
        private static MelsenMcClent getReadClent(){
    
    
            MelsenMcClent readClent=Interior.CLENT;
            readClent.iniConnet("192.168.120.158", 4001);
            return readClent;
        }
    }

    /**
     * 返回连接工具对象（因为我这边需要读取写入分开，所以设置为两个，可以不设置）
     * @param state 读取/写入状态
     * @return MelsenMcClent
     */
    public static MelsenMcClent getConnect(String state){
    
    
        return Interior.getConnect(state);
    }

### Der spezifische Aufruf zum Lesen und Schreiben des Codes lautet wie folgt
: Da ich keine lokale Verbindung zur SPS herstelle, die Ausgabeergebnisse des Protokolls nicht einfüge, kann ich die folgende Software zum Testen der Zusammenarbeit verwenden

Testen Sie mit Software

1. Wert schreiben:

2. Wert lesen

der gerade geschriebene Wert

• Der Name der Software lautet HslCommunication und kann direkt von seiner offiziellen Website heruntergeladen werden. Die spezifische Seite lautet wie folgt: Wählen Sie das SPS-Modell aus und geben Sie dann die IP und den Port zum Herstellen einer Verbindung und zum Testen ein.