私.Modbus測試_ZC03_rtu,ascii,tcp

ZC：另外一些信息在 “Modbus資料 - codeskill_android - 博客園.html”（https://www.cnblogs.com/codeskilla/p/9998416.html）

 

1、文章：modbus4j,rtu,ascii,tcp_ip傳輸模式 - 狂野的河 - CSDN博客.html（https://blog.csdn.net/u013150916/article/details/78065479?locationNum=9&fps=1#commentBox）

2、包：路徑：“...\ZC_IDE\Java_3rd\modbus_java\02_新一點的\Mango Automation\”

　　JAR：主要都是來自 m2m2-modbus-1.5.4.zip 中的 lib文件夾

　　源碼：沒有去找對應版本jar的源碼（也不知道能不能找到）

3、測試代碼：

package com.test.modbus;

import java.util.Arrays;

import org.junit.Test;

import com.serotonin.modbus4j.BasicProcessImage;
import com.serotonin.modbus4j.BatchRead;
import com.serotonin.modbus4j.BatchResults;
import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.ModbusSlaveSet;
import com.serotonin.modbus4j.ProcessImage;
import com.serotonin.modbus4j.ProcessImageListener;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.IllegalDataAddressException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.ip.IpParameters;
import com.serotonin.modbus4j.locator.BaseLocator;
import com.serotonin.modbus4j.msg.ReadCoilsRequest;
import com.serotonin.modbus4j.msg.ReadCoilsResponse;
import com.serotonin.modbus4j.msg.ReadDiscreteInputsRequest;
import com.serotonin.modbus4j.msg.ReadDiscreteInputsResponse;
import com.serotonin.modbus4j.msg.ReadExceptionStatusRequest;
import com.serotonin.modbus4j.msg.ReadExceptionStatusResponse;
import com.serotonin.modbus4j.msg.ReadHoldingRegistersRequest;
import com.serotonin.modbus4j.msg.ReadHoldingRegistersResponse;
import com.serotonin.modbus4j.msg.ReadInputRegistersRequest;
import com.serotonin.modbus4j.msg.ReadInputRegistersResponse;
import com.serotonin.modbus4j.msg.ReportSlaveIdRequest;
import com.serotonin.modbus4j.msg.ReportSlaveIdResponse;
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.WriteMaskRegisterRequest;
import com.serotonin.modbus4j.msg.WriteMaskRegisterResponse;
import com.serotonin.modbus4j.msg.WriteRegisterRequest;
import com.serotonin.modbus4j.msg.WriteRegisterResponse;
import com.serotonin.modbus4j.msg.WriteRegistersRequest;
import com.serotonin.modbus4j.msg.WriteRegistersResponse;

import com.serotonin.io.serial.SerialParameters;

public class MasterTest
{
    
    public static void main(String[] args) throws Exception
    {
        
            //TCP傳輸方式
//            ModbusMaster master = getTcpMaster();
            //RTU傳輸方式
            ModbusMaster master = getRtuMaster();
            //ASCII傳輸模式
//            ModbusMaster master = getAsiiMaster();
//           ModbusMaster master = modbusFactory.createUdpMaster(ipParameters);
 
        try {
            //初始化
            //設置超時時間
            master.setTimeout(500);
            //設置重連次數
            master.setRetries(1);
            master.init();
            //設置從站ID
            int slaveId = 1;
            
            //測試校驗
//            Timer timer = new Timer();
//            timer.schedule(new TimerTask() {
//                
//                @Override
//                public void run() {
//                    //RTU
//                    ModbusMaster master = getRtuMaster();
//                    //ASCII
////                    ModbusMaster master = getAsiiMaster();
//                    try {
//                        master.init();
//                        readCoilTest(master, 1, 0, 10);
//                    } catch (ModbusInitException e) {
//                        e.printStackTrace();
//                    } finally {
//                        master.destroy();
//                    }
//                }
//            }, 100, 1000);
            
            //------------------讀---------------
            //讀取開關量狀態   01
//            readCoilTest(master, slaveId, 0, 5);
            //讀取外部設備輸入開關量狀態  02
//            readDiscreteInputTest(master, slaveId, 0, 10);
            //讀取保持寄存器數據 03
//            readHoldingRegistersTest(master, slaveId, 0, 10);
            //讀取外圍設備輸入的數據 04
//            readInputRegistersTest(master, slaveId, 0, 10);
            //------------------寫---------------
            //開關量寫單個數據 05
//            writeCoilTest(master, slaveId, 9, true);
            //開關量寫入多個數據 15
//            writeCoilsTest(master, slaveId, 0, new boolean[] {true, true, true, true, true});
            //寫入單個模擬量數據 06
//            writeRegisterTest(master, slaveId, 0, 100);
            //寫入多個模擬量數據 16
//            writeRegistersTest(master, slaveId, 0, new short[] {1, 10, 100, 1000, 10000, (short) 65534});
 
            //批量讀取
//               bathRead(master, slaveId);
            //根據類型寫
               writeValue(master);
            //異常
//               readExceptionStatusTest(master, slaveId);
 
        }
        finally {
            master.destroy();
        }
    }
 
 
 
    /**
     * @Description: 根據類型寫數據
     * @param master
     * @throws ModbusTransportException
     * @throws ErrorResponseException 
     */
    public static void writeValue(ModbusMaster master) throws ModbusTransportException, ErrorResponseException {
 
//        BaseLocator<?> createLocator = StringLocator.createLocator(1, 1, DataType.TWO_BYTE_INT_UNSIGNED, 1, 2);
        
//        BaseLocator<Number> hr1 = BaseLocator.holdingRegister(1, 0, DataType.TWO_BYTE_INT_UNSIGNED);
//        BaseLocator<Number> hr1 = BaseLocator.holdingRegister(1, 0, DataType.TWO_BYTE_INT_UNSIGNED_SWAPPED);
//        BaseLocator<Number> hr1 = BaseLocator.holdingRegister(1, 0, DataType.TWO_BYTE_INT_UNSIGNED);
//        BaseLocator<Number> hr1 = BaseLocator.holdingRegister(1, 0, DataType.FOUR_BYTE_INT_UNSIGNED);
        //測試高低位0x12345678
//        BaseLocator<Number> hr1 = BaseLocator.holdingRegister(1, 0, DataType.FOUR_BYTE_INT_UNSIGNED);
//        BaseLocator<Number> hr1 = BaseLocator.holdingRegister(1, 0, DataType.FOUR_BYTE_INT_UNSIGNED_SWAPPED);
//        BaseLocator<Number> hr1 = BaseLocator.inputRegister(1, 0, DataType.FOUR_BYTE_INT_UNSIGNED_SWAPPED);
        BaseLocator<Number> hr1 = BaseLocator.holdingRegister(1, 0, DataType.FOUR_BYTE_INT_UNSIGNED_SWAPPED);// ZC: 上面那樣會報錯，我改成的這樣
//        BaseLocator<Number> hr2 = BaseLocator.holdingRegister(1, 0, DataType.TWO_BYTE_INT_UNSIGNED);
        //測試浮點數
//        BaseLocator<Number> hr2 = BaseLocator.holdingRegister(1, 0, DataType.FOUR_BYTE_INT_UNSIGNED);
//        master.setValue(hr2, 0x3F800000);
        
         master.setValue(hr1, 0x12345678);
         
        
    }
 
       
 
    /**
     * @Description: 批量讀取    可以批量讀取不同寄存器中數據
     * @param master
     * @param slaveId
     * @throws ModbusTransportException
     * @throws ErrorResponseException 
     */
    public static void bathRead(ModbusMaster master, int slaveId)
            throws ModbusTransportException, ErrorResponseException {
        
        
            BatchRead<Number> batch = new BatchRead<Number>();
            
            //****************批量讀取不同寄存器中的單個數據********************
            //讀取線圈狀態開關量
//               batch.addLocator(1, BaseLocator.coilStatus(slaveId, 0));
               //讀取輸入狀態 開關量
//               batch.addLocator(2, BaseLocator.inputStatus(slaveId, 0));
           
               //讀取保持寄存器數據
               //根據設置的數據類型讀取
//               batch.addLocator(3, BaseLocator.holdingRegister(slaveId, 0, DataType.TWO_BYTE_INT_UNSIGNED));
               //讀取整形中16位中某一位的布爾值
//               batch.addLocator(3.1, BaseLocator.holdingRegisterBit(slaveId, 0, 0));
               
               //讀取輸入寄存器數據
               //根據設置的數據類型讀取
//               batch.addLocator(4, BaseLocator.inputRegister(slaveId, 0, DataType.TWO_BYTE_INT_UNSIGNED));
             //讀取整形中16位中某一位的布爾值
//               batch.addLocator(4.1, BaseLocator.inputRegisterBit(slaveId, 0, 0));
               
               //高低字節顛倒
               batch.addLocator(1, BaseLocator.holdingRegister(slaveId, 0, DataType.FOUR_BYTE_INT_UNSIGNED_SWAPPED));
               //高低字節不顛倒
//               batch.addLocator(1, BaseLocator.holdingRegister(slaveId, 0, DataType.FOUR_BYTE_INT_UNSIGNED));
               //讀取浮點數
//               batch.addLocator(1, BaseLocator.holdingRegister(slaveId, 0, DataType.FOUR_BYTE_FLOAT));
             BatchResults<Number> results = master.send(batch);
//             System.out.println("批量讀取1:--" + results.getValue(1));
//             System.out.println("批量讀取2:--" + results.getValue(2));
//             System.out.println("批量讀取3:--" + results.getValue(3));
//             System.out.println("批量讀取3.1:--" + results.getValue(3.1));
//             System.out.println("批量讀取3.2:--" + results.getValue(3.2));
//             System.out.println("批量讀取4:--" + results.getValue(4));
//             System.out.println("批量讀取4.1:--" + results.getValue(4.1));
             //高低字節顛倒
             System.out.println(Long.toHexString((long) results.getValue(1)));
             
             
    }
 
 
    
    /**
     * @Description: 讀取開關量
     * @param master 主站實例 
     * @param slaveId 從站ID
     * @param start 起始位
     * @param len 讀取的長度
     */
    public static void readCoilTest(ModbusMaster master, int slaveId, int start, int len) {
        try {
            ReadCoilsRequest request = new ReadCoilsRequest(slaveId, start, len);
            ReadCoilsResponse response = (ReadCoilsResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("功能碼:1--" + Arrays.toString(response.getBooleanData()));
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @Description: 讀取外圍設備輸入的開關量
     * @param master 主站實例
     * @param slaveId 從站ID
     * @param start 起始位
     * @param len 長度
     */
    public static void readDiscreteInputTest(ModbusMaster master, int slaveId, int start, int len) {
        try {
            ReadDiscreteInputsRequest request = new ReadDiscreteInputsRequest(slaveId, start, len);
            ReadDiscreteInputsResponse response = (ReadDiscreteInputsResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("功能碼:2--" + Arrays.toString(response.getBooleanData()));
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @Description: 讀取保持寄存器數據
     * @param master 主站實例
     * @param slaveId 從站ID
     * @param start 起始位
     * @param len 長度
     */
    public static void readHoldingRegistersTest(ModbusMaster master, int slaveId, int start, int len) {
        try {
            ReadHoldingRegistersRequest request = new ReadHoldingRegistersRequest(slaveId, start, len);
            ReadHoldingRegistersResponse response = (ReadHoldingRegistersResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("功能碼:3--" + Arrays.toString(response.getShortData()));
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @Description: 讀取外圍設備輸入的數據
     * @param master 主站實例
     * @param slaveId 從站ID
     * @param start 起始位
     * @param len 長度
     */
    public static void readInputRegistersTest(ModbusMaster master, int slaveId, int start, int len) {
        try {
            ReadInputRegistersRequest request = new ReadInputRegistersRequest(slaveId, start, len);
            ReadInputRegistersResponse response = (ReadInputRegistersResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("功能碼:4--" + Arrays.toString(response.getShortData()));
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @Description: 寫開關量數據
     * @param master 
     * @param slaveId 從站ID
     * @param offset 偏移量
     * @param value 寫入的值
     */
    public static void writeCoilTest(ModbusMaster master, int slaveId, int offset, boolean value) {
        try {
            WriteCoilRequest request = new WriteCoilRequest(slaveId, offset, value);
            WriteCoilResponse response = (WriteCoilResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("功能碼:1,寫入單個數據成功!");
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @Description: 保持寄存器，寫入單個數據
     * @param master
     * @param slaveId 從站ID
     * @param offset 偏移量
     * @param value 
     */
    public static void writeRegisterTest(ModbusMaster master, int slaveId, int offset, int value) {
        try {
            WriteRegisterRequest request = new WriteRegisterRequest(slaveId, offset, value);
            WriteRegisterResponse response = (WriteRegisterResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("功能碼:3,寫入單個模擬量數據成功!");
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @Description: 讀取異常狀態
     * @param master
     * @param slaveId 
     */
    public static void readExceptionStatusTest(ModbusMaster master, int slaveId) {
        try {
            ReadExceptionStatusRequest request = new ReadExceptionStatusRequest(slaveId);
            ReadExceptionStatusResponse response = (ReadExceptionStatusResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println(response.getExceptionStatus());
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    public static void reportSlaveIdTest(ModbusMaster master, int slaveId) {
        try {
            ReportSlaveIdRequest request = new ReportSlaveIdRequest(slaveId);
            ReportSlaveIdResponse response = (ReportSlaveIdResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println(Arrays.toString(response.getData()));
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @Description: 保持寄存器寫多個數據
     * @param master
     * @param slaveId 從站ID
     * @param start 起始位置
     * @param values 數值
     */
    public static void writeCoilsTest(ModbusMaster master, int slaveId, int start, boolean[] values) {
        try {
            WriteCoilsRequest request = new WriteCoilsRequest(slaveId, start, values);
            WriteCoilsResponse response = (WriteCoilsResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("功能碼:1,寫入多個數據成功!");
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @Description: 保持寄存器寫入多個模擬量數據
     * @param master
     * @param slaveId 從站ID
     * @param start modbus起始位置
     * @param values 數據
     */
    public static void writeRegistersTest(ModbusMaster master, int slaveId, int start, short[] values) {
        try {
            WriteRegistersRequest request = new WriteRegistersRequest(slaveId, start, values);
            WriteRegistersResponse response = (WriteRegistersResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("功能碼:3,寫入多個模擬量數據成功!");
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
 
    public static void writeMaskRegisterTest(ModbusMaster master, int slaveId, int offset, int and, int or) {
        try {
            WriteMaskRegisterRequest request = new WriteMaskRegisterRequest(slaveId, offset, and, or);
            WriteMaskRegisterResponse response = (WriteMaskRegisterResponse) master.send(request);
 
            if (response.isException())
                System.out.println("Exception response: message=" + response.getExceptionMessage());
            else
                System.out.println("Success");
        }
        catch (ModbusTransportException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * @return 
     * @Description: 獲取AsiiMaster
     */
    public static ModbusMaster getAsiiMaster(){
        SerialParameters serialParameters = new SerialParameters();
        // 設定MODBUS通訊的串行口
        serialParameters.setCommPortId("COM4");
        // 設置端口波特率
        serialParameters.setBaudRate(9600);
        //硬件之間輸入流應答控制 
        serialParameters.setFlowControlIn(0);
        //硬件之間輸出流應答控制 
        serialParameters.setFlowControlOut(0);
        //設定數據位的位數  RTU:8位    ASCII:7位
        serialParameters.setDataBits(7);
        //停止位的位數，如果無奇偶校驗為2，有奇偶校驗為1
        serialParameters.setParity(2);
        //停止位的位數，如果無奇偶校驗為2，有奇偶校驗為1
        serialParameters.setStopBits(1);
        // 設置端口名稱
        serialParameters.setPortOwnerName("ASCII");
        // 創建ModbusMaster工廠實例
        return new ModbusFactory().createAsciiMaster(serialParameters);
    }
    
    /**
     * @Description: 獲取AsiiSalve
     * @return 
     */
    public static ModbusSlaveSet getAsciiSalve(){
        SerialParameters serialParameters = new SerialParameters();
        // 設定MODBUS通訊的串行口
        serialParameters.setCommPortId("COM4");
        // 設置端口波特率
        serialParameters.setBaudRate(9600);
        //硬件之間輸入流應答控制 
        serialParameters.setFlowControlIn(0);
        //硬件之間輸出流應答控制 
        serialParameters.setFlowControlOut(0);
        //設定數據位的位數  RTU:8位    ASCII:7位
        serialParameters.setDataBits(7);
        //奇偶校驗位  無校驗：0 奇校驗：1 偶校驗：2
        serialParameters.setParity(2);
        //停止位的位數，如果無奇偶校驗為2，有奇偶校驗為1
        serialParameters.setStopBits(1);
        // 設置端口名稱
        serialParameters.setPortOwnerName("ASCII"); 
        // 創建ModbusMaster工廠實例
        return new ModbusFactory().createAsciiSlave(serialParameters);
    }
    /**
     * @return 
     * @Description: 獲取RTUMaster
     */
    public static ModbusMaster getRtuMaster(){
        SerialParameters serialParameters = new SerialParameters();
//         TestSerialPortWrapper portWrapper = new TestSerialPortWrapper("COM4", 9600, 0, 0, 8, 1, 2);
        // 設定MODBUS通訊的串行口
        serialParameters.setCommPortId("COM4");
        // 設置端口波特率
        serialParameters.setBaudRate(9600);
        //硬件之間輸入流應答控制 
        serialParameters.setFlowControlIn(0);
        //硬件之間輸出流應答控制 
        serialParameters.setFlowControlOut(0);
        //設定數據位的位數  RTU:8位    ASCII:7位
        serialParameters.setDataBits(8);
        //奇偶校驗位  無校驗：0 奇校驗：1 偶校驗：2
        serialParameters.setParity(2);
        //停止位的位數，如果無奇偶校驗為2，有奇偶校驗為1
        serialParameters.setStopBits(1);
        // 設置端口名稱
        serialParameters.setPortOwnerName("RTU");
        // 創建ModbusMaster工廠實例
        return new ModbusFactory().createRtuMaster(serialParameters);
    }
    
     
    
    /**
     * @Description: 創建TcpMaster
     * @return 
     */
    public static ModbusMaster getTcpMaster() {
        IpParameters ipParameters = new IpParameters();
        //設置IP
        ipParameters.setHost("localhost");
        //設置端口 默認為502
        ipParameters.setPort(502);
        // 創建ModbusMaster工廠實例   
        return new ModbusFactory().createTcpMaster(ipParameters, true);
    }
    
    
    /**
     * @Description: IO盒測試
     * @throws ModbusInitException
     * @throws ModbusTransportException
     * @throws ErrorResponseException 
     */
    @Test
    public void konnadTest() throws ModbusInitException, ModbusTransportException, ErrorResponseException{
        IpParameters params = new IpParameters();
        params.setHost("172.16.16.205");
        params.setPort(502);
        //獲取主站
        ModbusMaster master = new ModbusFactory().createTcpMaster(params, false);
        master.init();
        //讀取MAC地址
        ReadHoldingRegistersRequest request = new ReadHoldingRegistersRequest(1, 0, 3);
        ReadHoldingRegistersResponse response = (ReadHoldingRegistersResponse) master.send(request);
//        System.out.println("MAC地址" + ConversionUtil.getHexString(response.getData()));
        // ZC: 上面的 ConversionUtil貌似是 博主自己寫的類，就先注釋掉了
        
//        WriteRegisterRequest request1 = new WriteRegisterRequest(1, 1056, 0);
//        ModbusResponse response1 = master.send(request1);
//        if (response1.isException())
//            System.out.println("Exception response: message=" + response1.getExceptionMessage());
//        else
//            System.out.println("功能碼:3,寫入多個模擬量數據成功!");
        //寫數據 DO0的狀態  0x0400  I/O盒實際為DO1
//        WriteRegisterRequest request1 = new WriteRegisterRequest(1, 1024, 1);
//        master.send(request1);
        //寫數據 DO1上電的狀態  0x0411 
//        WriteRegistersRequest request2 = new WriteRegistersRequest(1, 1040, new short[] {1, 1} );
//        master.send(request2);
        //讀取 0x0411狀態  為上電后的狀態
//        ReadHoldingRegistersRequest request3 = new ReadHoldingRegistersRequest(1, 1040, 7);
//        ReadHoldingRegistersResponse response3 = (ReadHoldingRegistersResponse) master.send(request3);
//        System.out.println(Arrays.toString(response3.getShortData()));
        
    }
    
    /**
     * @Description: 創建modbus服務端  從站
     */
    @Test
    public void createSalve(){
        //創建modbus工廠
        ModbusFactory modbusFactory = new ModbusFactory();
        //創建TCP服務端
        final ModbusSlaveSet salve = modbusFactory.createTcpSlave(false);
        //創建ASCII服務端
//        final ModbusSlaveSet salve = getAsciiSalve();
        //向過程影像區添加數據
        salve.addProcessImage(getModscanProcessImage(1));
        
         new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        salve.start();
                    }
                    catch (ModbusInitException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
         
         while (true) {
                synchronized (salve) {
                    try {
                        salve.wait(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
 
                for (ProcessImage processImage : salve.getProcessImages())
                    try {
                        updateProcessImage((BasicProcessImage) processImage);
                    } catch (IllegalDataAddressException e) {
                        e.printStackTrace();
                    }
            }
    }
    
     /**
     * @Description: 創建寄存器
     * @param slaveId
     * @return 
     */
    public static BasicProcessImage getModscanProcessImage(int slaveId) {
         BasicProcessImage processImage = new BasicProcessImage(slaveId);
         processImage.setInvalidAddressValue(Short.MIN_VALUE);
         
         //創建可讀寫開關量區
         processImage.setCoil(0, true);
         processImage.setCoil(1, false);
         processImage.setCoil(2, true);
         processImage.setCoil(3, true);
         processImage.setCoil(5, true);
         processImage.setCoil(6, true);
         processImage.setCoil(7, true);
         processImage.setCoil(8, true);
         processImage.setCoil(9, true);
         
         //創建只讀開關量區
         processImage.setInput(0, false);
         processImage.setInput(1, false);
         processImage.setInput(2, true);
         processImage.setInput(3, false);
         processImage.setInput(4, true);
         processImage.setInput(5, true);
         processImage.setInput(6, true);
         processImage.setInput(7, true);
         processImage.setInput(8, true);
         processImage.setInput(9, true);
         
         //創建模擬量保持寄存器
         processImage.setHoldingRegister(0, (short) 1);
         processImage.setHoldingRegister(1, (short) 10);
         processImage.setHoldingRegister(2, (short) 100);
         processImage.setHoldingRegister(3, (short) 1000);
         processImage.setHoldingRegister(4, (short) 10000);
         processImage.setHoldingRegister(5, (short) 10000);
         processImage.setHoldingRegister(6, (short) 10000);
         processImage.setHoldingRegister(7, (short) 10000);
         processImage.setHoldingRegister(8, (short) 10000);
         processImage.setHoldingRegister(9, (short) 10000);
         
         //創建模擬量只讀寄存器
         processImage.setInputRegister(0, (short) 10000);
         processImage.setInputRegister(1, (short) 1000);
         processImage.setInputRegister(2, (short) 100);
         processImage.setInputRegister(3, (short) 10);
         processImage.setInputRegister(4, (short) 1);
         processImage.setInputRegister(5, (short) 1);
         processImage.setInputRegister(6, (short) 1);
         processImage.setInputRegister(7, (short) 1);
         processImage.setInputRegister(8, (short) 1);
         processImage.setInputRegister(9, (short) 1);
         
         processImage.addListener(new BasicProcessImageListener());
         
        return processImage;
     }
    
    /**
     * @Description: 客戶端修改本地寄存器的數據
     * @author-lsh
     * @date 2017年9月13日 下午5:47:30
     */
    public static class BasicProcessImageListener implements ProcessImageListener {
            @Override
            public void coilWrite(int offset, boolean oldValue, boolean newValue) {
                System.out.println("Coil at " + offset + " was set from " + oldValue + " to " + newValue);
            }
 
            @Override
            public void holdingRegisterWrite(int offset, short oldValue, short newValue) {
                // Add a small delay to the processing.
                //            try {
                //                Thread.sleep(500);
                //            }
                //            catch (InterruptedException e) {
                //                // no op
                //            }
                System.out.println("HR at " + offset + " was set from " + oldValue + " to " + newValue);
            }
        }
    
     /**
     * @Description: 更新寄存器的數據
     * @param processImage
     * @throws IllegalDataAddressException 
     */
    static void updateProcessImage(BasicProcessImage processImage) throws IllegalDataAddressException {
            processImage.setInput(0, !processImage.getInput(0));
            processImage.setInput(1, !processImage.getInput(1));
 
//            processImage.setNumeric(RegisterRange.INPUT_REGISTER, 20, DataType.FOUR_BYTE_FLOAT, ir1Value += 0.01);
    //
//            short hr1Value = processImage.getNumeric(RegisterRange.HOLDING_REGISTER, 80, DataType.TWO_BYTE_BCD)
//                    .shortValue();
//            processImage.setNumeric(RegisterRange.HOLDING_REGISTER, 80, DataType.TWO_BYTE_BCD, hr1Value + 1);
        }
    @Test
    public void StringTest(){
        String a = "abc123456789";
        char[] charArray = a.toCharArray();
        System.err.println(Arrays.toString(charArray));
    }
}

 

4、

5、