modbus4j,rtu,ascii,tcp/ip传输模式

最新推荐文章于 2024-08-06 08:30:00 发布
置顶 最新推荐文章于 2024-08-06 08:30:00 发布
阅读量7.3k 收藏 12
点赞数 5
分类专栏： Modbus 文章标签： modbus modbus4j java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013150916/article/details/78065479
版权 
//感兴趣的或者需要交流的可以加qq群,大家一起讨论。群号：192656750感兴趣的或者需要交流的可以加qq群,大家一起讨论。群号：192656750

资料下载地址：https://download.csdn.net/download/u013150916/9848441

package com.yunkouan.wincc.modbus;
import java.util.Arrays;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import org.junit.Test;
import com.serotonin.io.serial.SerialParameters;
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.base.ReadFunctionGroup;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.code.RegisterRange;
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.locator.StringLocator;
import com.serotonin.modbus4j.msg.ModbusResponse;
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.sun.org.apache.bcel.internal.generic.StackInstruction;
import com.yunkouan.wincc.util.ConversionUtil;

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> 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()));
        
//        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) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
	            }

	            for (ProcessImage processImage : salve.getProcessImages())
					try {
						updateProcessImage((BasicProcessImage) processImage);
					} catch (IllegalDataAddressException e) {
						// TODO Auto-generated catch block
						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));
	}
}

 

狂野的河
关注
专栏目录
SpringBoot整合modbus 4j（Tcp）
程序员进阶之路
08-16 1516
【代码】SpringBoot整合modbus 4j（Tcp）
通过modbus4j读写字符串到PLC
Mr_Demo_2的博客
07-18 1117
通过java实现读写字符串到PLC
Modbus-Ascii详解
最新发布
qq_3517289697的博客
08-06 751
‌Modbus ASCII协议主要应用于需要串行通信接口进行数据交互的领域，‌如工业自动化、‌楼宇自动化、‌电力系统、‌环境监测等。‌尽管其传输效率相对较低，‌但由于其良好的可读性和容错性，‌在要求数据可读性或通信链路稳定性较好的场合，‌Modbus ASCII仍然是一个不错的选择。‌具体来说，‌每个8位的字节被拆分为两个ASCII字符进行发送，‌例如，‌十六进制数0xAB会被分解成ASCII字符“A”和“B”进行发送。‌此外，‌为了避免与报文中的特殊字符冲突，‌需要对特定字符进行转义处理。
modbus总线协议（二）modbus ascii
锅锅的博客
05-26 7438
一、介绍 modbus ascii是modbus的一种消息帧，相比rtu，ascii的传输是按照字符传的，传输的数据量会比rtu更多，所以数据量大的时候一般使用的rtu，数据量小的时候才会用ascii，然后ascii协议帧里面添加了起始和结束，更换了校验算法，下面详细介绍ascii协议 二、modbus ascii协议详解 1、协议描述 起始位: 冒号“ : ”（0x3A） 结束符: 回车（0D）和换行（0A） 数据表示：将一个字节的十六进制拆分成了两个字节的字符表示 例如：0x12表示成 字符 “1“”
使用modbus4j通过串口解析modbus协议（java）
jiankuangnian1578的博客
09-02 4881
前言 项目中需要读取工厂产线中传感器上的数据（温度，粘度等）； 传感器连接通讯协议是RS485串口通信（以后打算转成网口） 数据协议类型是modbus ASCII 一、生产工具/资料 提示：下面的工具我都会在后面一起打包 一：jdk1.8.0_201 按：我之前的是1.8.0_281,但引用了相关jar后jvm运行时退出，乖乖的换为1.8.0_201，查资料发现261以上的都有类似情况； 二：Configure Virtual Serial P...
使用modbus4j实现java对通讯管理机得采集
foolish_birder的博客
10-21 1464
modbus
C# modbus Rtu/Ascii/Tcp 源码
10-25
3. **Modbus TCP**：这是Modbus的网络版本，使用TCP/IP协议栈进行数据交换，适用于以太网环境，提供更可靠的连接和更高的传输速率。 压缩包内的文件名称列表揭示了项目的组成结构： - `app.config`：这是C#应用程序...
MG-S1EX ModbusRTU/ASCII转ModbusTCP/IP.zip
10-12
MG-S1EX ModbusRTU/ASCII转ModbusTCP/IPzip,提供“MG-S1EX ModbusRTU/ASCII转ModbusTCP/IP协议转换器”免费资料下载，主要包括产品概述、功能特点、技术参数、硬件说明、产品使用、安装尺寸等内容，可供选型和安装...
Fenix Modbus / S7:西门子S7300 / 400/1200/1500，ModbusMaster / RTU / TCP / ASCII，WebServer-开源
04-29
Fenix，用于与Modbus网络中的设备进行通信的软件。 您可以轻松地从Modbus从站获取数据。 您可以将寄存器分组到标签中。 您将能够查看通讯记录的字节并为您的创建标签制作图表。 YouTube播放列表：...
modbus TCP/IP 调试工具 Modbus Poll 和java 开发工具jar包
07-20
Modbus有多种变体，包括RTU（远程终端单元）和ASCII模式，以及基于TCP/IP的版本。 2. **Modbus TCP/IP**: 这是Modbus协议的一个扩展，将Modbus的数据交换功能与TCP/IP协议栈相结合，使设备可以通过网络进行通信。...
Modbus TCP/RTU 服务端、客户端源码、协议规范文档、测试工具
05-29
这个压缩包包含的内容是学习和开发Modbus TCP/RTU通信的关键资源。 首先，我们来看看"Modbus协议规范-中文版.pdf"。这份文档是Modbus协议的中文版本，详细解释了Modbus的工作原理和通信规则。它涵盖了Modbus的功能...
modbus tcp通讯modbus4j使用说明
bobozai86的博客
04-10 4205
ava编程中,使用modbus4j实现Java中的modbus协议通讯 modbus4j实现了Java与modbus协议的以下几种通讯方式: modbus TCP/IP通讯 modubs UDP/IP通讯 modbus RTU/IP通讯 Java读取工具类 package com.leftso.project.demo.modbus4j; import com.serotonin.modbus4j.BatchRead; import com.serotonin.modbus4j.BatchR
Java 整合 Modbus TCP
SSL 的博客
03-05 5428
使用Java整合Modbus TCP，实现代码控制Modbus设备模拟器。
Modbus TCP读取寄存器数据
热门推荐
qq_32168087的博客
10-10 1万+
modbus4j读取寄存器数据 ModbusReadUtil读取工具类 package cn.sync.modbus; import org.apache.log4j.Logger; import com.serotonin.modbus4j.BatchRead; import com.serotonin.modbus4j.BatchResults; import com.serotonin....
com.serotonin.modbus4j.sero.messaging.TimeoutException MODBUS RUT java
weixin_42164744的博客
06-13 5532
MODBUS RUT java 解决方案①： 设置超时时间 解决方案②： 查看串口是否连上 以下这个成功情况： 这个COM2、COM3 是成功连上了
java中modbus协议连接
weixin_33769125的博客
07-16 1802
2019独角兽企业重金招聘Python工程师标准>>> ...
modbus tcp通讯
oThrowsException的博客
01-02 820
【代码】modbus tcp通讯。
modbus tcp转发
xulibo5828的博客
04-21 359
机是低代码，只能发送modbus报文，现需要收到15码之后转发至下位，并延时后关掉下位。
modbus通信高位字节，低位字节转float32
qq_38242953的博客
11-18 2835
import struct # 获得modbus前端数据, 高位value1, 低位value2 value1 = 16711 value2 = 13107 # 将高位拆分成两个字节v1, v2 将低位拆分成俩个字节v3, v4 v1, v2 = value1.to_bytes(length=2, byteorder='big', signed=False) v3, v4 = value2.to_bytes(length=2, byteorder='big', signed=False) prin.
Modbus ASCII、Modbus RTU和Modbus TCP/IP 这三种能讲讲吗
05-26
当我们需要在不同设备之间传输数据时，Modbus是一种常用的通信协议。Modbus协议是一种串行通信协议，它可以用于连接不同制造商的设备。 Modbus协议有三种通信方式：ASCII、RTU和TCP/IP。 1. Modbus ASCII Modbus ASCII使用ASCII码作为数据传输格式，并且每个字节之间都有一个停止位和一个起始位。Modbus ASCII的缺点是速度慢，因为它需要进行字符编码和解码。它的优点是可读性强，方便调试和排错。 2. Modbus RTU Modbus RTU使用二进制码作为数据传输格式，数据帧包括起始位、数据位、奇偶校验位和停止位。相较于Modbus ASCII，Modbus RTU的传输速度更快，但是可读性差，难以调试。 3. Modbus TCP/IP Modbus TCP/IP是基于TCP/IP协议的Modbus协议，它使用以太网作为物理层，使用TCP协议进行传输。Modbus TCP/IP是目前最常用的Modbus协议，它的优点是速度快、可靠性高、安全性好，但是需要网络连接。 总之，Modbus ASCII、Modbus RTU和Modbus TCP/IP各有优缺点，在选择使用哪种通信方式时需要根据具体的应用场景进行考虑。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值