using CCDCount.DLL.AlarmTools;
using CCDCount.DLL.Tools;
using CCDCount.MODEL.PlcModel;
using System;
using System.Linq;
using System.Security.Cryptography;

namespace CCDCount.DLL
{
    public class PLCManagementClass
    {
        private bool isConnect = false;
        public bool IsConnect
        {
            get
            {
                return isConnect;
            }
        }


        public ModbusTcpClient modbusTcpClient = new ModbusTcpClient();
        public PLCManagementClass(string ipAddress)
        {
            //ConnectModbus("127.0.0.1");
            ConnectModbus(ipAddress);
            //ConnectModbus("192.168.1.88");
        }

        public void ConnectModbus(string ipAddress)
        {
            if (!modbusTcpClient.Connect(ipAddress))
            {
                //FaultLog.RecordErrorMessage($"Modbus通讯连接失败,目标IP:{ipAddress}");
                SystemAlarm.AlarmAlert(AlarmMessageList.PLC通讯连接失败, $"Modbus通讯连接失败,目标IP:{ipAddress}", "DLL:PLCManagementClass-ConnectModbus");
                isConnect = false;
                return;
            }
            isConnect = true;
            SystemAlarm.AlarmCancel(AlarmMessageList.PLC通讯连接失败);
        }
        /// <summary>
        /// 归零置为True
        /// </summary>
        public bool ReturnToZeroToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 0, values: true);
        }

        /// <summary>
        /// 归零置为False
        /// </summary>
        public bool ReturnToZeroToFalse()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 0, values: false);
        }

        /// <summary>
        /// 复位置为True
        /// </summary>
        public bool RepositionToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 1, values: true);
        }

        /// <summary>
        /// 复位置为False
        /// </summary>
        public bool RepositionToFalse()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 1, values: false);
        }

        /// <summary>
        /// 轴停止置为True
        /// </summary>
        public bool ShaftStopsToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 2, values: true);
        }

        /// <summary>
        /// 轴停止置为False
        /// </summary>
        public bool ShaftStopsToFalse()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 2, values: false);
        }

        /// <summary>
        /// 正转点动置为True
        /// </summary>
        public bool ForwardRotatingJogToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 3, values: true);
        }

        /// <summary>
        /// 正转点动置为False
        /// </summary>
        public bool ForwardRotatingJogToFalse()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 3, values: false);
        }

        /// <summary>
        /// 反转点动置为True
        /// </summary>
        public bool ReversalReverseJogToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 4, values: true);
        }

        /// <summary>
        /// 反转点动置为False
        /// </summary>
        public bool ReversalReverseJogToFalse()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 4, values: false);
        }

        /// <summary>
        /// 速度运行设置为True
        /// </summary>
        public bool SpeedRunToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 5, values: true);
        }

        /// <summary>
        /// 速度运行设置为False
        /// </summary>
        public bool SpeedRunToFalse()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 5, values: false);
        }

        /// <summary>
        /// 启动设置为True
        /// </summary>
        public bool InitiateToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 6, values: true);
        }

        /// <summary>
        /// 启动设置为False
        /// </summary>
        public bool InitiateToFalse()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 6, values: false);
        }

        /// <summary>
        /// 停止设置为True
        /// </summary>
        public bool StopToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 7, values: true);
        }

        /// <summary>
        /// 停止设置为False
        /// </summary>
        public bool StopToFalse()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 7, values: false);
        }

        /// <summary>
        /// 设备运行设置为True
        /// </summary>
        public bool EquipmentOperationToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 8, values: true);
        }

        /// <summary>
        /// 设备运行设置为False
        /// </summary>
        public bool EquipmentOperationToFalse()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 8, values: false);
        }

        /// <summary>
        /// 写入完成设置为True
        /// </summary>
        public bool WriteDoneToTrue()
        {
            return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 11, values: true);
        }

        /// <summary>
        /// 切换一级震台启动状态
        /// </summary>
        public void SwitchLevelOneVibrationTable()
        {
            if(ReadLevelOneVibrationTable(out bool Value))
            {
                modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 25, values: !Value);
            }
        }

        /// <summary>
        /// 二级震台启动
        /// </summary>
        public void SwitchLevelTwoVibrationTable()
        {
            if(ReadLevelTwoVibrationTable(out bool Value))
            {
                modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 26, values: !Value);
            }
        }


        /// <summary>
        /// 三级震台启动
        /// </summary>
        public void SwitchLevelThreeVibrationTable()
        {
            if(ReadLevelThreeVibrationTable(out bool Value))
            {
                modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 27, values: !Value);
            }
        }


        /// <summary>
        /// 设备上升
        /// </summary>
        public void WriteDeviceUpToTrue()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 28, values: true);
        }

        public void WriteDeviceUpToFalse()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 28, values: false);
        }


        /// <summary>
        /// 设备下降
        /// </summary>
        public void WriteDeviceDownToTrue()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 29, values: true);
        }

        public void WriteDeviceDownToFalse()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 29, values: false);
        }

        /// <summary>
        /// 传送带启动
        /// </summary>
        public void SwitchTransferStart()
        {
            if(ReadTransferStart(out bool Value))
            {
                modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 30, values: !Value);
            }
        }

        /// <summary>
        /// 气锁关
        /// </summary>
        public void SwitchAirValveClose()
        {
            if(ReadAirValveClose(out bool Value))
            {
                modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 31, values: !Value);
            }
        }

        /// <summary>
        /// 送瓶轮复位
        /// </summary>
        public void WriteBottleFeedingWheelResetToTrue()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 32, values: true);
        }

        public void WriteBottleFeedingWheelResetToFalse()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 32, values: false);
        }

        /// <summary>
        /// 送瓶轮回零
        /// </summary>
        public void WriteBottleFeedingWheelReturnToZeroToTrue()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 33, values: true);
        }
        public void WriteBottleFeedingWheelReturnToZeroToFalse()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 33, values: false);
        }

        /// <summary>
        /// 送瓶轮轴停止
        /// </summary>
        public void WriteBottleFeedingWheelShaftStopsToTrue()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 34, values: true);
        }

        public void WriteBottleFeedingWheelShaftStopsToFalse()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 34, values: false);
        }

        /// <summary>
        /// 送瓶轮正转点动
        /// </summary>
        public void WriteBottleFeedingWheelPositiveRotationJogToTrue()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 36, values: true);
        }
        public void WriteBottleFeedingWheelPositiveRotationJogToFalse()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 36, values: false);
        }

        /// <summary>
        /// 送瓶轮反转点动
        /// </summary>
        public void WriteBottleFeedingWheelReverseRotationJogToTrue()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 37, values: true);
        }
        public void WriteBottleFeedingWheelReverseRotationJogToFalse()
        {
            modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 37, values: false);
        }

        /// <summary>
        /// 送瓶轮使能
        /// </summary>
        public void SwitchBottleFeedingWheelEnable()
        {
            if(ReadBottleFeedingWheelEnable(out bool Value))
            {
                modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 38, values: !Value);
            }
        }

        /// <summary>
        /// 读取写入完成
        /// </summary>
        /// <returns></returns>
        public bool ReadAllowWrite(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 12, numRegisters: 1,out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取使能完成
        /// </summary>
        /// <returns></returns>
        public bool ReadEnableCompletion(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 14, numRegisters: 1,out bool[] ReturnValue);
            Value = ReturnValue[0];
            return  result;
        }

        /// <summary>
        /// 读取归零完成
        /// </summary>
        /// <returns></returns>
        public bool ReadReturnToZeroCompletion(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 15, numRegisters: 1,out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取停止完成
        /// </summary>
        /// <returns></returns>
        public bool ReadStopCompletion(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 16, numRegisters: 1, out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }


        /// <summary>
        /// 读取速度运行中
        /// </summary>
        public bool ReadSpeedRunning(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 17, numRegisters: 1,out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

         /// <summary>
         /// 读取归零中
         /// </summary>
         /// <returns></returns>
        public bool ReadReturnToZero(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 18, numRegisters: 1,out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取中转阀开定位完成
        /// </summary>
        /// <returns></returns>
        public bool ReadTransferValveOpenCompletion(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 19, numRegisters: 1,out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取中转阀关定位完成
        /// </summary>
        public bool ReadTransferValveCloseCompletion(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 20, numRegisters: 1,out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取允许数据交换
        /// </summary>
        public bool ReadAllowsDataExchange(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 21, numRegisters: 1,out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取暂停数据交换
        /// </summary>
        public bool ReadPauseDataExchange(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 22, numRegisters: 1,out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 缓存计数延时完成
        /// </summary>
        /// <returns></returns>
        public bool ReadCacheCountDelayed(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 23, numRegisters: 1, out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取使能
        /// </summary>
        /// <returns></returns>
        public bool ReadEnable(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 24, numRegisters: 1, out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取一级震台启动
        /// </summary>
        public bool ReadLevelOneVibrationTable(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 25, numRegisters: 1, out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取二级震台启动
        /// </summary>
        public bool ReadLevelTwoVibrationTable(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 26, numRegisters: 1, out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取三级震台启动
        /// </summary>
        public bool ReadLevelThreeVibrationTable(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 27, numRegisters: 1, out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取传送带启动
        /// </summary>
        public bool ReadTransferStart(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 30, numRegisters: 1, out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取气锁关
        /// </summary>
        public bool ReadAirValveClose(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 31, numRegisters: 1, out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取送瓶轮使能
        /// </summary>
        public bool ReadBottleFeedingWheelEnable(out bool Value)
        {
            bool result = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 38, numRegisters: 1, out bool[] ReturnValue);
            Value = ReturnValue[0];
            return result;
        }

        /// <summary>
        /// 读取所有状态
        /// </summary>
        public PlcStaticModelClass ReadAllState()
        {
            PlcStaticModelClass result = null;
            bool[] ReadResultValue = null;
            bool ReadResult = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 14, numRegisters: 11,out ReadResultValue);
            if (ReadResultValue == null|| ReadResult == false) return null;
            result = new PlcStaticModelClass()
            {
                EnableCompletion = ReadResultValue[0],
                ReturnToZeroCompletion = ReadResultValue[1],
                StopCompletion = ReadResultValue[2],
                SpeedRunning = ReadResultValue[3],
                ReturnToZero = ReadResultValue[4],
                TransferValveOpenCompletion = ReadResultValue[5],
                TransferValveCloseCompletion = ReadResultValue[6],
                AllowsDataExchange = ReadResultValue[7],
                PauseDataExchange = ReadResultValue[8],
                CacheCountDelayed = ReadResultValue[9],
                Enable = ReadResultValue[10]
            };
            ReadResult = modbusTcpClient.ReadCoilsRegister(slaveId: 1, startAddress: 35, numRegisters: 5,out ReadResultValue);
            if (ReadResultValue == null || ReadResult == false) return null;
            result.BottleFeedingWheelEnableCompletion = ReadResultValue[0];
            result.BottleFeedingWheelStopCompletion = ReadResultValue[4];
            return result;
        }

        /// <summary>
        /// 写入速度模式运行速度
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteSpeedModeRunningSpeed(float Value)
        {
            return modbusTcpClient.WriteMultipleReals(1, 1110, new float[] { Value }, "BADC");
        }

        /// <summary>
        /// 写入点动速度
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteJogSpeed(float Value)
        {
            return modbusTcpClient.WriteMultipleReals(1, 1114, new float[] { Value }, "BADC");
        }

        /// <summary>
        /// 写入罐装设定值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottValueSet(UInt16 Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1118, Value);
        }

        /// <summary>
        /// 写入中转阀打开速度
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteTransferValveOpeningSpeed(float Value)
        {
            return modbusTcpClient.WriteMultipleReals(1, 1122, new float[] { Value }, "BADC");
        }

        /// <summary>
        /// 写入中转阀打开时间
        /// </summary>
        public bool WriteTransferValveOpeningTime(UInt32 Value)
        {
            return modbusTcpClient.WriteSingleInt32(1, 1126, Value);
        }

        /// <summary>
        /// 写入罐装减速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottingDecelerationValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1130, Value);
        }

        /// <summary>
        /// 写入缓存减速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteCacheDecelerationValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1134, Value);
        }

        /// <summary>
        /// 写入缓存计时延时时间
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteCacheCountDelayTiming(UInt32 Value)
        {
            return modbusTcpClient.WriteSingleInt32(1, 1138, Value);
        }

        /// <summary>
        /// 写入缓存停机值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteCacheShutdownValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1142, Value);
        }

        /// <summary>
        /// 写入罐装料筒震台高速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottingMaterialCylinderVibrationTableHighSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1146, Value);
        }

        /// <summary>
        /// 写入罐装过滤震台高速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottingFilterVibrationTableHighSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1150, Value);
        }

        /// <summary>
        /// 写入罐装计数震台高速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottingCountVibrationTableHighSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1154, Value);
        }

        /// <summary>
        /// 写入罐装料筒震台减速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottingMaterialCylinderVibrationTableDecelerationSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1158, Value);
        }

        /// <summary>
        /// 写入罐装过滤震台减速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottingFilterVibrationTableDecelerationSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1162, Value);
        }

        /// <summary>
        /// 写入罐装计数震台减速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottingCountVibrationTableDecelerationSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1166, Value);
        }

        /// <summary>
        /// 写入缓存料筒震台高速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteCacheMaterialCylinderVibrationTableHighSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1170, Value);
        }

        /// <summary>
        /// 写入缓存过滤震台高速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteCacheFilterVibrationTableHighSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1174, Value);
        }

        /// <summary>
        /// 写入缓存计数震台高速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteCacheCountVibrationTableHighSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1178, Value);
        }

        /// <summary>
        /// 写入缓存料筒震台减速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteCacheMaterialCylinderVibrationTableDecelerationSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1182, Value);
        }

        /// <summary>
        /// 写入缓存过滤震台减速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteCacheFilterVibrationTableDecelerationSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1186, Value);
        }

        /// <summary>
        /// 写入缓存计数震台减速值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteCacheCountVibrationTableDecelerationSpeedValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1190, Value);
        }

        /// <summary>
        /// 写入闸门打开延时
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteGateOpeningDelay(UInt32 Value)
        {
            return modbusTcpClient.WriteSingleInt32(1, 1194, Value);
        }

        /// <summary>
        /// 写入回零偏移值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteReturnToZeroOffsetValue(float Value)
        {
            return modbusTcpClient.WriteSingleReal(1, 1198, Value);
        }

        /// <summary>
        /// 写入回零偏移速度
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteReturnToZeroOffsetSpeed(float Value)
        {
            return modbusTcpClient.WriteSingleReal(1, 1202, Value);
        }

        /// <summary>
        /// 写入中转阀关闭速度
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteTransferValveClosingSpeed(float Value)
        {
            return modbusTcpClient.WriteSingleReal(1, 1206, Value);
        }

        /// <summary>
        /// 写入中转阀开位置
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteTransferValveOpenPosition(float Value)
        {
            return modbusTcpClient.WriteSingleReal(1, 1210, Value);
        }

        /// <summary>
        /// 写入中转阀关位置
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteTransferValveClosePosition(float Value)
        {
            return modbusTcpClient.WriteSingleReal(1, 1214, Value);
        }

        /// <summary>
        /// 写入空气阀开启延时
        /// </summary>
        public bool WriteAirValveOpeningDelay(UInt32 Value)
        {
            return modbusTcpClient.WriteSingleInt32(1, 1218, Value);
        }

        /// <summary>
        /// 写入罐装停机值
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottlingShutdownValue(ushort Value)
        {
            return modbusTcpClient.WriteSingleRegister(1, 1230, Value);
        }

        /// <summary>
        /// 写入罐装停机时间
        /// </summary>
        /// <param name="Value"></param>
        public bool WriteBottlingShutdownTime(UInt32 Value)
        {
            return modbusTcpClient.WriteSingleInt32(1, 1234, Value);
        }
        /// <summary>
        /// 读取所有参数(参数数据表)
        /// </summary>
        public PlcParaModelClass ReadAllPara()
        {
            PlcParaModelClass result = null;
            var results = modbusTcpClient.ReadHoldingRegisters(slaveId: 1, startAddress: 1110, numRegisters: 124,out ushort[] ReturnValue);
            if (ReturnValue == null) return null;
            result = new PlcParaModelClass()
            {
                SpeedModeRunningSpeed = GetFloatFromRegisters(ReturnValue.Take(2).ToArray()),
                JogSpeed = GetFloatFromRegisters(ReturnValue.Skip(4).Take(2).ToArray()),
                BottValueSet = ReturnValue[8],
                TransferValveOpeningSpeed = GetFloatFromRegisters(ReturnValue.Skip(12).Take(2).ToArray()),
                TransferValveOpeningTime = GetInt32FromRegisters(ReturnValue.Skip(16).Take(2).ToArray()),
                BottingDecelerationValue = ReturnValue[20],
                CacheDecelerationValue = ReturnValue[24],
                CacheCountDelayTiming = GetInt32FromRegisters(ReturnValue.Skip(28).Take(2).ToArray()),
                CacheShutdownValue = ReturnValue[32],
                BottingMaterialCylinderVibrationTableHighSpeedValue = ReturnValue[36],
                BottingFilterVibrationTableHighSpeedValue = ReturnValue[40],
                BottingCountVibrationTableHighSpeedValue = ReturnValue[44],
                BottingMaterialCylinderVibrationTableDecelerationSpeedValue = ReturnValue[48],
                BottingFilterVibrationTableDecelerationSpeedValue = ReturnValue[52],
                BottingCountVibrationTableDecelerationSpeedValue = ReturnValue[56],
                CacheMaterialCylinderVibrationTableHighSpeedValue = ReturnValue[60],
                CacheFilterVibrationTableHighSpeedValue = ReturnValue[64],
                CacheCountVibrationTableHighSpeedValue = ReturnValue[68],
                CacheMaterialCylinderVibrationTableDecelerationSpeedValue = ReturnValue[72],
                CacheFilterVibrationTableDecelerationSpeedValue = ReturnValue[76],
                CacheCountVibrationTableDecelerationSpeedValue = ReturnValue[80],
                GateOpeningDelay = GetInt32FromRegisters(ReturnValue.Skip(84).Take(2).ToArray()),
                ReturnToZeroOffsetValue = GetFloatFromRegisters(ReturnValue.Skip(88).Take(2).ToArray()),
                ReturnToZeroOffsetSpeed = GetFloatFromRegisters(ReturnValue.Skip(92).Take(2).ToArray()),
                TransferValveClosingSpeed = GetFloatFromRegisters(ReturnValue.Skip(96).Take(2).ToArray()),
                TransferValveOpenPosition = GetFloatFromRegisters(ReturnValue.Skip(100).Take(2).ToArray()),
                TransferValveClosePosition = GetFloatFromRegisters(ReturnValue.Skip(104).Take(2).ToArray()),
                AirValveOpeningDelay = GetInt32FromRegisters(ReturnValue.Skip(108).Take(2).ToArray()),
                BottlingShutdownValue = ReturnValue[120],
            };
            results = modbusTcpClient.ReadHoldingRegisters(slaveId: 1, startAddress: 1234, numRegisters: 36,out ReturnValue);
            result.BottlingShutdownTime = GetInt32FromRegisters(ReturnValue.Take(2).ToArray());
            result.BottleFeedingWheelRunningSpeed = GetFloatFromRegisters(ReturnValue.Skip(8).Take(2).ToArray());
            result.BottleFeedingWheelJogRunningSpeed = GetFloatFromRegisters(ReturnValue.Skip(12).Take(2).ToArray());
            result.BottleFeedingWheelReturnToZeroOffsetValue = GetFloatFromRegisters(ReturnValue.Skip(16).Take(2).ToArray());
            result.BottleFeedingWheelReturnToZeroSpeed = GetFloatFromRegisters(ReturnValue.Skip(20).Take(2).ToArray());
            result.BottleFeedingWheelPositionLength = GetFloatFromRegisters(ReturnValue.Skip(24).Take(2).ToArray());
            result.BottleFeedingWheelPauseTime = GetInt32FromRegisters(ReturnValue.Skip(28).Take(2).ToArray());
            result.DelayBlanking = GetInt32FromRegisters(ReturnValue.Skip(32).Take(2).ToArray());
            return result;
        }

        public bool ReadBottingVibrationTableHighSpeedValue(out ushort MaterialCylinderValue,out ushort FilterValue,out ushort CountValue)
        {
            bool result = false;
            if(modbusTcpClient.ReadHoldingRegisters(1, 1146, 12,out ushort[] ReturnValue))
            {
                MaterialCylinderValue = ReturnValue[0];
                FilterValue = ReturnValue[4];
                CountValue = ReturnValue[8];
                result = true;
            }
            else
            {
                MaterialCylinderValue = 0;
                FilterValue = 0;
                CountValue = 0;
            }
            return result;
        }

        public bool ReadBottingCount(out ushort Count)
        {
            bool result = false;
            if(modbusTcpClient.ReadHoldingRegisters(1, 1269, 1,out ushort[] ReturnValue))//临时地址
            {
                Count = ReturnValue[0];
                result = true;
            }
            else
            {
                Count = 0;
            }
            return result;
        }

        /// <summary>
        /// 获取16位寄存器中的32Uint位值
        /// </summary>
        private UInt32 GetInt32FromRegisters(ushort[] registers,string byteOrder = "BADC")
        {
            ushort highRegister = registers[0];
            ushort lowRegister = registers[1];

            byte[] bytes = ConvertToByteArray(lowRegister, highRegister, byteOrder);

            // 转换为float
            return (UInt32)BitConverter.ToInt32(bytes, 0);
        }

        /// <summary>
        /// 获取16位寄存器中的32Float位值
        /// </summary>
        private float GetFloatFromRegisters(ushort[] registers)
        {
            string byteOrder = "BADC";
            ushort highRegister = registers[0];
            ushort lowRegister = registers[1];
            byte[] bytes = ConvertToByteArray(lowRegister, highRegister, byteOrder);
            return BitConverter.ToSingle(bytes, 0); ;
        }

        /// <summary>
        /// 将寄存器数组换为字节数组转（根据指定字节序）
        /// </summary>
        /// <param name="lowRegister">低位寄存器</param>
        /// <param name="highRegister">高位寄存器</param>
        /// <param name="byteOrder">字节序</param>
        /// <returns>字节数组</returns>
        private byte[] ConvertToByteArray(ushort lowRegister, ushort highRegister, string byteOrder = "BADC")
        {
            byte[] bytes = new byte[4];

            switch (byteOrder.ToUpper())
            {
                case "ABCD": // 大端序
                    bytes[0] = (byte)(highRegister >> 8);
                    bytes[1] = (byte)(highRegister & 0xFF);
                    bytes[2] = (byte)(lowRegister >> 8);
                    bytes[3] = (byte)(lowRegister & 0xFF);
                    break;
                case "CDAB": // 小端序
                    bytes[0] = (byte)(lowRegister >> 8);
                    bytes[1] = (byte)(lowRegister & 0xFF);
                    bytes[2] = (byte)(highRegister >> 8);
                    bytes[3] = (byte)(highRegister & 0xFF);
                    break;
                case "BADC":
                    bytes[0] = (byte)(highRegister & 0xFF);
                    bytes[1] = (byte)(highRegister >> 8);
                    bytes[2] = (byte)(lowRegister & 0xFF);
                    bytes[3] = (byte)(lowRegister >> 8);
                    break;
                case "DCBA":
                    bytes[0] = (byte)(lowRegister & 0xFF);
                    bytes[1] = (byte)(lowRegister >> 8);
                    bytes[2] = (byte)(highRegister & 0xFF);
                    bytes[3] = (byte)(highRegister >> 8);
                    break;
                default:
                    // 默认使用ABCD顺序
                    bytes[0] = (byte)(highRegister >> 8);
                    bytes[1] = (byte)(highRegister & 0xFF);
                    bytes[2] = (byte)(lowRegister >> 8);
                    bytes[3] = (byte)(lowRegister & 0xFF);
                    break;
            }
            return bytes;
        }

        /// <summary>
        /// 切换使能
        /// </summary>
        public bool SwitchEnable()
        {
            bool result = ReadEnable(out bool Value);
            if(result)
            {
                return modbusTcpClient.WriteCoilsRegister(slaveId: 1, CoilsAddress: 24, values: !Value);
            }
            return result;
        }

        /// <summary>
        /// 切换闸门点动
        /// </summary>
        /// <param name="value">闸门编号</param>
        public bool SwitchValveJog(int value)
        {
            bool result = false;
            if (value >= 0 && value <= 7)
            {
                ushort valveJog = ReadValveJog();
                ushort mask = (ushort)(1 << value);
                result = modbusTcpClient.WriteSingleRegister(slaveId: 1, registerAddress: 238, value: (ushort)(valveJog^mask));
            }
            return result;
        }

        /// <summary>
        /// 写入送瓶轮运行速度
        /// </summary>
        /// <param name="result"></param>
        public bool WriteBottleFeedingWheelRunningSpeed(float result)
        {
            return modbusTcpClient.WriteSingleReal(slaveId: 1, startAddress: 1242, value: result);
        }

        /// <summary>
        /// 送瓶轮点动速度
        /// </summary>
        /// <param name="result"></param>
        public bool WriteBottleFeedingWheelJogRunningSpeed(float result)
        {
            return modbusTcpClient.WriteSingleReal(slaveId: 1, startAddress: 1246, value: result);
        }

        /// <summary>
        /// 送瓶轮回零偏移值
        /// </summary>
        /// <param name="result"></param>
        public bool WriteBottleFeedingWheelReturnToZeroOffsetValue(float result)
        {
            return modbusTcpClient.WriteSingleReal(slaveId: 1, startAddress: 1250, value: result);
        }

        /// <summary>
        /// 送瓶轮回零速度
        /// </summary>
        /// <param name="result"></param>
        public bool WriteBottleFeedingWheelReturnToZeroSpeed(float result)
        {
            return modbusTcpClient.WriteSingleReal(slaveId: 1, startAddress: 1254, value: result);
        }

        /// <summary>
        /// 送瓶轮定位长度
        /// </summary>
        /// <param name="result"></param>
        public bool WriteBottleFeedingWheelPositionLength(float result)
        {
            return modbusTcpClient.WriteSingleReal(slaveId: 1, startAddress: 1258, value: result);
        }

        /// <summary>
        /// 送瓶轮暂停时间
        /// </summary>
        /// <param name="result"></param>
        public bool WriteBottleFeedingWheelPauseTime(UInt32 result)
        {
            return modbusTcpClient.WriteSingleInt32(slaveId: 1, startAddress: 1262, value: result);
        }

        /// <summary>
        /// 下料延时
        /// </summary>
        /// <param name="result"></param>
        public bool WriteDelayBlanking(UInt32 result)
        {
            return modbusTcpClient.WriteSingleInt32(slaveId: 1, startAddress: 1266, value: result);
        }

        /// <summary>
        /// 读取闸门点动
        /// </summary>
        public ushort ReadValveJog()
        {
            ushort result = 0;
            if (modbusTcpClient.ReadHoldingRegisters(slaveId: 1, startAddress: 238, numRegisters: 1, out ushort[] returnValue))
            {
                result = returnValue[0];
            }
            else
            {
                result = 0;
            }
            return result;
        }
    }
}