PLC 控制 java

用到的 modbus maven 坐标

    <!--modbus -->
        <dependency>
            <groupId>com.intelligt.modbus</groupId>
            <artifactId>jlibmodbus</artifactId>
            <version>1.2.9.7</version>
        </dependency>

        <dependency>
            <groupId>com.digitalpetri.modbus</groupId>
            <artifactId>modbus-master-tcp</artifactId>
            <version>1.1.0</version>
        </dependency>

modbus 实际工具类

package com.aicars.business.common.modbus;

import com.digitalpetri.modbus.FunctionCode;
import com.digitalpetri.modbus.codec.Modbus;
import com.digitalpetri.modbus.master.ModbusTcpMaster;
import com.digitalpetri.modbus.master.ModbusTcpMasterConfig;
import com.digitalpetri.modbus.requests.*;
import com.digitalpetri.modbus.responses.*;
import io.netty.buffer.ByteBuf;
import io.netty.util.ReferenceCountUtil;

import java.net.UnknownHostException;
import java.time.Duration;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * Modbus 实际连接操作类
 */
public class ModbusMasterTCP {
    private static ModbusTcpMaster master;
    //  private static Map<Object, Object> socketChannelMaps;

   // private  Map<String,ModbusTcpMaster> socketChannelMaps =new HashMap<String,ModbusTcpMaster>() ;

    /**
     * 获取TCP协议的Master
     *
     * @return
     */
    public static void initModbusTcpMaster() throws UnknownHostException {

        if(ModbusMasterTCP.master ==null)
            {
                // 创建配置
              //  192.168.3.248   502
              //  ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("192.168.0.113").setPort(502).setTimeout(Duration.ofDays(3)).setAutoConnect(true).build();
                ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("ip").setPort("端口号").setTimeout(Duration.ofDays(3)).setAutoConnect(true).build();
                master = new ModbusTcpMaster(config);

                System.out.println("初始化mobus成功！！！");

            }
    }

    /***
     * 释放资源
     */
    public static void release() {
        if (master != null) {
            master.disconnect();
        }
        Modbus.releaseSharedResources();
    }

    /**
     * 读取Coils开关量
     *
     * @param address  寄存器开始地址
     * @param quantity 数量
     * @param unitId   ID
     * @return 读取值
     * @throws InterruptedException 异常
     * @throws ExecutionException   异常
     */
    public static Boolean readCoils(int address, int quantity, int unitId)
            throws InterruptedException, ExecutionException {
        Boolean result = null;
        CompletableFuture<ReadCoilsResponse> future = master.sendRequest(new ReadCoilsRequest(address, quantity),
                unitId);
        ReadCoilsResponse readCoilsResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
        if (readCoilsResponse != null) {
            ByteBuf buf = readCoilsResponse.getCoilStatus();
            result = buf.readBoolean();
            ReferenceCountUtil.release(readCoilsResponse);
        }
        return result;
    }

    /**
     * 读取readDiscreteInputs开关量
     *
     * @param address  寄存器开始地址
     * @param quantity 数量
     * @param unitId   ID
     * @return 读取值
     * @throws InterruptedException 异常
     * @throws ExecutionException   异常
     */
    public static Boolean readDiscreteInputs(int address, int quantity, int unitId)
            throws InterruptedException, ExecutionException {
        Boolean result = null;
        CompletableFuture<ReadDiscreteInputsResponse> future = master
                .sendRequest(new ReadDiscreteInputsRequest(address, quantity), unitId);
        ReadDiscreteInputsResponse discreteInputsResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
        if (discreteInputsResponse != null) {
            ByteBuf buf = discreteInputsResponse.getInputStatus();
            result = buf.readBoolean();
            ReferenceCountUtil.release(discreteInputsResponse);
        }
        return result;
    }

    /**
     * 读取HoldingRegister数据
     *
     * @param address  寄存器地址
     * @param quantity 寄存器数量
     * @param unitId   id    SlaveId
     * @return 读取结果
     * @throws InterruptedException 异常
     * @throws ExecutionException   异常
     */
    public static Number readHoldingRegisters(int address, int quantity, int unitId)
            throws InterruptedException, ExecutionException {
        Number result = 0;
        try{

            CompletableFuture<ReadHoldingRegistersResponse> future = master
                    .sendRequest(new ReadHoldingRegistersRequest(address, quantity), unitId);
            ReadHoldingRegistersResponse readHoldingRegistersResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
            if (readHoldingRegistersResponse != null) {
                ByteBuf buf = readHoldingRegistersResponse.getRegisters();
                byte[] bytes = new byte[buf.capacity()];
                buf.readBytes(bytes, 0, buf.capacity());
                System.out.println("bytes=" + Arrays.toString(bytes));//bytes=[0, 21]
                result = bytes[1];
                //TODO 后来添加
               // result = buf.readFloat();
              //  result = buf.readInt();
                ReferenceCountUtil.release(readHoldingRegistersResponse);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 读取InputRegisters模拟量数据
     *
     * @param address  寄存器开始地址
     * @param quantity 数量
     * @param unitId   ID
     * @return 读取值
     * @throws InterruptedException 异常
     * @throws ExecutionException   异常
     */
    public static Number readInputRegisters(int address, int quantity, int unitId)
            throws InterruptedException, ExecutionException {
        Number result = null;
        try{
            CompletableFuture<ReadInputRegistersResponse> future = master
                    .sendRequest(new ReadInputRegistersRequest(address, quantity), unitId);
            ReadInputRegistersResponse readInputRegistersResponse = future.get();// 工具类做的同步返回.实际使用推荐结合业务进行异步处理
            if (readInputRegistersResponse != null) {
                ByteBuf buf = readInputRegistersResponse.getRegisters();
                result = buf.readDouble();
                ReferenceCountUtil.release(readInputRegistersResponse);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }


        return result;
    }


    /**
     * 写HoldingRegister数据
     *
     * @param address 寄存器地址
     * @param value   写入值
     * @param unitId  id
     * @return 写入结果
     * @throws InterruptedException 异常
     * @throws ExecutionException   异常
     */
    public static void writeHoldingRegisters(int address, int value, int unitId) throws InterruptedException, ExecutionException {
        // 发送单个寄存器数据，一般是无符号16位值：比如10
        try{
            CompletableFuture<ModbusResponse> future = master.sendRequest(new WriteSingleRegisterRequest(address, value), unitId);
            ModbusResponse modbusResponse = future.get();
            if (modbusResponse != null) {
                FunctionCode functionCode = modbusResponse.getFunctionCode();
                System.out.println("functionCode.getCode()=" + functionCode.getCode());
            } else {
                System.out.println("WriteHoldingRegisters return empty ");
            }
        }catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void writeDemo() throws UnknownHostException {
        // 初始化资源
       initModbusTcpMaster();

        Random random = new Random();
        int value = random.nextInt(100) + 1;
        System.out.println("write value=" + value);
        try {
            writeHoldingRegisters(0, 1, 1);
          //  release();
         //   writeHoldingRegisters(7, 100000%65536, 1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        // 释放资源
      //  release();

    }

    public static void readDemo() {
        try {


         //   initModbusTcpMaster();
            // 执行操作

            // 读取开关量
            // System.out.println(readCoils(0, 1, 1));
            // System.out.println(readDiscreteInputs(0, 1, 1));
            // System.out.println(readDiscreteInputs(1, 1, 1));

            // 读取模拟量
            // System.out.println(readHoldingRegisters(0, 2, 1));
            // System.out.println(readHoldingRegisters(2, 2, 1));
            // System.out.println(readHoldingRegisters(4, 2, 1));
            // System.out.println(readInputRegisters(2, 4, 1));
            // System.out.println(readInputRegisters(6, 4, 1));
            System.out.println("readHoldingRegisters=" + readHoldingRegisters(0, 10, 1));
          //  System.out.println("readHoldingRegisters=" + readHoldingRegisters(0, 10, 1));
         //   System.out.println("readHoldingRegisters=" + readHoldingRegisters(222, 1, 1));

            // 释放资源
         // release();
            release();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Boolean read() {
        try {
            // 初始化资源
           initModbusTcpMaster();
           Number number = readHoldingRegisters(0, 10, 1);
           System.err.println("number==============="+number);
         //  release();
            if(number !=null) {
                return true;
            } else {
                return false;
            }

        } catch (Exception e) {
           // release();
            e.printStackTrace();
        }
        return true;
    }


    /**
     * 更改PLC脉冲阈值（系统配置数值）；
     */
    public static boolean writePulse(int yheightPulse) {

        try {

          //  initModbusTcpMaster();
            if(yheightPulse >0 ) {
                writeHoldingRegisters(4, yheightPulse/65536, 1);
            } else {
                writeHoldingRegisters(4, 1280/65536, 1);
            }




           // Number number = readHoldingRegisters(4, 1, 1);

//
//            if(number !=null) {
//                return true;
//            } else {
//                return false;
//            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;


    }

    /**
     * 更改PLC脉冲阈值（系统配置数值）；
     */
    public static boolean writePulseTwo(int yheightPulse) {

        try {
            //initModbusTcpMaster();

           if(yheightPulse >0 ) {
               writeHoldingRegisters(5, yheightPulse%65536, 1);
           } else {
               writeHoldingRegisters(5, 1280%65536, 1);
           }

//            Number number = readHoldingRegisters(5, 1, 1);
//
//            if(number !=null) {
//                return true;
//            } else {
//                return false;
//            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;


    }

    /**
     * 更改PLC 主动产生脉冲
     */
    public static boolean writePlcActiveImpulse() {

        try {
           // initModbusTcpMaster();
            writeHoldingRegisters(0, 256, 1);

//            Number number = readHoldingRegisters(0, 1, 1);
//
//            if(number !=null) {
//                return true;
//            } else {
//                return false;
//            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;


    }



    /**
     * 更改PLC启用配置（1）
     */
    public static boolean writePlcStartConfihure() {

        try {
         //   initModbusTcpMaster();
            writeHoldingRegisters(1, 1, 1);
//
//            Number number = readHoldingRegisters(1, 1, 1);
//
//            if(number !=null) {
//                return true;
//            } else {
//                return false;
//            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }


    /**
     * 更改PLC启动计数（1）
     */

    public static boolean writePlcCount(){

        try {
           // initModbusTcpMaster();
            writeHoldingRegisters(0, 1, 1);
            //   writeHoldingRegisters(7, 100000%65536, 1);
//            Number number = readHoldingRegisters(0, 1, 1);
//
//            if(number !=null) {
//                return true;
//            } else {
//                return false;
//            }

        } catch (Exception e) {

            e.printStackTrace();
        }
        return true;
    }


    /**
     * 更改PLC启动计数（1）
     */

    public static boolean writePlcCountOff(){

        try {
            // 初始化资源
          //  initModbusTcpMaster();
            writeHoldingRegisters(1, 256, 1);

//            Number number = readHoldingRegisters(1, 1, 1);
//
//            if(number !=null) {
//                return true;
//            } else {
//                return false;
//            }

        } catch (Exception e) {

            e.printStackTrace();

        }
        return true;
    }


   public static void close() {
       if(ModbusMasterTCP.master !=null)
       {
           // 创建配置
           //ModbusTcpMasterConfig config = new ModbusTcpMasterConfig.Builder("192.168.3.248").setPort(502).build();
           master = null;
           System.out.println("断开mobus成功！！！");
       }
   }

    /**
     * plc 读  电动门开V  1 限位有信号；0 无信号
     * @return
     */
    public static Boolean readElectricdooropen() {
        try {
            // 初始化资源
            initModbusTcpMaster();
            Number number = readHoldingRegisters(0, 10, 1);
            //  release();
            //TODO 得判断读取的数字是不是开门   开门中  开门完成
            if(number !=null) {
                return true;
            } else {
                return false;
            }

        } catch (Exception e) {
            // release();
            e.printStackTrace();
        }
        return true;
    }

    /**
     * plc 读  电动门关V  1 限位有信号；0 无信号
     * @return
     */
    public static Boolean readElectricdoorclose() {
        try {
            // 初始化资源
            initModbusTcpMaster();
            Number number = readHoldingRegisters(0, 10, 1);
            //TODO 得判断读取的数字是不是关门
            if(number !=null) {
                return true;
            } else {
                return false;
            }

        } catch (Exception e) {
            // release();
            e.printStackTrace();
        }
        return true;
    }


    /**
     * plc 读  绿色指示灯V   1 门外光电有信号；0 无信号
     * @return
     */
    public static Boolean readGreenindicatorlight() {
        try {
            // 初始化资源
            initModbusTcpMaster();
            Number number = readHoldingRegisters(0, 10, 1);
            //  release();
            //TODO 得判断读取的数字是不是开门
            if(number !=null) {
                return true;
            } else {
                return false;
            }

        } catch (Exception e) {
            // release();
            e.printStackTrace();
        }
        return true;
    }


    /**
     * plc 读  黄色指示灯V   1 门内光电有信号；0 无信号
     * @return
     */
    public static Boolean readYellowindicatorlight() {
        try {
            // 初始化资源
            initModbusTcpMaster();
            Number number = readHoldingRegisters(0, 10, 1);
            //  release();
            if(number !=null) {
                return true;
            } else {
                return false;
            }

        } catch (Exception e) {
            // release();
            e.printStackTrace();
        }
        return true;
    }


    /**
     * plc 读  电动门停V   1 到位信号有信号；0 无信号
     * @return
     */
    public static Boolean readPowerDoorsStop() {
        try {
            // 初始化资源
            initModbusTcpMaster();
            Number number = readHoldingRegisters(0, 10, 1);
            //  release();
            if(number !=null) {
                return true;
            } else {
                return false;
            }

        } catch (Exception e) {
            // release();
            e.printStackTrace();
        }
        return true;
    }



    /**
     * plc 读  检测位可用状态   plc 获取车辆驶离信号
     * @return
     */
    public static Boolean readTestingState() {
        try {
            // 初始化资源
            initModbusTcpMaster();
            Number number = readHoldingRegisters(0, 10, 1);
            if (number.intValue()  == 0) {   //无信号

            }else if (number.intValue()  == 1) {  // 1 下限位有信号

            }
            //  release();
            if(number !=null) {
                return true;
            } else {
                return false;
            }

        } catch (Exception e) {
            // release();
            e.printStackTrace();
        }
        return true;
    }



    /**
     *  指示灯写入  黄灯 绿灯
     */

    public static boolean writeIndicator(int indicator){

        try {
            // 初始化资源
            //  initModbusTcpMaster();
            writeHoldingRegisters(6, indicator, 1);

//            Number number = readHoldingRegisters(1, 1, 1);
//
//            if(number !=null) {
//                return true;
//            } else {
//                return false;
//            }

        } catch (Exception e) {

            e.printStackTrace();

        }
        return true;
    }


    /**
     *  读取指示灯状态  黄灯 绿灯
     */

    public static Number resdIndicatorState(){

        try {
            // 初始化资源
            //  initModbusTcpMaster();
            Number number = readHoldingRegisters(6, 10, 1);
            return number;

//            Number number = readHoldingRegisters(1, 1, 1);
//
//            if(number !=null) {
//                return true;
//            } else {
//                return false;
//            }

        } catch (Exception e) {

            e.printStackTrace();

        }
        return 1;
    }



    /**
     *  控制门写入  黄灯 绿灯
     */

    public static boolean writeDoorControl(int doorState){

        try {
            // 初始化资源
            //  initModbusTcpMaster();
            writeHoldingRegisters(5, doorState, 1);

//            Number number = readHoldingRegisters(1, 1, 1);
//
//            if(number !=null) {
//                return true;
//            } else {
//                return false;
//            }

        } catch (Exception e) {

            e.printStackTrace();

        }
        return true;
    }



    public static void main(String[] args) throws InterruptedException {

        try{

            initModbusTcpMaster();
            writeHoldingRegisters(0, 2, 1);
            System.err.println("写入成功");
            release();

        } catch (Exception e) {
            e.printStackTrace();
        }


    }



}

modbus 心跳

package com.aicars.business.common.modbus;


import lombok.SneakyThrows;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

/**
 *   modbus   心跳包
 */
//@Component     //项目启动需要打开
public class HeartConnection extends Thread implements ApplicationRunner {


    @SneakyThrows
    @Override
    public void run() {
        while (true){
        ModbusMasterTCP.read();
         Thread.sleep(10000);
        }

    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        this.run();
    }
}

``