lj_plc/Actions/ChemicalWeighing/Mesnac.Action.ChemicalWeighing/LjDry/DryPlc.cs

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

namespace Mesnac.Action.ChemicalWeighing.LjDry
{
    public class DryPlc
    {
        private static BasePlcHelper GetPlcHelper => BasePlcHelper.Instance;

        private static void Down1408(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer0_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer0_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer0_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer0_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer0_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer0_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer0_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer0_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer0_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer0_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer0_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1408()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 1,
                Model = Convert.ToBoolean(basePlcHelper.Dryer0_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Dryer0_status.NowValue.ToInt()),
                Batch = basePlcHelper.Dryer0_batch.NowValue.ToInt(),
                Step = basePlcHelper.Dryer0_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Dryer0_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Dryer0_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Dryer0_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Dryer0_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Dryer0_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Dryer0_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Dryer0_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1440(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer1_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer1_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer1_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer1_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer1_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer1_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer1_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer1_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer1_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer1_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer1_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1440()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 2,
                Model = Convert.ToBoolean(basePlcHelper.Dryer1_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Dryer1_status.NowValue.ToInt()),
                Batch = basePlcHelper.Dryer1_batch.NowValue.ToInt(),
                Step = basePlcHelper.Dryer1_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Dryer1_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Dryer1_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Dryer1_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Dryer1_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Dryer1_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Dryer1_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Dryer1_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1472(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer2_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer2_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer2_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer2_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer2_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer2_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer2_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer2_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer2_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer2_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer2_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1472()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 3,
                Model = Convert.ToBoolean(basePlcHelper.Dryer2_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Dryer2_status.NowValue.ToInt()),
                Batch = basePlcHelper.Dryer2_batch.NowValue.ToInt(),
                Step = basePlcHelper.Dryer2_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Dryer2_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Dryer2_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Dryer2_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Dryer2_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Dryer2_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Dryer2_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Dryer2_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1504(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer3_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer3_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer3_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer3_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer3_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer3_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Dryer3_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer3_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer3_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer3_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Dryer3_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1504()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 4,
                Model = Convert.ToBoolean(basePlcHelper.Dryer3_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Dryer3_status.NowValue.ToInt()),
                Batch = basePlcHelper.Dryer3_batch.NowValue.ToInt(),
                Step = basePlcHelper.Dryer3_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Dryer3_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Dryer3_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Dryer3_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Dryer3_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Dryer3_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Dryer3_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Dryer3_pressure.NowValue.ToFloat(),
            };
            return view;

        }


        private static void Down1536(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater0_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater0_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater0_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater0_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater0_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater0_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater0_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater0_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater0_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater0_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater0_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1536()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 5,
                Model = Convert.ToBoolean(basePlcHelper.Gelater0_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Gelater0_status.NowValue.ToInt()),
                Batch = basePlcHelper.Gelater0_batch.NowValue.ToInt(),
                Step = basePlcHelper.Gelater0_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Gelater0_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Gelater0_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Gelater0_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Gelater0_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Gelater0_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Gelater0_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Gelater0_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1568(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater1_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater1_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater1_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater1_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater1_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater1_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater1_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater1_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater1_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater1_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater1_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1568()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 6,
                Model = Convert.ToBoolean(basePlcHelper.Gelater1_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Gelater1_status.NowValue.ToInt()),
                Batch = basePlcHelper.Gelater1_batch.NowValue.ToInt(),
                Step = basePlcHelper.Gelater1_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Gelater1_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Gelater1_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Gelater1_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Gelater1_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Gelater1_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Gelater1_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Gelater1_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1600(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater2_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater2_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater2_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater2_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater2_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater2_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater2_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater2_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater2_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater2_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater2_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1600()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 7,
                Model = Convert.ToBoolean(basePlcHelper.Gelater2_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Gelater2_status.NowValue.ToInt()),
                Batch = basePlcHelper.Gelater2_batch.NowValue.ToInt(),
                Step = basePlcHelper.Gelater2_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Gelater2_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Gelater2_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Gelater2_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Gelater2_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Gelater2_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Gelater2_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Gelater2_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1632(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater3_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater3_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater3_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater3_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater3_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater3_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater3_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater3_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater3_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater3_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater3_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1632()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 8,
                Model = Convert.ToBoolean(basePlcHelper.Gelater3_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Gelater3_status.NowValue.ToInt()),
                Batch = basePlcHelper.Gelater3_batch.NowValue.ToInt(),
                Step = basePlcHelper.Gelater3_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Gelater3_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Gelater3_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Gelater3_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Gelater3_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Gelater3_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Gelater3_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Gelater3_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1664(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater4_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater4_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater4_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater4_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater4_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater4_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater4_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater4_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater4_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater4_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater4_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1664()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 9,
                Model = Convert.ToBoolean(basePlcHelper.Gelater4_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Gelater4_status.NowValue.ToInt()),
                Batch = basePlcHelper.Gelater4_batch.NowValue.ToInt(),
                Step = basePlcHelper.Gelater4_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Gelater4_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Gelater4_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Gelater4_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Gelater4_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Gelater4_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Gelater4_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Gelater4_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1696(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater5_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater5_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater5_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater5_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater5_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater5_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater5_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater5_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater5_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater5_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater5_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1696()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 10,
                Model = Convert.ToBoolean(basePlcHelper.Gelater5_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Gelater5_status.NowValue.ToInt()),
                Batch = basePlcHelper.Gelater5_batch.NowValue.ToInt(),
                Step = basePlcHelper.Gelater5_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Gelater5_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Gelater5_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Gelater5_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Gelater5_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Gelater5_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Gelater5_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Gelater5_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1728(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater6_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater6_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater6_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater6_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater6_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater6_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater6_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater6_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater6_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater6_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater6_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1728()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 11,
                Model = Convert.ToBoolean(basePlcHelper.Gelater6_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Gelater6_status.NowValue.ToInt()),
                Batch = basePlcHelper.Gelater6_batch.NowValue.ToInt(),
                Step = basePlcHelper.Gelater6_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Gelater6_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Gelater6_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Gelater6_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Gelater6_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Gelater6_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Gelater6_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Gelater6_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1760(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater7_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater7_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater7_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater7_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater7_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater7_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Gelater7_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater7_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater7_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater7_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Gelater7_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1760()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 12,
                Model = Convert.ToBoolean(basePlcHelper.Gelater7_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Gelater7_status.NowValue.ToInt()),
                Batch = basePlcHelper.Gelater7_batch.NowValue.ToInt(),
                Step = basePlcHelper.Gelater7_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Gelater7_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Gelater7_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Gelater7_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Gelater7_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Gelater7_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Gelater7_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Gelater7_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1792(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter0_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter0_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter0_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter0_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter0_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter0_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter0_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter0_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter0_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter0_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter0_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1792()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 13,
                Model = Convert.ToBoolean(basePlcHelper.Weter0_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Weter0_status.NowValue.ToInt()),
                Batch = basePlcHelper.Weter0_batch.NowValue.ToInt(),
                Step = basePlcHelper.Weter0_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Weter0_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Weter0_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Weter0_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Weter0_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Weter0_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Weter0_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Weter0_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1824(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter1_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter1_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter1_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter1_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter1_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter1_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter1_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter1_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter1_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter1_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter1_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1824()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 14,
                Model = Convert.ToBoolean(basePlcHelper.Weter1_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Weter1_status.NowValue.ToInt()),
                Batch = basePlcHelper.Weter1_batch.NowValue.ToInt(),
                Step = basePlcHelper.Weter1_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Weter1_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Weter1_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Weter1_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Weter1_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Weter1_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Weter1_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Weter1_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1856(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter2_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter2_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter2_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter2_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter2_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter2_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter2_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter2_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter2_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter2_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter2_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1856()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 15,
                Model = Convert.ToBoolean(basePlcHelper.Weter2_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Weter2_status.NowValue.ToInt()),
                Batch = basePlcHelper.Weter2_batch.NowValue.ToInt(),
                Step = basePlcHelper.Weter2_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Weter2_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Weter2_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Weter2_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Weter2_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Weter2_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Weter2_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Weter2_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1888(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter3_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter3_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter3_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter3_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter3_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter3_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter3_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter3_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter3_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter3_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter3_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1888()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 16,
                Model = Convert.ToBoolean(basePlcHelper.Weter3_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Weter3_status.NowValue.ToInt()),
                Batch = basePlcHelper.Weter3_batch.NowValue.ToInt(),
                Step = basePlcHelper.Weter3_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Weter3_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Weter3_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Weter3_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Weter3_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Weter3_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Weter3_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Weter3_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1920(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter4_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter4_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter4_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter4_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter4_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter4_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter4_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter4_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter4_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter4_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter4_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1920()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 17,
                Model = Convert.ToBoolean(basePlcHelper.Weter4_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Weter4_status.NowValue.ToInt()),
                Batch = basePlcHelper.Weter4_batch.NowValue.ToInt(),
                Step = basePlcHelper.Weter4_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Weter4_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Weter4_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Weter4_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Weter4_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Weter4_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Weter4_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Weter4_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1952(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter5_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter5_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter5_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter5_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter5_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter5_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter5_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter5_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter5_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter5_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter5_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1952()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 18,
                Model = Convert.ToBoolean(basePlcHelper.Weter5_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Weter5_status.NowValue.ToInt()),
                Batch = basePlcHelper.Weter5_batch.NowValue.ToInt(),
                Step = basePlcHelper.Weter5_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Weter5_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Weter5_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Weter5_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Weter5_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Weter5_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Weter5_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Weter5_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down1984(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter6_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter6_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter6_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter6_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter6_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter6_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter6_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter6_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter6_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter6_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter6_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up1984()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 19,
                Model = Convert.ToBoolean(basePlcHelper.Weter6_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Weter6_status.NowValue.ToInt()),
                Batch = basePlcHelper.Weter6_batch.NowValue.ToInt(),
                Step = basePlcHelper.Weter6_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Weter6_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Weter6_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Weter6_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Weter6_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Weter6_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Weter6_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Weter6_pressure.NowValue.ToFloat(),
            };
            return view;

        }

        private static void Down2016(DrySettingView view)
        {
            if (null != view)
            {
                var basePlcHelper = GetPlcHelper;
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter7_mode, new object[]
                {
                    view.Model
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter7_status, new object[]
                {
                    view.Status
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter7_batch, new object[]
                {
                    view.Batch
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter7_step, new object[]
                {
                    view.Step
                });
                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter7_stepCode, new object[]
                {
                    view.StepCode
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter7_totalTime, new object[]
                {
                    view.TotalTime
                });

                basePlcHelper.PlcWriteByDataKey(basePlcHelper.Weter7_stepTime, new object[]
                {
                    view.StepTime
                });


                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter7_temperature,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter7_speed,
                    view.Speed);

                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter7_currnet,
                    view.Temperature);
                basePlcHelper.PlcWriteFloatByDataKey(basePlcHelper.Weter7_pressure,
                    view.Pressure);
            }
        }

        private static DrySettingView Up2016()
        {
            var basePlcHelper = GetPlcHelper;
            DrySettingView view = new DrySettingView
            {
                Id = 20,
                Model = Convert.ToBoolean(basePlcHelper.Weter7_mode.NowValue.ToInt()),
                Status = Convert.ToBoolean(basePlcHelper.Weter7_status.NowValue.ToInt()),
                Batch = basePlcHelper.Weter7_batch.NowValue.ToInt(),
                Step = basePlcHelper.Weter7_step.NowValue.ToInt(),
                StepCode = basePlcHelper.Weter7_stepCode.NowValue.ToInt(),
                TotalTime = basePlcHelper.Weter7_totalTime.NowValue.ToInt(),
                StepTime = basePlcHelper.Weter7_stepTime.NowValue.ToInt(),
                Temperature = basePlcHelper.Weter7_temperature.NowValue.ToFloat(),
                Speed = basePlcHelper.Weter7_speed.NowValue.ToFloat(),
                Currnet = basePlcHelper.Weter7_currnet.NowValue.ToFloat(),
                Pressure = basePlcHelper.Weter7_pressure.NowValue.ToFloat(),
            };
            return view;

        }


        public static IList<DrySettingView> UpFromPlc()
        {
            IList<DrySettingView> ls = new List<DrySettingView>();
            ls.Add(Up1408());
            ls.Add(Up1440());
            ls.Add(Up1472());
            ls.Add(Up1504());
            ls.Add(Up1536());
            ls.Add(Up1568());
            ls.Add(Up1600());
            ls.Add(Up1632());
            ls.Add(Up1664());
            ls.Add(Up1696());
            ls.Add(Up1728());
            ls.Add(Up1760());
            ls.Add(Up1792());
            ls.Add(Up1824());
            ls.Add(Up1856());
            ls.Add(Up1888());
            ls.Add(Up1920());
            ls.Add(Up1952());
            ls.Add(Up1984());
            ls.Add(Up2016());



            return ls;

        }

        public static DrySettingView UpFromPlc(int id)
        {
            DrySettingView view = new DrySettingView();
            switch (id)
            {
                case 1:
                    view = Up1408();
                    break;
                case 2:
                    view = Up1440();
                    break;
                case 3:
                    view = Up1472();
                    break;
                case 4:
                    view = Up1504();
                    break;
                case 5:
                    view = Up1536();
                    break;
                case 6:
                    view = Up1568();
                    break;
                case 7:
                    view = Up1600();
                    break;
                case 8:
                    view = Up1632();
                    break;
                case 9:
                    view = Up1664();
                    break;
                case 10:
                    view = Up1696();
                    break;
                case 11:
                    view = Up1728();
                    break;
                case 12:
                    view = Up1760();
                    break;
                case 13:
                    view = Up1792();
                    break;
                case 14:
                    view = Up1824();
                    break;
                case 15:
                    view = Up1856();
                    break;
                case 16:
                    view = Up1888();
                    break;
                case 17:
                    view = Up1920();
                    break;
                case 18:
                    view = Up1952();
                    break;
                case 19:
                    view = Up1984();
                    break;
                case 20:
                    view = Up2016();
                    break;


            }

            return view;
        }


        public static void DownToPlc(DrySettingView view)
        {

            switch (view.Id)
            {
                case 1:
                    Down1408(view);
                    break;
                case 2:
                    Down1440(view);
                    break;
                case 3:
                    Down1472(view);
                    break;
                case 4:
                    Down1504(view);
                    break;
                case 5:
                    Down1536(view);
                    break;
                case 6:
                    Down1568(view);
                    break;
                case 7:
                    Down1600(view);
                    break;
                case 8:
                    Down1632(view);
                    break;
                case 9:
                    Down1664(view);
                    break;
                case 10:
                    Down1696(view);
                    break;
                case 11:
                    Down1728(view);
                    break;
                case 12:
                    Down1760(view);
                    break;
                case 13:
                    Down1792(view);
                    break;
                case 14:
                    Down1824(view);
                    break;
                case 15:
                    Down1856(view);
                    break;
                case 16:
                    Down1888(view);
                    break;
                case 17:
                    Down1920(view);
                    break;
                case 18:
                    Down1952(view);
                    break;
                case 19:
                    Down1984(view);
                    break;
                case 20:
                    Down2016(view);
                    break;



            }
        }
    }
}