欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

springBoot 整合ModBus TCP的詳細過程

 更新時間:2025年01月26日 10:26:03   作者:雁歸來時  
ModBus是一種串行通信協議,用于從儀器和控制設備傳輸信號到主控制器或數據采集系統(tǒng),它分為主站和從站,主站獲取和編寫數據,從站則是設備,本文給大家介紹springBoot 整合ModBus TCP的詳細過程,感興趣的朋友一起看看吧

ModBus是什么:

ModBus是一種串行通信協議,主要用于從儀器和控制設備傳輸信號到主控制器或數據采集系統(tǒng),例如用于測量溫度和濕度并將結果傳輸到計算機的系統(tǒng)。(百度答案)

ModBus 有些什么東西:

ModBus其分為兩個站點,一個是主站一個是從站

主站和從站之間可以進行相互通訊,這里的主從站和JAVA程序中的主從關系應該是不一致的,博主在尋找資料的時候發(fā)現,所謂的從站就是用的仿真機進行模擬的,就是實打實的硬件設備,而主站才是中樞,是獲取設備從站推送的數據和對設備數據進行編寫的地方。
在實際業(yè)務開發(fā)過程中,對于從站的約束,需要和設備供應商進行對接,而邏輯處理業(yè)務集中在主站中。

Modbus Slave(打手)

Modbus Slave就是上面提到的仿真機,它可以在進行業(yè)務開發(fā)的過程中,充當設備的角色,方便主站獲取和編寫數據。
Modbus Slave下載地址
安裝完成之后在Connection–>connect 里面輸入激活碼即可

Modbus Slave使用(刷副本)

上面說過,它就是一個仿真機,我們進行使用的時候需要先了解一下它有那些東西,我們需要對它進行那些操作
它有四個功能類型

然后設置完成這些之后,可以對其屬性值進行編輯處理,根據不同的數據類型,可以設置多種數據值

更加具體的操作可以另行查找資料

獲取Slave數據

數據已經存在了, 那么如何進行獲取數據,這邊以ModbusTcp的方式進去編寫一個寫入和讀取的案例

導入POM依賴
pom依賴國內是無法進行下載的,所以我們需要指定國外鏡像或者下載ZIP進行打包編譯成我們需要的依賴文件,博主使用的是通過ZIP文件進行打包編譯導入的。(博主資源中有ZIP包,需要的可以自行獲取)
解壓ZIP文件之后,通過IDEA進行打包編譯即可,有需要的可以通過 maven deploy方法進行推送到maven倉庫中

pom文件中添加依賴即可

        <dependency>
            <groupId>com.infiniteautomation</groupId>
            <artifactId>modbus4j</artifactId>
            <version>3.1.1-SNAPSHOT</version>
        </dependency>

讀取數據

package com.example.modbusserve.Test;
import com.serotonin.modbus4j.BatchRead;
import com.serotonin.modbus4j.BatchResults;
import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.ip.IpParameters;
import com.serotonin.modbus4j.locator.BaseLocator;
/**
 * modbus通訊工具類,采用modbus4j實現(讀?。?
 *
 */
public class Modbus4jUtils {
    /**
     * 工廠。
     */
    static ModbusFactory modbusFactory;
    static {
        if (modbusFactory == null) {
            modbusFactory = new ModbusFactory();
        }
    }
    /**
     * 獲取master
     *
     */
    public static ModbusMaster getMaster() throws ModbusInitException {
        IpParameters params = new IpParameters();
        params.setHost("192.168.1.7");
        params.setPort(502);
        // 采用 Modbus RTU over TCP/IP,第二個參數為 true,即 modbusFactory.createTcpMaster(params, true),這里用的是TCP協議
        ModbusMaster master = modbusFactory.createTcpMaster(params, false);// TCP 協議
        master.init();
        return master;
    }
    /**
     * 讀取[01 Coil Status 0x]類型 開關數據
     *
     * @param slaveId
     *            slaveId
     * @param offset
     *            位置
     * @return 讀取值
     */
    public static Boolean readCoilStatus(int slaveId, int offset)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 01 Coil Status
        BaseLocator<Boolean> loc = BaseLocator.coilStatus(slaveId, offset);
        Boolean value = getMaster().getValue(loc);
        return value;
    }
    /**
     * 讀取[02 Input Status 1x]類型 開關數據
     *
     * @param slaveId
     * @param offset
     * @return
     */
    public static Boolean readInputStatus(int slaveId, int offset)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 02 Input Status
        BaseLocator<Boolean> loc = BaseLocator.inputStatus(slaveId, offset);
        Boolean value = getMaster().getValue(loc);
        return value;
    }
    /**
     * 讀取[03 Holding Register類型 2x]模擬量數據
     *
     * @param slaveId
     *            slave Id
     * @param offset
     *            位置
     * @param dataType
     *            數據類型,來自com.serotonin.modbus4j.code.DataType
     */
    public static Number readHoldingRegister(int slaveId, int offset, int dataType)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 03 Holding Register類型數據讀取
        BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);
        Number value = getMaster().getValue(loc);
        return value;
    }
    /**
     * 讀取[04 Input Registers 3x]類型 模擬量數據
     *
     * @param slaveId
     *            slaveId
     * @param offset
     *            位置
     * @param dataType
     *            數據類型,來自com.serotonin.modbus4j.code.DataType
     * @return 返回結果
     */
    public static Number readInputRegisters(int slaveId, int offset, int dataType)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 04 Input Registers類型數據讀取
        BaseLocator<Number> loc = BaseLocator.inputRegister(slaveId, offset, dataType);
        Number value = getMaster().getValue(loc);
        return value;
    }
    /**
     * 批量讀取使用方法
     *
     * @throws ModbusTransportException
     * @throws ErrorResponseException
     * @throws ModbusInitException
     */
    public static void batchRead() throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        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));
    }
    /**
     * 測試
     *
     * @param args
     */
    public static void main(String[] args) {
        try {
            // 01測試
            Boolean v011 = readCoilStatus(1, 0);
            Boolean v012 = readCoilStatus(1, 1);
            System.out.println("v011:" + v011);
            System.out.println("v012:" + v012);
//            // 02測試
//            Boolean v021 = readInputStatus(1, 0);
//            Boolean v022 = readInputStatus(1, 1);
//            Boolean v023 = readInputStatus(1, 2);
//            System.out.println("v021:" + v021);
//            System.out.println("v022:" + v022);
//            System.out.println("v023:" + v023);
//
//            // 03測試
//            Number v031 = readHoldingRegister(1, 1, DataType.FOUR_BYTE_FLOAT);// 注意,float
//            Number v032 = readHoldingRegister(1, 3, DataType.FOUR_BYTE_FLOAT);// 同上
//            System.out.println("v031:" + v031);
//            System.out.println("v032:" + v032);
//
//            // 04測試
//            Number v041 = readInputRegisters(1, 0, DataType.FOUR_BYTE_FLOAT);//
//            Number v042 = readInputRegisters(1, 2, DataType.FOUR_BYTE_FLOAT);//
//            System.out.println("v041:" + v041);
//            System.out.println("v042:" + v042);
//            // 批量讀取
//            batchRead();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

其中slaveId和offset對應的就是仿真機中的從站編碼和地址碼

通過不同的讀取方法,可以讀取不同業(yè)務類型中的數據。返回值仿真機中只能存數字(只是有誤符號的區(qū)別),所以固定是Number

寫入數據

package com.example.modbusserve.Test;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.ip.IpParameters;
import com.serotonin.modbus4j.locator.BaseLocator;
import com.serotonin.modbus4j.msg.ModbusResponse;
import com.serotonin.modbus4j.msg.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;
/**
 * modbus4j寫入數據
 *
 * @author xq
 *
 */
public class Modbus4jWriteUtils {
    static Log log = LogFactory.getLog(Modbus4jWriteUtils.class);
    /**
     * 工廠。
     */
    static ModbusFactory modbusFactory;
    static {
        if (modbusFactory == null) {
            modbusFactory = new ModbusFactory();
        }
    }
    /**
     * 獲取tcpMaster
     *
     * @return
     * @throws ModbusInitException
     */
    public static ModbusMaster getMaster() throws ModbusInitException {
        IpParameters params = new IpParameters();
        params.setHost("localhost");
        params.setPort(502);
        ModbusMaster tcpMaster = modbusFactory.createTcpMaster(params, false);
        tcpMaster.init();
        return tcpMaster;
    }
    /**
     * 寫 [01 Coil Status(0x)]寫一個 function ID = 5
     *
     * @param slaveId
     *            slave的ID
     * @param writeOffset
     *            位置
     * @param writeValue
     *            值
     * @return 是否寫入成功
     * @throws ModbusTransportException
     * @throws ModbusInitException
     */
    public static boolean writeCoil(int slaveId, int writeOffset, boolean writeValue)
            throws ModbusTransportException, ModbusInitException {
        // 獲取master
        ModbusMaster tcpMaster = getMaster();
        // 創(chuàng)建請求
        WriteCoilRequest request = new WriteCoilRequest(slaveId, writeOffset, writeValue);
        // 發(fā)送請求并獲取響應對象
        WriteCoilResponse response = (WriteCoilResponse) tcpMaster.send(request);
        if (response.isException()) {
            return false;
        } else {
            return true;
        }
    }
    /**
     * 寫[01 Coil Status(0x)] 寫多個 function ID = 15
     *
     * @param slaveId
     *            slaveId
     * @param startOffset
     *            開始位置
     * @param bdata
     *            寫入的數據
     * @return 是否寫入成功
     * @throws ModbusTransportException
     * @throws ModbusInitException
     */
    public static boolean writeCoils(int slaveId, int startOffset, boolean[] bdata)
            throws ModbusTransportException, ModbusInitException {
        // 獲取master
        ModbusMaster tcpMaster = getMaster();
        // 創(chuàng)建請求
        WriteCoilsRequest request = new WriteCoilsRequest(slaveId, startOffset, bdata);
        // 發(fā)送請求并獲取響應對象
        WriteCoilsResponse response = (WriteCoilsResponse) tcpMaster.send(request);
        if (response.isException()) {
            return false;
        } else {
            return true;
        }
    }
    /***
     * 保存寄存器
     * 寫[03 Holding Register(4x)] 寫一個 function ID = 6
     * @param slaveId
     * @param writeOffset
     * @param writeValue
     */
    public static boolean writeRegister(int slaveId, int writeOffset, short writeValue)
            throws ModbusTransportException, ModbusInitException {
        // 獲取master
        ModbusMaster tcpMaster = getMaster();
        // 創(chuàng)建請求對象
        WriteRegisterRequest request = new WriteRegisterRequest(slaveId, writeOffset, writeValue);
        WriteRegisterResponse response = (WriteRegisterResponse) tcpMaster.send(request);
        if (response.isException()) {
            log.error(response.getExceptionMessage());
            return false;
        } else {
            return true;
        }
    }
    /**
     *
     * 寫入[03 Holding Register(4x)]寫多個 function ID=16
     *
     * @param slaveId
     *            modbus的slaveID
     * @param startOffset
     *            起始位置偏移量值
     * @param sdata
     *            寫入的數據
     * @return 返回是否寫入成功
     * @throws ModbusTransportException
     * @throws ModbusInitException
     */
    public static boolean writeRegisters(int slaveId, int startOffset, short[] sdata)
            throws ModbusTransportException, ModbusInitException {
        // 獲取master
        ModbusMaster tcpMaster = getMaster();
        // 創(chuàng)建請求對象
        WriteRegistersRequest request = new WriteRegistersRequest(slaveId, startOffset, sdata);
        // 發(fā)送請求并獲取響應對象
        ModbusResponse response = tcpMaster.send(request);
        if (response.isException()) {
            log.error(response.getExceptionMessage());
            return false;
        } else {
            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
     * @throws ModbusTransportException
     * @throws ErrorResponseException
     * @throws ModbusInitException
     */
    public static void writeHoldingRegister(int slaveId, int offset, Number value, int dataType)
            throws ModbusTransportException, ErrorResponseException, ModbusInitException {
        // 獲取master
        ModbusMaster tcpMaster = getMaster();
        // 類型
        BaseLocator<Number> locator = BaseLocator.holdingRegister(slaveId, offset, dataType);
        tcpMaster.setValue(locator, value);
    }
    public static void main(String[] args) {
        try {
            //@formatter:off
            // 測試01
			boolean t01 = writeCoil(1, 4, true);
			System.out.println("T01:" + t01);
            // 測試02
//			boolean t02 = writeCoils(1, 0, new boolean[] { true, false, true });
//			System.out.println("T02:" + t02);
            // 測試03
//			short v = -3;
//			boolean t03 = writeRegister(1, 0, v);
//			System.out.println("T03:" + t03);
            // 測試04
//			boolean t04 = writeRegisters(1, 0, new short[] { -3, 3, 9 });
//			System.out.println("t04:" + t04);
            //寫模擬量
//            writeHoldingRegister(1,0, 10.1f, DataType.FOUR_BYTE_FLOAT);
            //@formatter:on
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代碼中獨有相對于的注釋,可以自行參考使用

到此這篇關于springBoot 整合ModBus TCP的文章就介紹到這了,更多相關springBoot 整合ModBus TCP內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家!

相關文章

  • springboot 啟動如何修改application.properties的參數

    springboot 啟動如何修改application.properties的參數

    這篇文章主要介紹了springboot 啟動如何修改application.properties的參數方法,具有很好的參考價值,希望對大家有所幫助。如有錯誤或未考慮完全的地方,望不吝賜教
    2021-08-08
  • java開發(fā)時各類工具的使用規(guī)范

    java開發(fā)時各類工具的使用規(guī)范

    這篇文章主要介紹了java編碼時各類工具的使用規(guī)范,多人協作、共同開發(fā)一個項目,如果沒有統(tǒng)一的代碼規(guī)范的話,項目中的每個人都按照自己的習慣率性而為,就會導致整個項目的代碼看上去雜亂無章,可讀性非常差,并且持續(xù)增加后續(xù)的維護成本。對此感興趣可以來了解一下
    2020-07-07
  • Java并發(fā)編程service層處理并發(fā)事務加鎖可能會無效問題

    Java并發(fā)編程service層處理并發(fā)事務加鎖可能會無效問題

    這篇文章主要介紹了Java并發(fā)編程service層處理并發(fā)事務加鎖可能會無效問題,具有很好的參考價值,希望對大家有所幫助。如有錯誤或未考慮完全的地方,望不吝賜教
    2023-07-07
  • Spring 實現自定義監(jiān)聽器案例

    Spring 實現自定義監(jiān)聽器案例

    這篇文章主要介紹了Spring 實現自定義監(jiān)聽器案例,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2021-01-01
  • Java8函數式接口的基礎學習教程

    Java8函數式接口的基礎學習教程

    這篇文章主要給大家介紹了關于Java8函數式接口基礎學習的相關資料,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2021-04-04
  • Java中getSuperclass()方法的使用與原理解讀

    Java中getSuperclass()方法的使用與原理解讀

    文章介紹了Java中的getSuperclass()方法,該方法用于獲取一個類的直接父類,通過理解其使用方式、工作原理以及實際應用場景,可以更好地利用反射機制處理類的繼承關系,實現動態(tài)類型檢查、類加載以及序列化等功能
    2025-01-01
  • Java中equals方法使用及重寫練習

    Java中equals方法使用及重寫練習

    equals是在object類中的方法,在object中equals是用來看看兩個參數是否引用的是同一個對象,下面這篇文章主要給大家介紹了關于Java中equals方法使用及重寫練習的相關資料,需要的朋友可以參考下
    2023-05-05
  • Spring如何通過注解存儲和讀取對象詳解

    Spring如何通過注解存儲和讀取對象詳解

    在Spring中,要想更簡單的存儲和讀取對象的核心是使用注解,這篇文章主要給大家介紹了關于Spring如何通過注解存儲和讀取對象的相關資料,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下
    2022-07-07
  • springboot 如何重定向redirect 并隱藏參數

    springboot 如何重定向redirect 并隱藏參數

    這篇文章主要介紹了springboot 如何重定向redirect 并隱藏參數的操作,具有很好的參考價值,希望對大家有所幫助。如有錯誤或未考慮完全的地方,望不吝賜教
    2021-09-09
  • Nacos與SpringBoot實現配置管理的開發(fā)實踐

    Nacos與SpringBoot實現配置管理的開發(fā)實踐

    在微服務架構中,配置管理是一個核心組件,而Nacos為此提供了一個強大的解決方案,本文主要介紹了Nacos與SpringBoot實現配置管理的開發(fā)實踐,具有一定的參考價值
    2023-08-08

最新評論