CtrEditor/ObjetosSim/ucVMmotorSim.xaml.cs

using CtrEditor.Convertidores;
using CtrEditor.Siemens;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using CtrEditor.Simulacion;
using Newtonsoft.Json;

namespace CtrEditor.ObjetosSim
{
    /// <summary>
    /// Interaction logic for ucVMmotorSim.xaml
    /// </summary>
    /// 

    public class osVMmotorSim : osBase
    {

        // Otros datos y métodos relevantes para la simulación

        private string _nombre = "VetroMeccanica Motor";
        private float _tamano;
        private float _left;
        private float _top;
        private int _numeroMotor;
        private float _ratio;
        private float _velocidad;
        private bool _encendido;
        private float _rampaSegundos;
        private float _maxHz;
        private ImageSource _imageSource;
                
        private VMSimMotor motState = new VMSimMotor();

        [Hidden]
        [JsonIgnore]
        public ImageSource ImageSource
        {
            get { return _imageSource; }
            set
            {
                _imageSource = value;
                OnPropertyChanged(nameof(ImageSource));
            }
        }

        public float Tamano
        {
            get => _tamano;
            set
            {
                _tamano = value;
                OnPropertyChanged(nameof(Tamano));
            }
        }

        public float MaxRatedHz
        {
            get => _maxHz;
            set
            {
                _maxHz = value;
                OnPropertyChanged(nameof(Tamano));
            }
        }

        public float TiempoRampa
        {
            get => _rampaSegundos;
            set
            {
                if (value < 0.1f)
                    value = 0.1f;
                _rampaSegundos = value;
                OnPropertyChanged(nameof(Tamano));
            }
        }

        public bool Encendido
        {
            get => _encendido;
            set
            {
                _encendido = value;                
                OnPropertyChanged(nameof(Encendido));
            }
        }

        public int PLC_NumeroMotor
        {
            get => _numeroMotor;
            set
            {
                _numeroMotor = value;
                OnPropertyChanged(nameof(PLC_NumeroMotor));
            }
        }


        public override float Left
        {
            get => _left;
            set
            {
                _left = value;
                CanvasSetLeftinMeter(value);
                OnPropertyChanged(nameof(Left));
            }
        }
        public override float Top
        {
            get => _top;
            set
            {
                _top = value;
                CanvasSetTopinMeter(value);
                OnPropertyChanged(nameof(Top));
            }
        }

        public override string Nombre
        {
            get => _nombre;
            set
            {
                if (_nombre != value)
                {
                    _nombre = value;
                    OnPropertyChanged(nameof(Nombre));
                }
            }
        }

        public float Ratio {
            get => _ratio;
            set {
                _ratio = value;
                OnPropertyChanged(nameof(Ratio));
            }
        }

        public float Velocidad {
            get => _velocidad;
            set {
                _velocidad = value;
                if (value > 0) 
                    ImageSource = ImageFromPath("/imagenes/motorVerde.png");
                else
                    ImageSource = ImageFromPath("/imagenes/motorNegro.png");

                OnPropertyChanged(nameof(Velocidad));
            }
        }

        public osVMmotorSim()
        {
            Tamano = 0.30f;
            PLC_NumeroMotor = 31;
            MaxRatedHz = 100;
            TiempoRampa = 3;
            ImageSource = ImageFromPath("/imagenes/motor2.png");
        }        

        public override void UpdateGeometryStart()
        {
            // Se llama antes de la simulacion

        }
        public override void UpdateGeometryStep()
        {
        }
        public override void UpdatePLC(PLCModel plc, int elapsedMilliseconds) {

            motState.UpdatePLC(plc,PLC_NumeroMotor,Encendido, elapsedMilliseconds);
            Velocidad = motState.STATUS_VFD_ACT_Speed_Hz / 10;

        }

        public override void UpdateControl(int elapsedMilliseconds)
        {
            // Calculamos la velocidad
            motState.UpdateSpeed(MaxRatedHz,TiempoRampa, elapsedMilliseconds);

        }

        public override void ucLoaded()
        {
            // El UserControl ya se ha cargado y podemos obtener las coordenadas para 
            // crear el objeto de simulacion
        }

    }

    public partial class ucVMmotorSim : UserControl, IDataContainer
    {
        public osBase? Datos { get; set; }

        public ucVMmotorSim()
        {
            InitializeComponent();
            this.Loaded += OnLoaded;
        }
        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            Datos?.ucLoaded();
        }
        public void Resize(float width, float height) { }
        public void Move(float LeftPixels, float TopPixels)
        {
            if (Datos != null)
            {
                Datos.Left = PixelToMeter.Instance.calc.PixelsToMeters(LeftPixels);
                Datos.Top = PixelToMeter.Instance.calc.PixelsToMeters(TopPixels);
            }
        }
        public void Rotate(float Angle) { }
        public void Highlight(bool State) { }
        public int ZIndex()
        {
            return 10;
        }
    }

    public class VMSimMotor
    {
        public bool _STATUS_VFD_Ready;
        public float STATUS_VFD_ACT_Speed_Hz;
        public bool Motor_Running;
        public bool STATUS_VFD_Trip;
        public bool STATUS_VFD_Warning;
        public bool STATUS_VFD_Coasting;
        public bool OUT_Run;
        public bool OUT_Stop;
        public bool OUT_Reversal;
        public float OUT_OUT_VFD_REQ_Speed_Hz;

        public void UpdatePLC(PLCModel plc, int NumeroMotor, bool Encendido, int elapsedMilliseconds)
        {
            var index = 0;
            switch (NumeroMotor)
            {
                case < 100:
                    index = (int)NumeroMotor - 30 + 300;
                    break;
            }

            OUT_Run = plc.LeerTagBool($"\"DB MotorSimulate\".Motors[{index}].OUT.Run");
            OUT_Reversal = plc.LeerTagBool($"\"DB MotorSimulate\".Motors[{index}].OUT.\"Reversal Direction\"");
            OUT_OUT_VFD_REQ_Speed_Hz = (float)plc.LeerTagInt16($"\"DB MotorSimulate\".Motors[{index}].OUT.OUT_VFD_REQ_Speed_Hz");



            if (Encendido)
            {
                _STATUS_VFD_Ready = true;
                Motor_Running = true;
                STATUS_VFD_Trip = false;
                STATUS_VFD_Warning = false;
                STATUS_VFD_Coasting = false;
            }
            else
            {
                _STATUS_VFD_Ready = false;
                Motor_Running = false;
                STATUS_VFD_Trip = true;
                STATUS_VFD_Warning = false;
                STATUS_VFD_Coasting = false;
            }

            plc.EscribirTagBool($"\"DB MotorSimulate\".Motors[{index}].STATUS_VFD_Ready", _STATUS_VFD_Ready);
            plc.EscribirTagBool($"\"DB MotorSimulate\".Motors[{index}].Motor_Running", Motor_Running);
            plc.EscribirTagBool($"\"DB MotorSimulate\".Motors[{index}].STATUS_VFD_Trip", STATUS_VFD_Trip);
            plc.EscribirTagBool($"\"DB MotorSimulate\".Motors[{index}].STATUS_VFD_Warning", STATUS_VFD_Warning);
            plc.EscribirTagBool($"\"DB MotorSimulate\".Motors[{index}].STATUS_VFD_Coasting", STATUS_VFD_Coasting);

            plc.EscribirTagInt16($"\"DB MotorSimulate\".Motors[{index}].STATUS_VFD_ACT_Speed_Hz", (int)STATUS_VFD_ACT_Speed_Hz);

        }

        private float CalcSpeedRamp(float MaxRatedHz, float TiempoRampa, float actual, float expected, int elapsedMilliseconds)
        {
            float hzIncrementsRamp = (MaxRatedHz * 10) / (TiempoRampa * (1000.0f / elapsedMilliseconds));
            float delta = expected - actual;
            // Conrtolar si la diferencia no es mayor de lo que falta
            if (Math.Abs(hzIncrementsRamp) > Math.Abs(delta))
                hzIncrementsRamp = Math.Abs(delta);
            if (delta < 0)
                return -hzIncrementsRamp;
            else
                return hzIncrementsRamp;
        }

        public void UpdateSpeed(float MaxRatedHz, float TiempoRampa, int elapsedMilliseconds)
        {
            // Calculamos la velocidad
            STATUS_VFD_ACT_Speed_Hz += CalcSpeedRamp(MaxRatedHz, TiempoRampa, STATUS_VFD_ACT_Speed_Hz, OUT_OUT_VFD_REQ_Speed_Hz, elapsedMilliseconds);

        }
    }

}