package com.ruoyi.fuzhou.utils;

import com.serotonin.modbus4j.BatchRead;
import com.serotonin.modbus4j.BatchResults;
import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.ip.IpParameters;
import com.serotonin.modbus4j.locator.BaseLocator;
import com.serotonin.modbus4j.msg.ModbusResponse;
import com.serotonin.modbus4j.msg.ReadCoilsRequest;
import com.serotonin.modbus4j.msg.ReadCoilsResponse;
import com.serotonin.modbus4j.msg.WriteRegistersRequest;

/**
 * modbus通讯工具类,采用modbus4j实现
 *
 * @author zhangyy
 */
public class ModbusReadTcpUtils {
    /**
     * 工厂。
     */
    static ModbusFactory modbusFactory;

    static {
        if (modbusFactory == null) {
            modbusFactory = new ModbusFactory();
        }
    }

    /**
     * 获取master
     *
     * @return
     * @throws ModbusInitException
     */
    public static ModbusMaster getTcpMaster(String ip, int port) throws ModbusInitException {
        IpParameters params = new IpParameters();
        /**
         * 设置ip端口
         */
        params.setHost(ip);
        params.setPort(port);
        params.setEncapsulated(true);
        System.out.println(params.getHost() + ":" + params.getPort());
        // TCP 协议
        ModbusMaster master = modbusFactory.createTcpMaster(params, false);
        master.setTimeout(5000);
        master.setRetries(3);
        master.init();
        return master;
    }

    /**
     * 读取[01 Coil Status 0x]类型 开关数据
     *
     * @param slaveId slaveId
     * @param offset  位置
     * @return 读取值
     * @throws ModbusTransportException 异常
     * @throws ErrorResponseException   异常
     * @throws ModbusInitException      异常
     */
    public static Boolean readCoilStatus(String ip, int slaveId, int offset)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        BaseLocator<Boolean> loc = BaseLocator.coilStatus(slaveId, offset);
        Boolean value = getTcpMaster(ip, 502).getValue(loc);
        return value;
    }

    /**
     * 读取[02 Input Status 1x]类型 开关数据
     *
     * @param slaveId
     * @param offset
     * @return
     * @throws ModbusTransportException
     * @throws ErrorResponseException
     * @throws ModbusInitException
     */
    public static Boolean readInputStatus(String ip, int slaveId, int offset)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        BaseLocator<Boolean> loc = BaseLocator.inputStatus(slaveId, offset);
        Boolean value = getTcpMaster(ip, 502).getValue(loc);
        return value;
    }

    /**
     * 读取[03 Holding Register类型 2x]模拟量数据
     *
     * @param ip       ip
     * @param slaveId  slave Id
     * @param offset   位置
     * @param dataType 数据类型,来自com.serotonin.modbus4j.code.DataType
     * @return
     * @throws ModbusTransportException 异常
     * @throws ErrorResponseException   异常
     * @throws ModbusInitException      异常
     */
    public static Number readHoldingRegister(String ip, int slaveId, int offset, int dataType, int port)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
        Number value = getTcpMaster(ip, port).getValue(loc);
        return value;
    }

    public static Number readHoldingRegisterTest(String ip, int slaveId, int offset, int dataType, int port)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        BaseLocator<?> locator = BaseLocator.createLocator(slaveId, 1, 4001, dataType, 8, 22);
        Object value1 = getTcpMaster(ip, port).getValue(locator);
        //Number value = (Number) getMaster().getValue(locator);
        return 1;
    }

    /**
     * 读取[04 Input Registers 3x]类型 模拟量数据
     *
     * @param slaveId  slaveId
     * @param offset   位置
     * @param dataType 数据类型,来自com.serotonin.modbus4j.code.DataType
     * @return 返回结果
     * @throws ModbusTransportException 异常
     * @throws ErrorResponseException   异常
     * @throws ModbusInitException      异常
     */
    public static Number readInputRegisters(String ip, int slaveId, int offset, int dataType, int port)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 04 Input Registers类型数据读取
        BaseLocator<Number> loc = BaseLocator.inputRegister(slaveId, offset, dataType);
        Number value = getTcpMaster(ip, port).getValue(loc);
        return value;
    }

    /**
     * 批量读取使用方法
     *
     * @throws ModbusTransportException
     * @throws ErrorResponseException
     * @throws ModbusInitException
     */
    public static void batchRead(String ip, int port) throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        BatchRead<Integer> batch = new BatchRead<Integer>();
        batch.addLocator(0, BaseLocator.holdingRegister(1, 1535, DataType.FOUR_BYTE_FLOAT));
        //连接
        ModbusMaster master = getTcpMaster(ip, port);
        batch.setContiguousRequests(false);
        BatchResults<Integer> results = master.send(batch);
        System.out.println("高压进线Uab电压采集：" + results.getValue(0));
    }

    /**
     * 测试
     *
     * @param args
     */
    public static void main(String[] args) {
        try {
            //todo 单个读取
            ModbusMaster master = getTcpMaster("192.168.0.7", 23);
            // 从机地址1，起始地址0，读取10个线圈
            ReadCoilsRequest request = new ReadCoilsRequest(1, 1, 10);
            ReadCoilsResponse response = (ReadCoilsResponse) master.send(request);
            String s = response.toString();
            System.out.println(s);
            master.destroy();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


}