package com.modbus.data;

import com.base.ComBase;
import com.serotonin.modbus4j.BatchRead;
import com.serotonin.modbus4j.BatchResults;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.code.DataType;
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;
	}
 
	public static BatchResults<Integer> readMutilRegisters(BatchRead<Integer> batch,MyModbusMaster master){
		batch.setContiguousRequests(false);
		boolean isSuccess = true;
		try {
			return master.getMaster().send(batch);
		} catch (ModbusTransportException | ErrorResponseException e) {
			//e.printStackTrace();
			isSuccess = false;
		} finally {
			if(isSuccess) {
				master.clearError();
			}else {
				master.addErrorCount();
			}
		}
		return null;
	}
	
	
	/**
	 * ÅúÁ¿¶ÁȡʹÓ÷½·¨
	 * 
	 * @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));
	}
	
	/**
	 * 	¹¹ÔìÏßȦ¶ÁÈ¡½Úµã
	 * @param offset
	 * @param master
	 * @return
	 */
	public static BaseLocator<?> createBaseLocator(int offset,MyModbusMaster master) {
		return BaseLocator.coilStatus(master.getSlaveId(), offset);
	}
	
	/**
	 * 	¹¹Ôì¶ÁÈ¡½Úµã
	 * @param offset
	 * @param master
	 * @return
	 */
	public static BaseLocator<?> createBaseLocator(int offset,int datatype,MyModbusMaster master) {
		return BaseLocator.holdingRegister(master.getSlaveId(), offset, datatype);
	}
	
	/**
	 * д [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();
			}
		}
	}
	
	public static void main(String[] args) {
		BatchRead<Integer> batch = new BatchRead<Integer>();
 
		batch.addLocator(0, BaseLocator.holdingRegister(1, 1, DataType.TWO_BYTE_INT_SIGNED));
        batch.addLocator(1, BaseLocator.coilStatus(1, 1));
        batch.setContiguousRequests(true);
 
		MyModbusMaster m = new MyModbusMaster("192.168.10.221", 2);
		
		ModbusMaster master = m.getMaster();
 
		BatchResults<Integer> results = new BatchResults<>();
		try {
			results = master.send(batch);
		} catch (ModbusTransportException | ErrorResponseException e) {
			e.printStackTrace();
		}
		System.out.println(results.getValue(0));
		//System.out.println(results.getValue(1));
	}
	
	/**
	 * 	¶ÁÈ¡floatÀàÐÍÊý¾Ý
	 * @param obj	ShortÀàÐÍ
	 * @return
	 */
	public static float readShortToFloat(Object obj) {
		return (float)ComBase.changeShortToInt((Short)obj);
	}
	/**
	 * 
	 * @param obj
	 * @param signed	true:ÓзûºÅÊý     false:ÎÞ·ûºÅ
	 * @return
	 */
	public static float readShortToFloat(Object obj,boolean signed) {
		return (float)ComBase.changeShortToInt((Short)obj,signed);
	}
	/**
	 * 	¶ÁÈ¡intÀàÐÍÊý¾Ý
	 * @param obj	ShortÀàÐÍ
	 * @return
	 */
	public static int readShortToInt(Object obj) {
		return ComBase.changeShortToInt((Short)obj);
	}
	
	public static int readIntergerToInt(Object obj) {
		return (int)obj;
	}
	/**
	 * 	¶ÁÈ¡BooleanÀàÐÍÊý¾Ý
	 * @param obj	BooleanÀàÐÍ
	 * @return
	 */
	public static int readBooleanToInt(Object obj) {
		return ((Boolean)obj?1:0);
	}
}