修改

whyclxw

2020-08-25 4bf1d172d090c12c044379c9dcda22c6e5173c31

修改

 DyEnvir_system/lib/commons-lang3-3.11.jar

Binary files differ

 DyEnvir_system/lib/commons-logging-1.1.3.jar

Binary files differ

 DyEnvir_system/lib/modbus4j-3.0.4-SNAPSHOT.jar

Binary files differ

 DyEnvir_system/src/com/fgkj/actions/electricsystem/Electric_control_connAction.java

@@ -14,7 +14,9 @@
    //电源系统组合控制
    public String update() {
        Electric_control_conn econn=getGson(ActionUtil.time_yyyyMMddHHmmss).fromJson(json, Electric_control_conn.class);
        ServiceModel model=service.update(econn);
        //ServiceModel model=service.update(econn);
        //电源系统组合控制<直接控制PLC点位>
        ServiceModel model=service.updatePLC(econn);
        result=tojson(model);
        return SUCCESS;
    }

 DyEnvir_system/src/com/fgkj/actions/electricsystem/Electric_control_singleAction.java

@@ -13,7 +13,9 @@
    //电源系统单点控制
    public String update() {
        Electric_control_single ecs=getGson(ActionUtil.time_yyyyMMddHHmmss).fromJson(json, Electric_control_single.class);
        ServiceModel model=service.update(ecs);
        //ServiceModel model=service.update(ecs);
        //电源系统单点控制<直接控制PLC点位>
        ServiceModel model=service.updatePLC(ecs);
        result=tojson(model);
        return SUCCESS;
    }

 DyEnvir_system/src/com/fgkj/dao/Electric_4KW_ModbusAddress.java

New file
@@ -0,0 +1,575 @@
package com.fgkj.dao;


public class Electric_4KW_ModbusAddress {
    //ABCD套获取地址
    public static int getAddress(int electric_id,String addressName) {
        int address=0;
        if(addressName.equals("upsetcurr")) {//上位机设定电流
            switch (electric_id) {
            case 4001:address=25;break;
            case 4002:address=45;break;
            case 4003:address=65;break;
            case 4004:address=85;break;
            default:break;
            }
        }
        if(addressName.equals("upsetvol")) {//上位机设定电压
            switch (electric_id) {
            case 4001:address=26;break;
            case 4002:address=46;break;
            case 4003:address=66;break;
            case 4004:address=86;break;
            default:break;
            }
        }
        if(addressName.equals("convolcontrol")) {//恒压控制
            switch (electric_id) {
            case 4001:address=432;break;
            case 4002:address=752;break;
            case 4003:address=1072;break;
            case 4004:address=1392;break;
            default:break;
            }
        }
        if(addressName.equals("concurrcontrol")) {//恒流控制
            switch (electric_id) {
            case 4001:address=433;break;
            case 4002:address=753;break;
            case 4003:address=1073;break;
            case 4004:address=1393;break;
            default:break;
            }
        }
        if(addressName.equals("othermodes")) {//其他模式运行
            switch (electric_id) {
            case 4001:address=434;break;
            case 4002:address=754;break;
            case 4003:address=1074;break;
            case 4004:address=1394;break;
            default:break;
            }
        }
        if(addressName.equals("parallelmodes")) {//并联稳压运行	
            switch (electric_id) {
            case 4001:address=435;break;
            case 4002:address=755;break;
            case 4003:address=1075;break;
            case 4004:address=1395;break;
            default:break;
            }
        }
        if(addressName.equals("startposition")) {//启动位	
            switch (electric_id) {
            case 4001:address=436;break;
            case 4002:address=756;break;
            case 4003:address=1076;break;
            case 4004:address=1396;break;
            default:break;
            }
        }
        if(addressName.equals("stopposition")) {//停止位
            switch (electric_id) {
            case 4001:address=437;break;
            case 4002:address=757;break;
            case 4003:address=1077;break;
            case 4004:address=1397;break;
            default:break;
            }
        }
        if(addressName.equals("resetposition")) {//复位
            switch (electric_id) {
            case 4001:address=438;break;
            case 4002:address=758;break;
            case 4003:address=1078;break;
            case 4004:address=1398;break;
            default:break;
            }
        }
        if(addressName.equals("fanstart")) {//风机启动
            switch (electric_id) {
            case 4001:address=440;break;
            case 4002:address=760;break;
            case 4003:address=1080;break;
            case 4004:address=1400;break;
            default:break;
            }
        }
        if(addressName.equals("fanstop")) {//风机停止
            switch (electric_id) {
            case 4001:address=441;break;
            case 4002:address=761;break;
            case 4003:address=1081;break;
            case 4004:address=1401;break;
            default:break;
            }
        }
        if(addressName.equals("dcvol")) {//直流电压
            switch (electric_id) {
            case 4001:address=35;break;
            case 4002:address=55;break;
            case 4003:address=75;break;
            case 4004:address=95;break;
            default:break;
            }
        }if(addressName.equals("dccurr")) {//直流电流	
            switch (electric_id) {
            case 4001:address=36;break;
            case 4002:address=56;break;
            case 4003:address=76;break;
            case 4004:address=96;break;
            default:break;
            }
        }
        if(addressName.equals("controlangle")) {//控制角
            switch (electric_id) {
            case 4001:address=37;break;
            case 4002:address=57;break;
            case 4003:address=77;break;
            case 4004:address=97;break;
            default:break;
            }
        }
        if(addressName.equals("loopflag")) {//开闭环标志位【0开环；1闭环】
            switch (electric_id) {
            case 4001:address=634;break;
            case 4002:address=954;break;
            case 4003:address=1274;break;
            case 4004:address=1594;break;
            default:break;
            }
        }
        if(addressName.equals("remoteflag")) {//就地远程标志位【0远程；1就地】
            switch (electric_id) {
            case 4001:address=635;break;
            case 4002:address=955;break;
            case 4003:address=1275;break;
            case 4004:address=1595;break;
            default:break;
            }
        }
        if(addressName.equals("orderflag")) {//正序逆序标志位【0正序；1逆序】
            switch (electric_id) {
            case 4001:address=636;break;
            case 4002:address=956;break;
            case 4003:address=1276;break;
            case 4004:address=1596;break;
            default:break;
            }
        }
        if(addressName.equals("consvolcurrflag")) {//恒压横流标志位【0恒压；1恒流】
            switch (electric_id) {
            case 4001:address=639;break;
            case 4002:address=959;break;
            case 4003:address=1279;break;
            case 4004:address=1599;break;
            default:break;
            }
        }
        if(addressName.equals("powerstartflag")) {//电源启动标志位【0停止；1启动】	
            switch (electric_id) {
            case 4001:address=624;break;
            case 4002:address=944;break;
            case 4003:address=1264;break;
            case 4004:address=1584;break;
            default:break;
            }
        }
        if(addressName.equals("workmodelflag")) {//工作模式标志位【0其他模式；1并联稳压】
            switch (electric_id) {
            case 4001:address=625;break;
            case 4002:address=945;break;
            case 4003:address=1265;break;
            case 4004:address=1585;break;
            default:break;
            }
        }
        if(addressName.equals("case_trip_output")) {//机箱跳闸输出
            switch (electric_id) {
            case 4001:address=640;break;
            case 4002:address=960;break;
            case 4003:address=1280;break;
            case 4004:address=1600;break;
            default:break;
            }
        }
        if(addressName.equals("fault_reset_signal")) {//故障复位信号
            switch (electric_id) {
            case 4001:address=641;break;
            case 4002:address=961;break;
            case 4003:address=1281;break;
            case 4004:address=1601;break;
            default:break;
            }
        }
        if(addressName.equals("high_vol_switch_status")) {//高压开关状态	
            switch (electric_id) {
            case 4001:address=642;break;
            case 4002:address=962;break;
            case 4003:address=1282;break;
            case 4004:address=1602;break;
            default:break;
            }
        }
        if(addressName.equals("stop_button")) {//急停按钮
            switch (electric_id) {
            case 4001:address=643;break;
            case 4002:address=963;break;
            case 4003:address=1283;break;
            case 4004:address=1603;break;
            default:break;
            }
        }
        if(addressName.equals("main_cabinet_fan_status")) {//主柜风机状态				
            switch (electric_id) {
            case 4001:address=644;break;
            case 4002:address=964;break;
            case 4003:address=1284;break;
            case 4004:address=1604;break;
            default:break;
            }
        }
        if(addressName.equals("trans_cabinet_door_lock")) {//变压器柜门连锁
            switch (electric_id) {
            case 4001:address=645;break;
            case 4002:address=965;break;
            case 4003:address=1285;break;
            case 4004:address=1605;break;
            default:break;
            }
        }
        if(addressName.equals("trans_cabinet_overtem_alarm")) {//变压器超温报警
            switch (electric_id) {
            case 4001:address=646;break;
            case 4002:address=966;break;
            case 4003:address=1286;break;
            case 4004:address=1606;break;
            default:break;
            }
        }
        if(addressName.equals("trans_cabinet_overtem_trip")) {//变压器超温跳闸
            switch (electric_id) {
            case 4001:address=647;break;
            case 4002:address=967;break;
            case 4003:address=1287;break;
            case 4004:address=1607;break;
            default:break;
            }
        }
        if(addressName.equals("qs1_state")) {//QS1状态	
            switch (electric_id) {
            case 4001:address=648;break;
            case 4002:address=968;break;
            case 4003:address=1288;break;
            case 4004:address=1608;break;
            default:break;
            }
        }
        if(addressName.equals("qs2_state")) {//QS2状态	
            switch (electric_id) {
            case 4001:address=649;break;
            case 4002:address=969;break;
            case 4003:address=1289;break;
            case 4004:address=1609;break;
            default:break;
            }
        }
        if(addressName.equals("switch_cabinet_door_status")) {//转换开关柜门状态
            switch (electric_id) {
            case 4001:address=652;break;
            case 4002:address=972;break;
            case 4003:address=1292;break;
            case 4004:address=1612;break;
            default:break;
            }
        }
        if(addressName.equals("alldcvol")) {//总直流电压
            switch (electric_id) {
            case 4001:address=41;break;
            case 4003:address=81;break;
            default:break;
            }
        }
        if(addressName.equals("alldccurr")) {//总直流电流	
            switch (electric_id) {
            case 4001:address=42;break;
            case 4003:address=82;break;
            default:break;
            }
        }
        //开关地址
        if(addressName.equals("switchon_1")) {//开关柜合闸指令
            switch (electric_id) {
            case 4001:address=240;break;
            case 4002:address=244;break;
            case 4003:address=248;break;
            case 4004:address=252;break;
            default:break;
            }
        }
        if(addressName.equals("switchon_2")) {//开关柜合闸指令
            switch (electric_id) {
            case 4001:address=242;break;
            case 4002:address=246;break;
            case 4003:address=250;break;
            case 4004:address=254;break;
            default:break;
            }
        }
        if(addressName.equals("switchoff_1")) {//开关柜分闸指令
            switch (electric_id) {
            case 4001:address=241;break;
            case 4002:address=245;break;
            case 4003:address=249;break;
            case 4004:address=253;break;
            default:break;
            }
        }
        if(addressName.equals("switchoff_2")) {//开关柜分闸指令
            switch (electric_id) {
            case 4001:address=243;break;
            case 4002:address=247;break;
            case 4003:address=251;break;
            case 4004:address=255;break;
            default:break;
            }
        }
		
        //通讯状态
        if(addressName.equals("comm_state")) {//通讯状态
            switch (electric_id) {
            case 4001:address=280;break;
            case 4002:address=280;break;
            case 4003:address=280;break;
            case 4004:address=280;break;
            default:break;
            }
        }
        //触摸屏复位
        if(addressName.equals("screen_reset")) {//触摸屏复位
            switch (electric_id) {
            case 4001:address=281;break;
            case 4002:address=281;break;
            case 4003:address=281;break;
            case 4004:address=281;break;
            default:break;
            }
        }
        //风机控制
        if(addressName.equals("fan_control")) {//风机控制
            switch (electric_id) {
            case 4001:address=282;break;
            case 4002:address=282;break;
            case 4003:address=282;break;
            case 4004:address=282;break;
            default:break;
            }
        }
        //紧急跳闸
        if(addressName.equals("emergency_trip")) {//紧急跳闸
            switch (electric_id) {
            case 4001:address=283;break;
            case 4002:address=283;break;
            case 4003:address=283;break;
            case 4004:address=283;break;
            default:break;
            }
        }
        return address;
    }
    //获取总开关地址和总状态地址
    public static int getAllAdd(String addressName) {
        int address=0;
        switch (addressName) {
        case "km1_switchon_one":address=240;break;//一号转换开关柜KM1合闸指令	
        case "km1_switchoff_one":address=241;break;    //一号转换开关柜KM1分闸指令	
        case "km2_switchon_one":address=242;break;//一号转换开关柜KM2合闸指令
        case "km2_switchoff_one":address=243;break;    //一号转换开关柜KM2分闸指令	
        case "km3_switchon_one":address=244;break;//一号转换开关柜KM3合闸指令
        case "km3_switchoff_one":address=245;break;    //一号转换开关柜KM3分闸指令	
        case "km4_switchon_one":address=246;break;//一号转换开关柜KM4合闸指令
        case "km4_switchoff_one":address=247;break;    //一号转换开关柜KM4分闸指令	
        case "km1_switchon_two":address=248;break;//二号转换开关柜KM1合闸指令
        case "km1_switchoff_two":address=249;break;//二号转换开关柜KM1分闸指令		
        case "km2_switchon_two":address=250;break;//二号转换开关柜KM2合闸指令
        case "km2_switchoff_two":address=251;break;//二号转换开关柜KM2分闸指令		
        case "km3_switchon_two":address=252;break;//二号转换开关柜KM3合闸指令
        case "km3_switchoff_two":address=253;break;//二号转换开关柜KM3分闸指令		
        case "km4_switchon_two":address=254;break;//二号转换开关柜KM4合闸指令
        case "km4_switchoff_two":address=255;break;//二号转换开关柜KM4分闸指令		
        case "start_a":address=272;break;//A套启动	
        case "stop_a":address=288;break;//A套停止	
        case "start_b":address=273;break;//B套启动	
        case "stop_b":address=289;break;//B套停止	
        case "start_c":address=274;break;//C套启动	
        case "stop_c":address=290;break;//C套停止	
        case "start_d":address=275;break;//D套启动	
        case "stop_d":address=291;break;//D套停止	
        case "abconn_start":address=276;break;//AB套并联运行启动
        case "abconn_stop":address=292;break;//AB套并联运行停止		
        case "cdconn_start":address=277;break;//CD套并联运行启动
        case "cdconn_stop":address=293;break;//CD套并联运行停止
        case "allconn_start":address=278;break;//四套并联运行启动
        case "allconn_stop":address=294;break;//四套并联运行停止
        case "abconn_flag":address=312;break;//AB并串联标志位
        case "cdconn_flag":address=313;break;//CD并串联标志位
        case "abconn_volset":address=275;break;//AB并联电压给定
        case "abconn_currset":address=276;break;//AB并联电流给定
        case "cdconn_volset":address=277;break;//CD并联电压给定
        case "cdconn_currset":address=278;break;//CD并联电流给定
        default:break;
        }
        return address;
    }
    //获取电源故障的地址
    public static int getFaultAdd(int electric_id,String addressName) {
        int address=0;
        if(addressName.equals("dcover_curr")) {//直流过流
            switch (electric_id) {
            case 4001:address=616;break;
            case 4002:address=936;break;
            case 4003:address=1256;break;
            case 4004:address=1576;break;
            default:break;
            }
        }
        if(addressName.equals("synchro_lose")) {//同步丢失
            switch (electric_id) {
            case 4001:address=617;break;
            case 4002:address=937;break;
            case 4003:address=1257;break;
            case 4004:address=1577;break;
            default:break;
            }
        }
        if(addressName.equals("dcover_vol")) {//直流过压
            switch (electric_id) {
            case 4001:address=618;break;
            case 4002:address=938;break;
            case 4003:address=1258;break;
            case 4004:address=1578;break;
            default:break;
            }
        }
        if(addressName.equals("case_pulse_block")) {//机箱脉冲封锁
            switch (electric_id) {
            case 4001:address=619;break;
            case 4002:address=939;break;
            case 4003:address=1259;break;
            case 4004:address=1579;break;
            default:break;
            }
        }
        if(addressName.equals("case_transA_overcurr")) {//机箱变压器A相过流
            switch (electric_id) {
            case 4001:address=620;break;
            case 4002:address=940;break;
            case 4003:address=1260;break;
            case 4004:address=1580;break;
            default:break;
            }
        }
        if(addressName.equals("case_transB_overcurr")) {//机箱变压器B相过流
            switch (electric_id) {
            case 4001:address=621;break;
            case 4002:address=941;break;
            case 4003:address=1261;break;
            case 4004:address=1581;break;
            default:break;
            }
        }
        if(addressName.equals("case_transC_overcurr")) {//机箱变压器C相过流
            switch (electric_id) {
            case 4001:address=622;break;
            case 4002:address=942;break;
            case 4003:address=1262;break;
            case 4004:address=1582;break;
            default:break;
            }
        }
        if(addressName.equals("case_cuurfeedback_lose")) {//机箱直流反馈丢失
            switch (electric_id) {
            case 4001:address=623;break;
            case 4002:address=943;break;
            case 4003:address=1263;break;
            case 4004:address=1583;break;
            default:break;
            }
        }
        if(addressName.equals("case_synchro_cycle_fault")) {//机箱同步周期故障
            switch (electric_id) {
            case 4001:address=608;break;
            case 4002:address=928;break;
            case 4003:address=1248;break;
            case 4004:address=1568;break;
            default:break;
            }
        }
        if(addressName.equals("main_cabinet_fault_one")) {//1号主柜快熔故障
            switch (electric_id) {
            case 4001:address=609;break;
            case 4002:address=929;break;
            case 4003:address=1249;break;
            case 4004:address=1569;break;
            default:break;
            }
        }
        if(addressName.equals("main_cabinet_fault_two")) {//2号主柜快熔故障
            switch (electric_id) {
            case 4001:address=610;break;
            case 4002:address=930;break;
            case 4003:address=1250;break;
            case 4004:address=1570;break;
            default:break;
            }
        }
        return address;
    }
    //组合地址
    public static int getConnAddress(int electric_id,String addressName) {
        int address=0;
        if(addressName.equals("conn_flag")) {// '并联模式',
            switch (electric_id) {
            case 4001:address=312;break;
            case 4003:address=313;break;
            default:break;
            }
        }
        if(addressName.equals("divide_flag")) {// '串联模式',
            switch (electric_id) {
            case 4001:address=312;break;
            case 4003:address=313;break;
            default:break;
            }
        }
        if(addressName.equals("givevol")) {// '电压给定',
            switch (electric_id) {
            case 4001:address=275;break;//AB并联电压给定
            case 4003:address=277;break;//CD并联电压给定
            default:break;
            }
        }
        if(addressName.equals("givecurr")) {// '电流给定',
            switch (electric_id) {
            case 4001:address=276;break;//AB并联电流给定
            case 4003:address=278;break;//CD并联电流给定
            default:break;
            }
        }
        if(addressName.equals("conn_start")) {// '并联运行启动',
            switch (electric_id) {
            case 4001:address=276;break;
            case 4003:address=277;break;
            default:break;
            }
        }
        if(addressName.equals("conn_stop")) {// '并联运行停止',
            switch (electric_id) {
            case 4001:address=292;break;
            case 4003:address=293;break;
            default:break;
            }
        }
        return address;
    }
}

 DyEnvir_system/src/com/fgkj/electricsystem/Service/Electric_control_connService.java

@@ -4,8 +4,16 @@

import com.fgkj.dao.BaseDAO;
import com.fgkj.dao.BaseDAOFactory;
import com.fgkj.dao.Electric_4KW_ModbusAddress;
import com.fgkj.electricsystem.Impl.Electric_control_connImpl;
import com.fgkj.electricsystem.dto.Electric_control_conn;
import com.fgkj.services.ServiceModel;
import com.modbus.data.BaseData;
import com.modbus.data.Modbus_ComBase;
import com.modbus.data.MyModbusMaster;
import com.modbus.data.MyModbusUtils;
import com.modbus.data.SocketClient;
import com.serotonin.modbus4j.code.DataType;

public class Electric_control_connService {
    private BaseDAO dao;
@@ -28,6 +36,318 @@
        }
        return model;
    }
    //电源系统组合控制<socket>
    public ServiceModel updatePLC(Object obj) {
        Electric_control_conn econn=(Electric_control_conn) obj;
        //System.out.println(econn);
        boolean bl=false;
        BaseData basedata=null;
        byte[] b=null;
        try {
            switch (econn.getNum()) {
            case 1: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "convolcontrol"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "convolcontrol"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "convolcontrol"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "convolcontrol"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//恒压控制
            case 2: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "concurrcontrol"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "concurrcontrol"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "concurrcontrol"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "concurrcontrol"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//恒流控制
            case 3: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getConnAddress(econn.getElectric_id(), "conn_flag"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
                    break;// '并联模式',
            case 4: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getConnAddress(econn.getElectric_id(), "conn_flag"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
                    break;// '串联模式',
            case 5: 
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getConnAddress(econn.getElectric_id(), "givevol"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte((int)econn.getGivevol()));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "upsetvol"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte((int)econn.getGivevol()));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "othermodes"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "upsetvol"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte((int)econn.getGivevol()));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "othermodes"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "othermodes"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
						
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "othermodes"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
						
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;// '电压给定',
            case 6: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getConnAddress(econn.getElectric_id(), "givecurr"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte((int)econn.getGivecurr()));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "givecurr"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte((int)econn.getGivecurr()));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "othermodes"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "givecurr"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte((int)econn.getGivecurr()));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "othermodes"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "othermodes"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
						
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "othermodes"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
						
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;// '电流给定',
				
            case 7: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "switchon_1"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "switchon_2"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "switchon_1"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "switchon_2"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
						
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                       break;// '输出合闸1',
            case 8: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "switchon_1"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "switchon_2"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "switchon_1"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "switchon_2"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
						
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                       break;// '输出合闸2',
            case 9: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "switchoff_1"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "switchoff_2"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "switchoff_1"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "switchoff_2"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
						
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                       break;// '输出分闸1 ',
            case 10:basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "switchoff_1"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "switchoff_2"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "switchoff_1"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "switchoff_2"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
						
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                       break;// '输出分闸2',
            case 11:basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "conn_start"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "fanstart"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "fanstart"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "conn_start"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "fanstart"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "fanstart"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;// '并联运行启动',
            case 12:basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "conn_stop"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "fanstop"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				    
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "fanstop"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, econn.getElectric_ip());
				
					
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "conn_stop"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id(), "fanstop"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
					    
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(econn.getElectric_id()+1, "fanstop"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, econn.getElectric_ip());
						
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;// '并联运行停止',
			
            default:break;
            }
         } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            bl=false;
            e.printStackTrace();
        }	
        if(bl){
            model.setCode(1);
            model.setMsg("写入成功");
        } else{
            model.setCode(0);
            model.setMsg("写入失败");
        }
        return model;
    }
	
	
    //组合控制界面<电压/电流确认>
    public ServiceModel delVCSet(Object obj) {
        boolean bl=((Electric_control_connImpl)dao).delVCSet(obj);    

 DyEnvir_system/src/com/fgkj/electricsystem/Service/Electric_control_singleService.java

@@ -1,8 +1,22 @@
package com.fgkj.electricsystem.Service;

import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import com.fgkj.dao.BaseDAO;
import com.fgkj.dao.BaseDAOFactory;
import com.fgkj.dao.Electric_4KW_ModbusAddress;
import com.fgkj.electricsystem.dto.Electric_control_single;
import com.fgkj.services.ServiceModel;
import com.modbus.data.BaseData;
import com.modbus.data.ComBase;
import com.modbus.data.Modbus_ComBase;
import com.modbus.data.MyModbusMaster;
import com.modbus.data.MyModbusUtils;
import com.modbus.data.SocketClient;
import com.serotonin.modbus4j.code.DataType;
import com.sun.scenario.effect.Bloom;

public class Electric_control_singleService {
    private BaseDAO dao;
@@ -26,5 +40,253 @@
        }
        return model;
    }

    //电源系统单点控制<直接控制PLC点位>
    public ServiceModel updateMaster(Object obj) {
        Electric_control_single ecs=(Electric_control_single) obj;
        System.out.println(ecs);
        try {
            MyModbusMaster master = new MyModbusMaster(ecs.getElectric_ip(), MyModbusMaster.SLAVEID_DEFAULT);
            switch (ecs.getNum()) {
            case 1: MyModbusUtils.writeHoldingRegister(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "upsetcurr"), ecs.getUpsetcurr(), DataType.TWO_BYTE_INT_UNSIGNED, master);break;//上位机设定电流
            case 2: MyModbusUtils.writeHoldingRegister(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "upsetvol"), ecs.getUpsetvol(), DataType.TWO_BYTE_INT_UNSIGNED, master);break;//上位机设定电压
            case 3: MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "convolcontrol"), true, master);
                    try {
                        //300毫秒后复原
                        Thread.sleep(300);
                        MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "convolcontrol"),false, master);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//恒压控制
            case 4: MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "concurrcontrol"),true, master);
                    try {
                        //300毫秒后复原
                        Thread.sleep(300);
                        MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "concurrcontrol"),false, master);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//恒流控制
            case 5:break;//其他模式运行
            case 6:break;//并联稳压运行
            case 7: MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "startposition"),true, master);
                    MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "othermodes"),true, master);
                    MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "fanstart"),true, master);
                    try {
                        //300毫秒后复原
                        Thread.sleep(300);
                        MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "startposition"),false, master);
                        MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "othermodes"),false, master);
                        MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "fanstart"),false, master);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//启动位
            case 8: MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "stopposition"),true, master);
                    MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "fanstop"),true, master);
                    try {
                        //300毫秒后复原
                        Thread.sleep(300);
                        MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "stopposition"),false, master);
                        MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "fanstop"),false, master);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//停止位
            case 9: MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "resetposition"),true,master);break;//复位
            case 10:break;//风机启动
            case 11:break;//风机停止
            case 12:MyModbusUtils.writeHoldingRegister(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "dcvol"), ecs.getDcvol(), DataType.TWO_BYTE_INT_UNSIGNED, master);break;//直流电压
            case 13:MyModbusUtils.writeHoldingRegister(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "dccurr"), ecs.getDccurr(), DataType.TWO_BYTE_INT_UNSIGNED, master);break;//直流电流
            case 14:MyModbusUtils.writeHoldingRegister(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "controlangle"), ecs.getControlangle(), DataType.TWO_BYTE_INT_UNSIGNED, master);break;//控制角
            case 15:
                    MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "switchon_1"),true, master);
                    MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "switchon_2"),true, master);	
                    break;//开关合闸
            case 16:
                    MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "switchoff_1"),true, master);
                    MyModbusUtils.writeCoil(Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "switchoff_2"),true, master);	
                    break;//开关分闸
			
            default:break;
            }
            master.getMaster().destroy();
            model.setCode(1);
            model.setMsg("控制成功");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            model.setCode(0);
            model.setMsg("控制失败");
            e.printStackTrace();
        }
        return model;
    }
    //电源单点控制<建立socket通讯>
    public ServiceModel updatePLC(Object obj) {
        Electric_control_single ecs=(Electric_control_single) obj;
        boolean bl=false;
        BaseData basedata=null;
        byte[] b=null;
        try {
            switch (ecs.getNum()) {
            case 1: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "upsetcurr"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte(ecs.getUpsetcurr()));        
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    break;//上位机设定电流
            case 2: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "upsetvol"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte(ecs.getUpsetvol())); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    break;//上位机设定电压
            case 3: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "convolcontrol"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                        bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//恒压控制
            case 4: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "concurrcontrol"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1));
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    try {
                          //100毫秒后复原
                         Thread.sleep(100);
                         b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0));
                         bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//恒流控制
            case 5:break;//其他模式运行
            case 6:break;//并联稳压运行
            case 7: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "startposition"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
			        
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "othermodes"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
			        
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "fanstart"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
			        
                   try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "startposition"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0)); 
                        bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
			            
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "othermodes"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0)); 
                        bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
			            
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "fanstart"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0)); 
                        bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//启动位
            case 8: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "stopposition"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
			        
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "fanstop"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
			        
                    try {
                        //100毫秒后复原
                        Thread.sleep(100);
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "stopposition"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0)); 
                        bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
				        
                        basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "fanstop"),1);
                        b=basedata.createSingleCollWiriteData(basedata.createButtonByte(0)); 
                        bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;//停止位
            case 9: basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "resetposition"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    break;//复位
            case 10:break;//风机启动
            case 11:break;//风机停止
            case 12:basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "dcvol"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte(ecs.getDcvol()));        
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    break;//直流电压
            case 13:basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "dccurr"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte(ecs.getDccurr()));        
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    break;//直流电流
            case 14:basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_REGISTER,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "controlangle"),1);
                    b=basedata.createSingleResWiriteData(basedata.createIntByte(ecs.getControlangle()));        
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    break;//控制角
            case 15:
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "switchon_1"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
			        
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "switchon_2"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    break;//开关合闸
            case 16:
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "switchoff_1"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
			        
                    basedata = new BaseData(Modbus_ComBase.WRITE_SINGLE_COIL,Electric_4KW_ModbusAddress.getAddress(ecs.getElectric_id(), "switchoff_2"),1);
                    b=basedata.createSingleCollWiriteData(basedata.createButtonByte(1)); 
                    bl=SocketClient.SocketComm(b, ecs.getElectric_ip());
                    break;//开关分闸
            default:break;
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            bl=false;
            e.printStackTrace();
        }	
        if(bl){
            model.setCode(1);
            model.setMsg("写入成功");
        } else{
            model.setCode(0);
            model.setMsg("写入失败");
        }
        return model;
    }
	
    public static void main(String[] args) {
        /*MyModbusMaster master = new MyModbusMaster("127.0.0.1", MyModbusMaster.SLAVEID_DEFAULT);
        System.out.println(master);
        MyModbusUtils.writeHoldingRegister(Electric_4KW_ModbusAddress.getAddress(4001, "upsetvol"),100, DataType.TWO_BYTE_INT_UNSIGNED, master);//上位机设定
       */	 
        Electric_control_single ecs=new Electric_control_single();
        ecs.setNum(2);
        ecs.setElectric_ip("127.0.0.1");
        ecs.setElectric_id(4001);
        ecs.setUpsetvol(300);
        Electric_control_singleService service=new Electric_control_singleService();
        //service.updatePLC(ecs);
    }
}

 DyEnvir_system/src/com/fgkj/electricsystem/dto/Electric_control_conn.java

@@ -20,6 +20,8 @@
      public int switchoff2 ;// '输出分闸2',
      public int conn_start   ;// '并联运行启动',
      public int conn_stop   ;// '并联运行停止',
	  
      private String electric_ip;
    public int getNum() {
        return num;
    }
@@ -122,6 +124,12 @@
    public void setConn_stop(int conn_stop) {
        this.conn_stop = conn_stop;
    }
    public String getElectric_ip() {
        return electric_ip;
    }
    public void setElectric_ip(String electric_ip) {
        this.electric_ip = electric_ip;
    }
    @Override
    public String toString() {
        return "Electric_control_conn [num=" + num + ", electric_id="
@@ -132,8 +140,10 @@
                + givevol + ", givecurr=" + givecurr + ", switchon1="
                + switchon1 + ", switchon2=" + switchon2 + ", switchoff1="
                + switchoff1 + ", switchoff2=" + switchoff2 + ", conn_start="
                + conn_start + ", conn_stop=" + conn_stop + "]";
                + conn_start + ", conn_stop=" + conn_stop + ", electric_ip="
                + electric_ip + "]";
    }
	
      
     
      

 DyEnvir_system/src/com/fgkj/electricsystem/dto/Electric_control_single.java

@@ -5,8 +5,8 @@
public class Electric_control_single implements Serializable{
      private int num; // '主键',
      private int electric_id;// '电源id',
      private float upsetcurr ;// '上位机设定电流',
      private float upsetvol ;// '上位机设定电压',
      private int upsetcurr ;// '上位机设定电流',
      private int upsetvol ;// '上位机设定电压',
      private int convolcontrol  ;// '恒压控制',
      private int concurrcontrol  ;// '恒流控制',
      private int othermodes  ;// '其他模式运行',
@@ -16,12 +16,14 @@
      private int resetposition  ;// '复位',
      private int fanstart  ;// '风机启动',
      private int fanstop  ;// '风机停止',
      private float dcvol ;// '直流电压',
      private float dccurr ;// '直流电流',
      private float controlangle ;// '控制角',
      private int dcvol ;// '直流电压',
      private int dccurr ;// '直流电流',
      private int controlangle ;// '控制角',
    //单套电源输出合闸
    public int switchon;        //开关柜合闸指令
    public int switchoff;        //开关柜分闸指令
	
    private String electric_ip;
    
    public int getNum() {
        return num;
@@ -35,16 +37,17 @@
    public void setElectric_id(int electric_id) {
        this.electric_id = electric_id;
    }
    public float getUpsetcurr() {
	
    public int getUpsetcurr() {
        return upsetcurr;
    }
    public void setUpsetcurr(float upsetcurr) {
    public void setUpsetcurr(int upsetcurr) {
        this.upsetcurr = upsetcurr;
    }
    public float getUpsetvol() {
    public int getUpsetvol() {
        return upsetvol;
    }
    public void setUpsetvol(float upsetvol) {
    public void setUpsetvol(int upsetvol) {
        this.upsetvol = upsetvol;
    }
    public int getConvolcontrol() {
@@ -102,25 +105,26 @@
        this.fanstop = fanstop;
    }

    public float getDcvol() {
	
	
    public int getDcvol() {
        return dcvol;
    }
    public void setDcvol(float dcvol) {
    public void setDcvol(int dcvol) {
        this.dcvol = dcvol;
    }
    public float getDccurr() {
    public int getDccurr() {
        return dccurr;
    }
    public void setDccurr(float dccurr) {
    public void setDccurr(int dccurr) {
        this.dccurr = dccurr;
    }
    public float getControlangle() {
    public int getControlangle() {
        return controlangle;
    }
    public void setControlangle(float controlangle) {
    public void setControlangle(int controlangle) {
        this.controlangle = controlangle;
    }
	
    public int getSwitchon() {
        return switchon;
    }
@@ -132,6 +136,12 @@
    }
    public void setSwitchoff(int switchoff) {
        this.switchoff = switchoff;
    }
    public String getElectric_ip() {
        return electric_ip;
    }
    public void setElectric_ip(String electric_ip) {
        this.electric_ip = electric_ip;
    }
    @Override
    public String toString() {
@@ -145,8 +155,7 @@
                + ", fanstart=" + fanstart + ", fanstop=" + fanstop
                + ", dcvol=" + dcvol + ", dccurr=" + dccurr + ", controlangle="
                + controlangle + ", switchon=" + switchon + ", switchoff="
                + switchoff + "]";
                + switchoff + ", electric_ip=" + electric_ip + "]";
    }
	
    
}

 DyEnvir_system/src/com/modbus/data/BaseData.java

New file
@@ -0,0 +1,197 @@
package com.modbus.data;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;



public class BaseData {
    public static final int ReadByteCount = 12;
	
    public static final int SINGLEWRITE_BYTECOUNT = 6;
	
    public int transsend;                //发送事务标识符
    public int transreceive;            //接收事务标识符
    public int protocolident;            //协议标识符
    public int datacount;                //数据长度[本字节下一个到最后]
    public int unitident = 0x02;        //单元标识符[当前单元固定为2]
    public int funcode;                    //功能码
    public int addrstart;                //寄存器起始地址
    public int regcount;                //寄存器数量
    public int bytecount;                //数据区字节数量
    public byte[] data;                    //数据区数据
	
    public BaseData() {
		
    }
	
    public BaseData(int cmd_code,int regstart,int regcount) {
        this.funcode = cmd_code;
        this.addrstart = regstart;
        this.regcount = regcount;
    }
	
    /**
     * 构造发送数据
     * @param cmd_code        命令码
     * @param addrstart        寄存器起始地址
     * @param regcount        寄存器数量
     * @return
     */
    public byte[] createReadData() {
        ByteBuffer bf = ByteBuffer.allocate(ReadByteCount);
        bf.order(ByteOrder.BIG_ENDIAN);
        bf.putShort(ComBase.changeIntToShort(addrstart));        //接收标识          将寄存器起始地址放在标识中[2个字节]
        bf.putShort(ComBase.changeIntToShort(0x0000));            //协议标识符
        bf.putShort(ComBase.changeIntToShort(0x0006));            //下面字节长度
        bf.put(ComBase.changeIntToByte(unitident));                //单元标识符(设备ID)
        bf.put(ComBase.changeIntToByte(funcode));                //功能码
        bf.putShort(ComBase.changeIntToShort(addrstart));        //寄存器起始地址
        bf.putShort(ComBase.changeIntToShort(regcount));
        bf.flip();
        byte[] databyte = new byte[ReadByteCount];
        bf.get(databyte);
        return databyte;
    }
	
    /*
     * 保持寄存器单点输入
     * */
    public byte[] createSingleResWiriteData(byte[] data) {
        ByteBuffer bf = ByteBuffer.allocate(ReadByteCount+regcount*2+1);
        bf.order(ByteOrder.BIG_ENDIAN);
        bf.putShort(ComBase.changeIntToShort(addrstart));        //接收标识          将寄存器起始地址放在标识中[2个字节]
        bf.putShort(ComBase.changeIntToShort(0x0000));            //协议标识符
        bf.putShort(ComBase.changeIntToShort(4+regcount*2));    //下面字节长度
        bf.put(ComBase.changeIntToByte(unitident));                //单元标识符(设备ID)
        bf.put(ComBase.changeIntToByte(funcode));                //功能码
        bf.putShort(ComBase.changeIntToShort(addrstart));        //寄存器起始地址
        bf.put(data);                                            //目标值
        bf.flip();
        byte[] databyte = new byte[bf.limit()];
        bf.get(databyte);
        //System.out.println(ComFn.bytesToHexString(databyte, databyte.length));
        return databyte;
    }
	
	
	
    /**
     *     构造单点写入数据
     * @param value
     * @return
     */
    public byte[] createSingleCollWiriteData(byte[] data) {
        ByteBuffer bf = ByteBuffer.allocate(ReadByteCount+regcount*2+1);
        bf.order(ByteOrder.BIG_ENDIAN);
        bf.putShort(ComBase.changeIntToShort(addrstart));        //接收标识          将寄存器起始地址放在标识中[2个字节]
        bf.putShort(ComBase.changeIntToShort(0x0000));            //协议标识符
        bf.putShort(ComBase.changeIntToShort(4+regcount*2));    //下面字节长度
        bf.put(ComBase.changeIntToByte(unitident));                //单元标识符(设备ID)
        bf.put(ComBase.changeIntToByte(funcode));                //功能码
        bf.putShort(ComBase.changeIntToShort(addrstart));        //寄存器起始地址
        bf.put(data);                                            //目标值
        bf.flip();
        byte[] databyte = new byte[bf.limit()];
        bf.get(databyte);
        //System.out.println(ComFn.bytesToHexString(databyte, databyte.length));
        return databyte;
    }
	
	
    /**
     *     构造多点写入数据
     * @param value
     * @return
     */
    public byte[] createWiriteData(byte[] data) {
        ByteBuffer bf = ByteBuffer.allocate(ReadByteCount+regcount*2+1);
        bf.order(ByteOrder.BIG_ENDIAN);
        bf.putShort(ComBase.changeIntToShort(addrstart));        //接收标识          将寄存器起始地址放在标识中[2个字节]
        bf.putShort(ComBase.changeIntToShort(0x0000));            //协议标识符
        bf.putShort(ComBase.changeIntToShort(7+regcount*2));    //下面字节长度
        bf.put(ComBase.changeIntToByte(unitident));                //单元标识符(设备ID)
        bf.put(ComBase.changeIntToByte(funcode));                //功能码
        bf.putShort(ComBase.changeIntToShort(addrstart));        //寄存器起始地址
        bf.putShort(ComBase.changeIntToShort(regcount));         //寄存器数量
        bf.put(ComBase.changeIntToByte(regcount*2));            //写字节数量
        bf.put(data);                                            //目标值
        bf.flip();
        byte[] databyte = new byte[bf.limit()];
        bf.get(databyte);
        return databyte;
    }
	
    /**
     * 构造按钮控制数据
     * @return
     */
    public static byte[] createButtonByte(int value) {
        if(value==1){
            value=0xff00;
        }else{
            value=0x0000;
        }
        ByteBuffer bf = ByteBuffer.allocate(2);
        bf.order(ByteOrder.BIG_ENDIAN);
        bf.putShort(ComBase.changeIntToShort(value));
        bf.flip();
        byte[] b = new byte[2];
        bf.get(b);
        return b;
    }
	
    /**
     * 构造写入多个寄存器数据
     * @param value
     * @return
     */
    public static byte[] createFloatByte(float value) {
        ByteBuffer bf = ByteBuffer.allocate(4);
        bf.order(ByteOrder.BIG_ENDIAN);
        bf.putFloat(value);
        bf.flip();
        byte[] b = new byte[4];
        bf.get(b);
        return b;
    }
	
    /**
     * 构造写入多个寄存器数据
     * @param value
     * @return
     */
    public static byte[] createIntByte(int value) {
        ByteBuffer bf = ByteBuffer.allocate(2);
        bf.order(ByteOrder.BIG_ENDIAN);
        bf.putShort(ComBase.changeIntToShort(value));
        bf.flip();
        byte[] b = new byte[2];
        bf.get(b);
        return b;
    }
	
    /**
     * 
     * @return
     */
    public boolean putByteBuffer(ByteBuffer bf) {
        ByteBuffer tmpbuf = bf;
        if(tmpbuf.limit() < 8) {
            return false;
        }
        tmpbuf.position(0);
        transsend = ComBase.changeShortToInt(bf.getShort());
        protocolident = ComBase.changeShortToInt(bf.getShort());
        datacount = ComBase.changeShortToInt(bf.getShort());
        unitident = ComBase.changeByteToInt(bf.get());
        addrstart = transsend;
        if(unitident != 0x02) {
            return false;
        }
        funcode = ComBase.changeByteToInt(bf.get());
        return true;
    }
	
	
}

 DyEnvir_system/src/com/modbus/data/ComBase.java

New file
@@ -0,0 +1,131 @@
package com.modbus.data;
/**
 * 数据转换
 * @author LiJun
 *
 */
public class ComBase {
	
	
    public static byte changeIntToByte(int data)
    {
        return (byte)(data & 0xFF);
    }
    //------------------------------------------------------------------------------
    public static short changeIntToShort(int data)
    {
        return (short)(data & 0xFFFF);
    }
    //------------------------------------------------------------------------------
    public static byte changeShortToByte(short data)
    {
        return (byte)(data & 0xFF);
    }
    //------------------------------------------------------------------------------
    public static int changeByteToInt(byte data)
    {
        int tmp = data;
        return (tmp & 0xFF);
    }
    //------------------------------------------------------------------------------
    public static int changeShortToInt(short data)
    {
        int tmp = data;
        return (tmp & 0xFFFF);
    }
    //------------------------------------------------------------------------------
    public static double changeShortToDouble(short data)
    {
        int tmp = data & 0xFFFF;
        return (double)(tmp);
    }
	
    public static int ByteToHex(byte temp1 ,byte temp2) {  
        int Rtemp;
        Rtemp = ((temp1 &0xff)<<8) | (temp2 & 0xff);
        return (short)Rtemp;
    } 
	 

    public static int ByteToHexxx(byte temp1 ,byte temp2) {
        int Rtemp;
        Rtemp = ((temp1 &0xff)<<8) | (temp2 & 0xff);
        return (int)Rtemp;
    } 

    public static int ByteToInt(byte temp1 ,byte temp2,byte temp3 ,byte temp4){
        int Rtemp; 
        int Rtemp1,Rtemp2;
        Rtemp = 0;
        Rtemp1 = ByteToHexxx( temp3 ,temp4);
        Rtemp2 = ByteToHexxx( temp1 ,temp2);
        Rtemp= (int)(Rtemp1<<16) +(int)(Rtemp2);
        return Rtemp;
    }
	
    public static long ByteToLong(byte temp1 ,byte temp2,byte temp3 ,byte temp4){
        long Rtemp; 
        long Rtemp1,Rtemp2;
        Rtemp = 0;
        Rtemp1 = ByteToHexxx( temp3 ,temp4);
        Rtemp2 = ByteToHexxx( temp1 ,temp2);
        Rtemp= (int)(Rtemp1<<16) +(int)(Rtemp2);
        return Rtemp;
    }

	
    public static byte[] IntToByte(int num){
        byte[]bytes=new byte[4];
        bytes[0]=(byte) ((num>>8)&0xff);
        bytes[1]=(byte) ((num)&0xff);
        bytes[2]=(byte) ((num>>24)&0xff);
        bytes[3]=(byte) (num>>16&0xff);
        return bytes;
    }
	
    public static byte[] LongToByte(long num){
        byte[]bytes=new byte[4];
        bytes[0]=(byte) ((num>>8)&0xff);
        bytes[1]=(byte) ((num)&0xff);
        bytes[2]=(byte) ((num>>24)&0xff);
        bytes[3]=(byte) (num>>16&0xff);
        return bytes;
    }
	
    public static int my_power_2(int N){
        StringBuffer v = new StringBuffer("");
        long num[] = new long[2];
        num[1] = 1;
        if(N > 62){
           num[0] = 1;
           num[0] = num[0]<<(N - 62);
           num[1] = num[1]<<62;
           String s = String.valueOf(num[1]);
           int size = 30,i = 0,j = 0;
           long n[] = new long[size + 1];
           //System.out.println(num[0]+" "+s);
           for(i = s.length() - 1;i >= 0;-- i){
               n[j ++] = (long) (num[0] * (s.charAt(i) - '0'));
               //System.out.println(n[j - 1]);
           }
           for(i = 0;i < size;++ i){
               while(n[i] > 9){
                   n[i + 1] += n[i] / 10;
                   n[i] %= 10;
               }
           }
           boolean bl = false;
           for(i = size;i >= 0;-- i){
               if(n[i] != 0 || bl){
                   v.append(n[i]);
                   bl = true;
               }
           }
        }else{
           num[1] = num[1] << N;
           v.append(String.valueOf(num[1]));
        }   
        return Integer.parseInt(v.toString());
    }
	
}

 DyEnvir_system/src/com/modbus/data/ComFn.java

New file
@@ -0,0 +1,36 @@
package com.modbus.data;
public class ComFn {
    public static String bytesToHexString(byte[] src, int len){
        StringBuilder stringBuilder = new StringBuilder("");
        if (src == null || len <= 0) {
            return null;
        }
        for (int i = 0; i < len; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v).toUpperCase();
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv + " ");
        }
        return stringBuilder.toString();
    }
	
    /**
     * 16进制字符串 转换为对应的 byte数组
     */
    public static byte[] hex2Bytes(String hex) {
        if (hex == null || hex.length() == 0) {
            return null;
        }

        char[] hexChars = hex.toCharArray();
        byte[] bytes = new byte[hexChars.length / 2];   // 如果 hex 中的字符不是偶数个, 则忽略最后一个

        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) Integer.parseInt("" + hexChars[i * 2] + hexChars[i * 2 + 1], 16);
        }

        return bytes;
    }
}

 DyEnvir_system/src/com/modbus/data/Modbus_ComBase.java

New file
@@ -0,0 +1,16 @@
package com.modbus.data;
public class Modbus_ComBase {
	
    public static final int NULL_STATUS                 = 0x00;
    public static final int READ_COIL_STATUS             = 0x01;            //读线圈状态            单/多
    public static final int READ_INPUT_STATUS             = 0x02;            //读离散输入状态        单/多
    public static final int READ_HOLDING_REGISTER         = 0x03;         //读保持寄存器            单/多
    public static final int READ_INPUT_REGISTER         = 0x04;            //读输入寄存器            单/多
    public static final int WRITE_SINGLE_COIL             = 0x05;            //写线圈状态            单
    public static final int WRITE_SINGLE_REGISTER         = 0x06;            //写单个保持寄存器        单
    public static final int WRITE_MULTIPLE_COIL         = 0x0F;            //写多个线圈            多
    public static final int WRITE_MULTIPLE_REGISTER     = 0x10;            //写多个保持寄存器        多
	
	
	
}

 DyEnvir_system/src/com/modbus/data/MyModbusFactory.java

New file
@@ -0,0 +1,43 @@
package com.modbus.data;

import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.ip.IpParameters;

public class MyModbusFactory {
    private static final int SERVER_PORT = 502;                //服务端口
	
    static ModbusFactory modbusFactory;
	
    static {
        if (modbusFactory == null) {
            modbusFactory = new ModbusFactory();
        }
    }
	
    /**
     * 获取master
     * 
     * @return
     * @throws ModbusInitException
     */
    public static ModbusMaster getMaster(IpParameters params){
        // modbusFactory.createRtuMaster(wapper);         //RTU 协议
        // modbusFactory.createUdpMaster(params);        //UDP 协议
        // modbusFactory.createAsciiMaster(wrapper);    //ASCII 协议
        params.setPort(SERVER_PORT);
        ModbusMaster master = modbusFactory.createTcpMaster(params, true);// TCP 协议
        try {
             //设置超时时间
            master.setTimeout(1000);
            //设置重连次数
            master.setRetries(3);
            //初始化
            master.init();
        } catch (ModbusInitException e) {
            //e.printStackTrace();
        }
        return master;
    }
}

 DyEnvir_system/src/com/modbus/data/MyModbusMaster.java

New file
@@ -0,0 +1,131 @@
package com.modbus.data;

import java.text.NumberFormat;

import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.ip.IpParameters;

public class MyModbusMaster {
    public final static int SLAVEID_DEFAULT = 2;
	
    public final static int MAX_ERROR_COUNT = 2;        //最大连续错误计数
    private ModbusMaster master;
    private int errcount;                                //错误计数    错误连续超过三个时重新获取master
    private int totalerr;                                //总的错误计数            //用于判别设备是否掉线
    private String target_ip;                            //目标ip
    private int slaveId;                                //设备ID
	
    public MyModbusMaster(String target_ip,int slaveId) {
        this.target_ip = target_ip;
        this.slaveId = slaveId;
        System.out.println(111);
        IpParameters params = new IpParameters();
        params.setHost(target_ip);
        System.out.println(params);
        this.master = MyModbusFactory.getMaster(params);
    }
	
    public void addErrorCount() {
        this.errcount++;
        if(this.errcount > MAX_ERROR_COUNT) {
            reConnect();
        }
        if(this.totalerr > 99999999) {
            this.totalerr = 5;
        }
        this.totalerr ++;
    }
	
    //清空错误计数
    public void clearError() {
        errcount = 0;
        totalerr = 0;
    }
	
    public void reConnect() {
        IpParameters params = new IpParameters();
        params.setHost(target_ip);
        if(this.master != null) {
            //清空上一个master
            this.master.destroy();
        }
        this.errcount = 0;
        this.master = MyModbusFactory.getMaster(params);
    }
	
    /**
     *     判断获取到的值是否为空
     * @param target
     * @param source
     * @return
     */
    public static Object checkNullData(Object target,Object source) {
        if(null == target) {
            return source;
        }
        try {
            if(target instanceof Number) {
                if(source instanceof Integer) {
                    return ((Number) target).intValue();
                }else if(source instanceof Float) {
                    return ((Number) target).floatValue();
                }
            }
            if(target instanceof Boolean) {
                //判断Boolean类型数据
                if((Boolean)target) {
                    target = 1;
                }else {
                    target = 0;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return target;
		
    }
	
    public int getTotalerr() {
        return totalerr;
    }

    public void setTotalerr(int totalerr) {
        this.totalerr = totalerr;
    }

    public ModbusMaster getMaster() {
        return master;
    }
    public int getErrcount() {
        return errcount;
    }
    public void setMaster(ModbusMaster master) {
        this.master = master;
    }
    public void setErrcount(int errcount) {
        this.errcount = errcount;
    }

    public String getTarget_ip() {
        return target_ip;
    }

    public void setTarget_ip(String target_ip) {
        this.target_ip = target_ip;
    }

    public int getSlaveId() {
        return slaveId;
    }

    public void setSlaveId(int slaveId) {
        this.slaveId = slaveId;
    }

    @Override
    public String toString() {
        return "MyModbusMaster [SLAVEID_DEFAULT=" + SLAVEID_DEFAULT + ", master=" + master + ", errcount=" + errcount
                + ", target_ip=" + target_ip + ", slaveId=" + slaveId + "]";
    }
}

 DyEnvir_system/src/com/modbus/data/MyModbusUtils.java

New file
@@ -0,0 +1,323 @@
package com.modbus.data;

import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.locator.BaseLocator;
import com.serotonin.modbus4j.msg.ModbusResponse;
import com.serotonin.modbus4j.msg.WriteCoilRequest;
import com.serotonin.modbus4j.msg.WriteCoilResponse;
import com.serotonin.modbus4j.msg.WriteCoilsRequest;
import com.serotonin.modbus4j.msg.WriteCoilsResponse;
import com.serotonin.modbus4j.msg.WriteRegisterRequest;
import com.serotonin.modbus4j.msg.WriteRegisterResponse;
import com.serotonin.modbus4j.msg.WriteRegistersRequest;

public class MyModbusUtils {
		
    /**
     * 读取[01 Coil Status 0x]类型 开关数据
     * 
     * @param slaveId
     *            slaveId
     * @param offset
     *            位置
     * @return 读取值
     */
    public static Boolean readCoilStatus(int offset,MyModbusMaster master){
        // 01 Coil Status
        BaseLocator<Boolean> loc = BaseLocator.coilStatus(master.getSlaveId(), offset);
        Boolean value = null;
        boolean isSuccess = true;
        try {
            value = master.getMaster().getValue(loc);
        } catch (ModbusTransportException | ErrorResponseException e) {
            //e.printStackTrace();
            isSuccess = false;
        } finally {
            if(isSuccess) {
                master.clearError();
            }else {
                master.addErrorCount();
            }
        }
        return value;
    }
 
    /**
     * 读取[02 Input Status 1x]类型 开关数据
     * 
     * @param slaveId
     * @param offset
     * @return
     */
    public static Boolean readInputStatus(int offset,MyModbusMaster master){
        // 02 Input Status
        BaseLocator<Boolean> loc = BaseLocator.inputStatus(master.getSlaveId(), offset);
        Boolean value = null;;
        boolean isSuccess = true;
        try {
            value = master.getMaster().getValue(loc);
        } catch (ModbusTransportException | ErrorResponseException e) {
            //e.printStackTrace();
            isSuccess = false;
        } finally {
            if(isSuccess) {
                master.clearError();
            }else {
                master.addErrorCount();
            }
        }
        return value;
    }
 
    /**
     * 读取[03 Holding Register类型 2x]模拟量数据
     * 
     * @param slaveId
     *            slave Id
     * @param offset
     *            位置
     * @param dataType
     *            数据类型,来自com.serotonin.modbus4j.code.DataType
     * @return
     */
    public static Number readHoldingRegister(int offset, int dataType,MyModbusMaster master){
        // 03 Holding Register类型数据读取
        BaseLocator<Number> loc = BaseLocator.holdingRegister(master.getSlaveId(), offset, dataType);
        Number value = null;
        boolean isSuccess = true;
        try {
            value = master.getMaster().getValue(loc);
        } catch (ModbusTransportException | ErrorResponseException e) {
            //e.printStackTrace();
            isSuccess = false;
        }  finally {
            if(isSuccess) {
                master.clearError();
            }else {
                master.addErrorCount();
            }
        }
        return value;
    }
 
    /**
     * 读取[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(int offset, int dataType,MyModbusMaster master){
        // 04 Input Registers类型数据读取
        BaseLocator<Number> loc = BaseLocator.inputRegister(master.getSlaveId(), offset, dataType);
        Number value = null;
        boolean isSuccess = true;
        try {
            value = master.getMaster().getValue(loc);
        } catch (ModbusTransportException | ErrorResponseException e) {
            //e.printStackTrace();
            isSuccess = false;
        } finally {
            if(isSuccess) {
                master.clearError();
            }else {
                master.addErrorCount();
            }
        }
        return value;
    }
 
    /**
     * 批量读取使用方法
     * 
     * @throws ModbusTransportException
     * @throws ErrorResponseException
     * @throws ModbusInitException
     */
    public static void batchRead() { 
//        BatchRead<Integer> batch = new BatchRead<Integer>();
// 
//        batch.addLocator(0, BaseLocator.holdingRegister(1, 1, DataType.FOUR_BYTE_FLOAT));
//        batch.addLocator(1, BaseLocator.inputStatus(1, 0));
// 
//        ModbusMaster master = getMaster();
// 
//        batch.setContiguousRequests(false);
//        BatchResults<Integer> results = master.send(batch);
//        System.out.println(results.getValue(0));
//        System.out.println(results.getValue(1));
    }

    /**
     * 写 [01 Coil Status(0x)]写一个 function ID = 5
     * 
     * @param slaveId
     *            slave的ID
     * @param writeOffset
     *            位置
     * @param writeValue
     *            值
     * @return 是否写入成功
     */
    public static boolean writeCoil(int writeOffset, boolean writeValue,MyModbusMaster master){
        // 获取master
        ModbusMaster tcpMaster = master.getMaster();
        // 创建请求
        // 发送请求并获取响应对象
        WriteCoilResponse response = null;
        try {
            WriteCoilRequest request = new WriteCoilRequest(master.getSlaveId(), writeOffset, writeValue);
            response = (WriteCoilResponse) tcpMaster.send(request);
        } catch (ModbusTransportException e) {
            e.printStackTrace();
        }
        if (response == null || response.isException()) {
            master.addErrorCount();
            return false;
        } else {
            master.clearError();
            return true;
        }
    }
 
    /**
     * 写[01 Coil Status(0x)] 写多个 function ID = 15
     * 
     * @param slaveId
     *            slaveId
     * @param startOffset
     *            开始位置
     * @param bdata
     *            写入的数据
     * @return 是否写入成功
     */
    public static boolean writeCoils(int startOffset, boolean[] bdata,MyModbusMaster master) {
        // 获取master
        ModbusMaster tcpMaster = master.getMaster();
        // 创建请求
        WriteCoilsRequest request;
        WriteCoilsResponse response = null;
        try {
            request = new WriteCoilsRequest(master.getSlaveId(), startOffset, bdata);
            response = (WriteCoilsResponse) tcpMaster.send(request);
        } catch (ModbusTransportException e) {
            e.printStackTrace();
        }
        // 发送请求并获取响应对象
        if (response == null || response.isException()) {
            master.addErrorCount();
            return false;
        } else {
            master.clearError();
            return true;
        }
 
    }
 
    /***
     * 写[03 Holding Register(4x)] 写一个 function ID = 6
     * 
     * @param slaveId
     * @param writeOffset
     * @param writeValue
     * @return
     */
    public static boolean writeRegister(int writeOffset, short writeValue,MyModbusMaster master){
        // 获取master
        ModbusMaster tcpMaster = master.getMaster();
        // 创建请求对象
        WriteRegisterRequest request;
        WriteRegisterResponse response = null;
        try {
            request = new WriteRegisterRequest(master.getSlaveId(), writeOffset, writeValue);
            response = (WriteRegisterResponse) tcpMaster.send(request);
        } catch (ModbusTransportException e) {
            e.printStackTrace();
        }
        if (response == null || response.isException()) {
            master.addErrorCount();
            return false;
        } else {
            master.clearError();
            return true;
        }
 
    }
 
    /**
     * 
     * 写入[03 Holding Register(4x)]写多个 function ID=16
     * 
     * @param slaveId
     *            modbus的slaveID
     * @param startOffset
     *            起始位置偏移量值
     * @param sdata
     *            写入的数据
     * @return 返回是否写入成功
     */
    public static boolean writeRegisters(int startOffset, short[] sdata,MyModbusMaster master){
        // 获取master
        ModbusMaster tcpMaster = master.getMaster();
        // 创建请求对象
        WriteRegistersRequest request;
        // 发送请求并获取响应对象
        ModbusResponse response = null;
        try {
            request = new WriteRegistersRequest(master.getSlaveId(), startOffset, sdata);
            response = tcpMaster.send(request);
        } catch (ModbusTransportException e) {
            e.printStackTrace();
        }
        if (response.isException()) {
            //log.error(response.getExceptionMessage());
            master.addErrorCount();
            return false;
        } else {
            master.clearError();
            return true;
        }
    }
 
    /**
     * 写入数字类型的模拟量（如:写入Float类型的模拟量、Double类型模拟量、整数类型Short、Integer、Long）
     * 
     * @param slaveId
     * @param offset
     * @param value
     *            写入值,Number的子类,例如写入Float浮点类型,Double双精度类型,以及整型short,int,long
     * @param registerCount
     *            ,com.serotonin.modbus4j.code.DataType
     */
    public static void writeHoldingRegister(int offset, Number value, int dataType,MyModbusMaster master){
        // 获取master
        ModbusMaster tcpMaster = master.getMaster();
        // 类型
        BaseLocator<Number> locator = BaseLocator.holdingRegister(master.getSlaveId(), offset, dataType);
        boolean isSuccess = true;
        try {
            tcpMaster.setValue(locator, value);
        } catch (ModbusTransportException | ErrorResponseException e) {
            //e.printStackTrace();
            isSuccess = true;
        } finally {
            if(isSuccess) {
                master.clearError();
            }else {
                master.addErrorCount();
            }
        }
    }
}

 DyEnvir_system/src/com/modbus/data/SocketClient.java

New file
@@ -0,0 +1,76 @@
package com.modbus.data;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Date;

public class SocketClient {

    // socket发送和读取数据
    public static boolean SocketComm(byte[] bytedata, String ip)throws InterruptedException {
        boolean res_t = false;
        InputStream in = null;
        OutputStream out = null;
        Socket socket = new Socket();
        ByteBuffer bytebuffer_for_socket_RX = ByteBuffer.allocate(1500);
        try {
            socket.connect(new InetSocketAddress(ip, 502), 5000);
            socket.setSoTimeout(3000);
            if (socket != null) {
                in = socket.getInputStream();
                out = socket.getOutputStream();
                // ----------------- clear rx buff for tcp resend packet
                // ----------------//
                byte[] rx_buf_t = new byte[1024];
                // ----------------------------------------------------------------------//
                bytebuffer_for_socket_RX.order(ByteOrder.BIG_ENDIAN);
                bytebuffer_for_socket_RX.clear();
                // --------------------- socket write
                // -----------------------------------//
                // byte[] b = makeCommBuf(cmd, bf);
                // System.err.println("发送数据："+ComFn.bytesToHexString(bytedata,
                // bytedata.length));
                Date d1 = new Date();
                int rx_read_time_out = 0;
                // int rx_len = 0;
                // System.err.println("TX: " + ComFn.bytesToHexString(b,
                // b.length));
                out.write(bytedata);
                out.flush();
                res_t=true;
            }
        } catch (IOException e) {
            res_t=false;
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
			
        }
        return res_t;
    }

}