agrobot_base/AgroBase/AgroBase/Models/Modules/SensoriamentoModel.cs

using AgroBase.Forms.IHM;
using AgroBase.Services;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using static AgroBase.Models.Enums;

namespace AgroBase.Models.Modules
{
    public class SensoriamentoModel : DispositivoBaseModel
    {
        public string Modulo_ID { get; set; } = T_Code.Sen.ToString();
        public string IP { get; set; } = Variaveis.FaixaIPwifi + ".12";
        public bool RequisitarDados { get; set; } = false;
        private bool _MensagemConexaoRecebida { get; set; } = false;
        public bool MensagemConexaoRecebida(bool Reset = false)
        {
            if (Reset)
            {
                _MensagemConexaoRecebida = false;
            }
            return _MensagemConexaoRecebida;
        }

        public static int _TaxaAmostragem { get; set; } = 1000;
        public static int PingsConsiderarConexao { get; set; } = 5;
        public static int TempoLimiteConexao
        {
            get
            {
                return PingsConsiderarConexao * _TaxaAmostragem;
            }
        }
        public bool Conectado { get; set; } = false;
        public static int LogsManter { get; set; } = 60;
        public static PinoutDataModel Pinout { get; set; }
        public static bool ExpansorGPIO { get; set; } = false;
        public static List<FuncoesPinout> Funcoes { get; set; } = new List<FuncoesPinout>()
        {
            FuncoesPinout.SDA,
            FuncoesPinout.SCL,
        };
        public List<SensorModel> Sensores { get; set; }
        public List<SensorSinaleiroModel> Sinaleiros { get; set; }
        public List<SensorReleModel> Reles { get; set; }
        public List<SensorServoModel> Servos { get; set; }
        public string CameraID_Caminho { get; set; } = "";
        public List<string> CameraID_Solo { get; set; } = new List<string>();
        public UltrasonicA05Configuracoes ConfiguracaoSensorUltrassom { get; set; }
        public double BateriaCargaConsumida { get; set; }
        public SensoriamentoMensagemJsonModel DadosLeitura { get; set; } = new SensoriamentoMensagemJsonModel();
        public LoRaParametrosModel LoRaParametrosBase { get; set; } = new LoRaParametrosModel()
        {
            address = 0x01,
            channel = 0x17,
            tranMode = LoRaService.CodigosTipoTransmissao["Fixed"],
            baudRate = LoRaService.CodigosBaudRates[9600],
            airRate = LoRaService.CodigosAirRates[2.4],
            packetSize = LoRaService.CodigosPacketSizes[200],
            worCycle = LoRaService.CodigosWorCycles[4000],
            power = LoRaService.CodigosPowers[22],
        };

        public AsyncTaskTimerModel tmrRegistrador;
        private int _TempoReconexaoComponentes = 5;
        private int _VezesLeituraReconexao = 0;

        public static SensoriamentoModel CarregarParametrosIniciais()
        {
            return new SensoriamentoModel()
            {
                CameraID_Caminho = "", 
                CameraID_Solo = new List<string>()
                {
                    "", 
                    ""
                },
                Sinaleiros = new List<SensorSinaleiroModel>()
                {
                    new SensorSinaleiroModel()
                    {
                        ID = "LEDMN",
                        Descricao = "Sinaleiro indicação de modo Manual ativo",
                        Componente = S_Code.sLED,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.Sinaleiro,
                        }, 
                        Comportamento = VariaveisEquipamento.ComportamentoPorStatus(StatusOperacao.NaoIniciado)
                    },
                    new SensorSinaleiroModel()
                    {
                        ID = "LEDAT",
                        Descricao = "Sinaleiro indicação de modo Automático ativo",
                        Componente = S_Code.sLED,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.Sinaleiro,
                        },
                        Comportamento = VariaveisEquipamento.ComportamentoPorStatus(StatusOperacao.NaoIniciado)
                    },
                    new SensorSinaleiroModel()
                    {
                        ID = "LEDOP",
                        Descricao = "Sinaleiro indicação do status da operação ativa",
                        Componente = S_Code.sLED,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.Sinaleiro,
                        },
                        Comportamento = VariaveisEquipamento.ComportamentoPorStatus(StatusOperacao.NaoIniciado)
                    },
                },
                Sensores = new List<SensorModel>()
                {
                    new SensorModel()
                    {
                        ID = "TMVET",
                        Descricao = "Temperatura Motor Esquerdo Trás",
                        Prioridade = 0,
                        Componente = S_Code.sTMP, 
                        Aferir = true, 
                        Testando = false, 
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.TMP,
                        },
                        DelayAmostragem = 200,
                        UnidadeMedida = "ºC",
                        Parametros = new List<string[]>()
                        {
                            new string[] { "Offset", "0" },
                        },
                    },
                    new SensorModel()
                    {
                        ID = "TMVEF",
                        Descricao = "Temperatura Motor Esquerdo Frente",
                        Prioridade = 0,
                        Componente = S_Code.sTMP,
                        Aferir = true,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.TMP,
                        },
                        DelayAmostragem = 200,
                        UnidadeMedida = "ºC",
                        Parametros = new List<string[]>()
                        {
                            new string[] { "Offset", "0" },
                        },
                    },
                    new SensorModel()
                    {
                        ID = "TMVDT",
                        Descricao = "Temperatura Motor Direito Trás",
                        Prioridade = 0,
                        Componente = S_Code.sTMP,
                        Aferir = true,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.TMP,
                        },
                        DelayAmostragem = 200,
                        UnidadeMedida = "ºC",
                        Parametros = new List<string[]>()
                        {
                            new string[] {"Offset", "0" },
                        },
                    },
                    new SensorModel()
                    {
                        ID = "TMVDF",
                        Descricao = "Temperatura Motor Direito Frente",
                        Prioridade = 0,
                        Componente = S_Code.sTMP,
                        Aferir = true,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.TMP,
                        },
                        DelayAmostragem = 200,
                        UnidadeMedida = "ºC",
                        Parametros = new List<string[]>()
                        {
                            new string[] {"Offset", "0" },
                        },
                    },
                    /*new SensorModel()
                    {
                        ID = "AB3V",
                        Prioridade = 10,
                        Descricao = "Corrente no Barramento 3V",
                        Componente = S_Code.sCOR,
                        Aferir = true,
                        Inicializado = false,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.I2C,
                        },
                        DelayAmostragem = 500,
                        UnidadeMedida = "A",
                        Parametros = new List<string[]>()
                        {
                            new string[] { "Endereço I2C", "0x45" },
                            new string[] { "CI", "219" }
                        },
                    },*/
                    new SensorModel()
                    {
                        ID = "AB5V",
                        Prioridade = 10,
                        Descricao = "Corrente no Barramento 5V",
                        Componente = S_Code.sCOR,
                        Aferir = true,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.I2C,
                        },
                        DelayAmostragem = 500,
                        UnidadeMedida = "A",
                        Parametros = new List<string[]>()
                        {
                            new string[] { "Endereço I2C", "0x41" },
                            new string[] { "Corrente Max", "3.2" }
                        },
                    },
                    new SensorModel()
                    {
                        ID = "AB7V2",
                        Prioridade = 10,
                        Descricao = "Corrente no Barramento 7,2V",
                        Componente = S_Code.sCOR,
                        Aferir = true,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.I2C,
                        },
                        DelayAmostragem = 500,
                        UnidadeMedida = "A",
                        Parametros = new List<string[]>()
                        {
                            new string[] { "Endereço I2C", "0x44" },
                            new string[] { "CI", "219" }
                        },
                    },
                    new SensorModel()
                    {
                        ID = "AB12V",
                        Prioridade = 10,
                        Descricao = "Corrente no Barramento 12V",
                        Componente = S_Code.sCOR,
                        Aferir = true,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.I2C,
                        },
                        DelayAmostragem = 500,
                        UnidadeMedida = "A",
                        Parametros = new List<string[]>()
                        {
                            new string[] { "Endereço I2C", "0x40" },
                            new string[] { "Corrente Max", "100" }
                        },
                    },
                    new SensorModel()
                    {
                        ID = "TBAT",
                        Descricao = "Temperatura da bateria",
                        Prioridade = 5,
                        Componente = S_Code.sTMP,
                        Aferir = true,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.TMP,
                        },
                        DelayAmostragem = 500,
                        UnidadeMedida = "ºC",
                        Parametros = new List<string[]>()
                        {
                            new string[] { "V offset", "0.0000" },
                        },
                    },
                    /*new SensorModel()
                    {
                        ID = "SUESQ",
                        Descricao = "Sensor Ultrassom Esquerdo",
                        Prioridade = 2,
                        Componente = S_Code.sULT,
                        Aferir = true,
                        Inicializado = false,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.Echo,
                            FuncoesPinout.Trigger,
                        },
                        DelayAmostragem = 1000,
                        UnidadeMedida = "cm",
                        Parametros = new List<string[]>(),
                    },
                    new SensorModel()
                    {
                        ID = "SUDIR",
                        Descricao = "Sensor Ultrassom Direito",
                        Prioridade = 2,
                        Componente = S_Code.sULT,
                        Aferir = true,
                        Inicializado = false,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.Echo,
                            FuncoesPinout.Trigger,
                        },
                        DelayAmostragem = 1000,
                        UnidadeMedida = "cm",
                        Parametros = new List<string[]>(),
                    },
                    new SensorModel()
                    {
                        ID = "SMAG",
                        Descricao = "Sensor Magnetômetro",
                        Prioridade = 15,
                        Componente = S_Code.sMAG,
                        Aferir = true,
                        Inicializado = false,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.I2C,
                        },
                        DelayAmostragem = 500,
                        UnidadeMedida = "º",
                        Parametros = new List<string[]>(),
                    },
                    new SensorModel()
                    {
                        ID = "SNR_F",
                        Descricao = "Sensor Sonar Frontal",
                        Prioridade = 20,
                        Componente = S_Code.sSNR,
                        Aferir = true,
                        Inicializado = false,
                        Testando = false,
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.Echo,
                            FuncoesPinout.Trigger,
                            FuncoesPinout.ServoX,
                            FuncoesPinout.ServoY,
                        },
                        DelayAmostragem = 1000,
                        UnidadeMedida = "cm/º",
                        Parametros = new List<string[]>()
                        {
                            new string[] { "Angulo X Acrescentar", "5" },
                            new string[] { "Angulo Y Acrescentar", "30" },
                        },
                        LimiteMinimo = 40, 
                        LimiteMaximo = 9999,
                    },*/

                },
                Reles = new List<SensorReleModel>()
                {
                    new SensorReleModel()
                    {
                        ID = "RLLRA",
                        Descricao = "Relé modo operação LoRa",
                        Componente = S_Code.sRLE,
                        Controlar = true, 
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.Rele,
                        },
                        StatusControle = Estado.Desligado,
                    },
                },
                Servos = new List<SensorServoModel>()
                {
                    new SensorServoModel()
                    {
                        ID = "FRO_ET", 
                        Descricao = "Freio Motor ET", 
                        Componente = S_Code.sFRO, 
                        Controlar = true, 
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.ServoFreio,
                        },
                        _AnguloControle = 0,
                    },
                    new SensorServoModel()
                    {
                        ID = "FRO_EF",
                        Descricao = "Freio Motor EF",
                        Componente = S_Code.sFRO,
                        Controlar = false, 
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.ServoFreio,
                        },
                        _AnguloControle = 0,
                    },
                    new SensorServoModel()
                    {
                        ID = "FRO_DT",
                        Descricao = "Freio Motor DT",
                        Componente = S_Code.sFRO, 
                        Controlar = true, 
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.ServoFreio,
                        },
                        _AnguloControle = 0,
                    },
                    new SensorServoModel()
                    {
                        ID = "FRO_DF",
                        Descricao = "Freio Motor DF",
                        Componente = S_Code.sFRO,
                        Controlar = false, 
                        Funcoes = new List<FuncoesPinout>()
                        {
                            FuncoesPinout.ServoFreio,
                        },
                        _AnguloControle = 0,
                    },
                }
            };
        }

        public void LimparDados<T>(T _dados)
        {
            var Dados = _dados as SensoriamentoModel;
            Dados.Conectado = false;
            Dados.DadosLeitura = new SensoriamentoMensagemJsonModel();
            Dados.DadosLeitura.Momento = DateTime.MinValue;
            Dados.Reles.ForEach(x =>
            {
                x.StatusControle = Estado.Desligado;
            });
            Dados.Servos.ForEach(x =>
            {
                x._AnguloControle = 0;
            });

            ReiniciarLeituras(Dados);
        }

        public void ReiniciarLeituras(SensoriamentoModel Dados)
        {
            Dados.Reles.ForEach(x =>
            {
                x.Leitura = null;
            });
            Dados.Sinaleiros.ForEach(x =>
            {
                x.Leitura = null;
            });
            Dados.Sensores.ForEach(x =>
            {
                x.Leitura = null;
            });
            Dados.Servos.ForEach(x =>
            {
                x.Leitura = null;
            });
        }

        public Dictionary<string, List<string>> ProtocoloConfiguracao(bool Conectar)
        {
            // Inicializar o dicionário
            var configDictionary = new Dictionary<string, List<string>>() { { Modulo_ID, new List<string>() } };

            // Adicionar configurações dos Sensores que devem ser aferidos
            var sensoresConfig = SensoresConfig(Conectar);
            configDictionary[Modulo_ID].AddRange(sensoresConfig);

            // Adicionar configurações dos Sinaleiros
            var sinaleirosConfig = SinaleirosConfig(Conectar);
            configDictionary[Modulo_ID].AddRange(sinaleirosConfig);

            // Adicionar configurações dos Reles
            var relesConfig = RelesConfig(Conectar);
            configDictionary[Modulo_ID].AddRange(relesConfig);

            // Adicionar configurações dos Servos
            var servosConfig = ServosConfig(Conectar);
            configDictionary[Modulo_ID].AddRange(servosConfig);

            if (!Conectado || configDictionary.Any(x => x.Value.Count() > 0))
            {
                // Adicionar configuração do ProtocoloMOD
                var protocoloMOD = ModConfig(Conectar);
                configDictionary[Modulo_ID].Add(protocoloMOD);
            }

            return configDictionary;
        }

        private string ModConfig(bool Conectar)
        {
            string protocoloMOD =
                ((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
                ((int)T_Code.Mod).ToString() + SerialService.SplitParams +
                (Conectar ? "1" : "0") + SerialService.SplitParams +
                _TaxaAmostragem.ToString() + SerialService.SplitParams +
                (RequisitarDados ? "1" : "0") + SerialService.SplitParams +
                PinoutModel.PinoProtocolo(Pinout, Funcoes, SerialService.SplitParams);

            return protocoloMOD;
        }

        private string[] SensoresConfig(bool Conectar)
        {
            bool configurarTodos = (Sensores.Any(x => x.Aferir && x.Inicializado) && Sensores.Any(x => x.Aferir && !x.Inicializado));

            var sensoresConfig = Sensores
                .Where(x => x.Aferir && (configurarTodos ? true : x.Inicializado != Conectar))
                .GroupBy(x => x.Componente)
                .Select(x =>
                    ((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
                    ((int)T_Code.Sen).ToString() + SerialService.SplitParams +
                    ((int)x.Key).ToString() + SerialService.SplitParams +
                    string.Join(SerialService.SplitConfig, x.Select(y => y.ProtocoloConfiguracao(Pinout, Conectar)))
                ).ToArray();

            return sensoresConfig;
        }

        private string[] SinaleirosConfig(bool Conectar)
        {
            bool configurarTodos = (Sinaleiros.Any(x => x.Inicializado) && Sinaleiros.Any(x => !x.Inicializado));

            var sinaleirosConfig = Sinaleiros
                .Where(x => (configurarTodos ? true : x.Inicializado != Conectar))
                .GroupBy(x => x.Componente)
                .Select(x =>
                    ((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
                    ((int)T_Code.Sen).ToString() + SerialService.SplitParams +
                    ((int)x.Key).ToString() + SerialService.SplitParams +
                    string.Join(SerialService.SplitConfig, x.Select(y => y.ProtocoloConfiguracao(Pinout, Conectar)))
                ).ToArray();

            return sinaleirosConfig;
        }

        private string[] RelesConfig(bool Conectar)
        {
            bool configurarTodos = (Reles.Any(x => x.Controlar && x.Inicializado) && Reles.Any(x => x.Controlar && !x.Inicializado));

            var relesConfig = Reles
                .Where(x => x.Controlar && (configurarTodos ? true : x.Inicializado != Conectar))
                .GroupBy(x => x.Componente)
                .Select(x =>
                    ((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
                    ((int)T_Code.Sen).ToString() + SerialService.SplitParams +
                    ((int)x.Key).ToString() + SerialService.SplitParams +
                    string.Join(SerialService.SplitConfig, x.Select(y => y.ProtocoloConfiguracao(Pinout, Conectar)))
                ).ToArray();

            return relesConfig;
        }

        private string[] ServosConfig(bool Conectar)
        {
            bool configurarTodos = (Servos.Any(x => x.Controlar && x.Inicializado) && Servos.Any(x => x.Controlar && !x.Inicializado));

            var servosConfig = Servos
                .Where(x => x.Controlar && (configurarTodos ? true : x.Inicializado != Conectar))
                .GroupBy(x => x.Componente)
                .Select(x =>
                    ((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
                    ((int)T_Code.Sen).ToString() + SerialService.SplitParams +
                    ((int)x.Key).ToString() + SerialService.SplitParams +
                    string.Join(SerialService.SplitConfig, x.Select(y => y.ProtocoloConfiguracao(Pinout, Conectar)))
                ).ToArray();

            return servosConfig;
        }

        public string ProtocoloVerificacao(bool Completo)
        {
            if (Completo)
            {
                string ProtocoloCheck =
                    //SerialService.BeginLine +
                    "0" + SerialService.SplitMessage +
                    Modulo_ID + SerialService.SplitMessage +
                    ((int)F_Code.Chk).ToString() + SerialService.SplitMessage +
                    "check" +
                    SerialService.EndLine;

                return ProtocoloCheck;
            }
            else
            {
                string ProtocoloCheck = ((int)F_Code.Chk).ToString() + SerialService.SplitMessage + "check";

                return ProtocoloCheck;
            }
        }

        private string ProtocoloAquisicaoDados()
        {
            string ProtocoloReq = ((int)F_Code.Req).ToString() + SerialService.SplitMessage + "req";
            return ProtocoloReq;
        }

        public void RecebeProtocoloModulo(string Protocolo)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(Protocolo))
                {
                    Console.WriteLine("Protocolo recebido está vazio ou nulo.");
                    return;
                }

                Protocolo = Protocolo.Substring(0, Protocolo.Length - 1);

                // Valida se o protocolo possui um formato esperado
                if (Protocolo.Length <= 1 || !Protocolo.EndsWith("}"))
                {
                    Console.WriteLine("Protocolo recebido está em um formato inválido.");
                    return;
                }

                //Console.WriteLine($"JSON recebido: {Protocolo}");

                // Tenta desserializar o JSON
                var dadosLeitura = JsonConvert.DeserializeObject<SensoriamentoMensagemJsonModel>(Protocolo);
                if (dadosLeitura == null)
                {
                    Console.WriteLine("Falha ao desserializar o JSON.");
                    return;
                }

                dadosLeitura.Momento = DateTime.Now;
                
                AtualizaDadosComponentes(dadosLeitura);
            }
            catch (JsonException ex)
            {
                Console.WriteLine($"Erro ao processar o JSON recebido: {ex.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Erro inesperado no processamento do protocolo: {ex.Message}");
            }
        }

        private void AtualizaDadosComponentes(SensoriamentoMensagemJsonModel dadosLeitura)
        {
            DadosLeitura = dadosLeitura;

            DefineStatusConexao(Modulo_ID, true);




            if (Variaveis.OperacaoEmAndamento.DispMvd != null)
            {
                Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.ForEach(Modulo => Modulo.AtualizarSensoresMotor());
            }
        }

        public void DefineStatusConexao(string Mod_ID, bool conecatdo)
        {
            if (Mod_ID == Modulo_ID)
            {
                Conectado = conecatdo;
            }
        }

        public string GetTaxaAmostragem()
        {
            return _TaxaAmostragem.ToString("00000");
        }

        public void SetTaxaAmostragem(int TaxaAmostragem)
        {
            _TaxaAmostragem = TaxaAmostragem;
        }

        public bool GetStatusConexao()
        {
            Conectado = DadosLeitura.Conectado && DadosLeitura.Momento.AddMilliseconds(10 * _TaxaAmostragem) >= DateTime.Now;
            return Conectado;
        }

        public string GetIP()
        {
            return IP;
        }

        public void IniciarRegistrador()
        {
            if (!(tmrRegistrador?.IsRunning ?? false))
            {
                LimparDados(this);

                PararRegistrador();

                tmrRegistrador = new AsyncTaskTimerModel("tmrRegistrador_" + T_Code.Sen.ToString(), tmrRegistrador_Tick, _TaxaAmostragem);
                tmrRegistrador.Start();
            }
        }

        public void PararRegistrador()
        {
            tmrRegistrador?.Dispose();
        }

        public async Task tmrRegistrador_Tick()
        {
            if (Variaveis.OperacaoEmAndamento?.DispSen != null)
            {
                await Variaveis.OperacaoEmAndamento.DispSen.GerenciarMqttTopicos();
            }

            tmrRegistrador.SetInterval(_TaxaAmostragem);

            bool _conectado = DadosLeitura.Conectado && DadosLeitura.Momento.AddMilliseconds(TempoLimiteConexao * 2) >= DateTime.Now;
            DefineStatusConexao(Modulo_ID, _conectado);


            if (SerialService.DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Sen) && (_VezesLeituraReconexao >= _TempoReconexaoComponentes))
            {
                Variaveis.OperacaoEmAndamento.DispSen?.EnviarProtocolosConfiguracao();

                _VezesLeituraReconexao = 0;
            }
            else
            {
                _VezesLeituraReconexao++;
            }


            if (Conectado)
            {
                if (RequisitarDados)
                {
                    RequisitarDadosModulo();
                }

                VerificaControleLeitura();
            }
        }

        public void RequisitarDadosModulo()
        {
            if (Variaveis.OperacaoEmAndamento.DispSen != null)
            {
                string ProtocoloAquisicao = ProtocoloAquisicaoDados();
                Variaveis.OperacaoEmAndamento.DispSen.AdicionarMensagemFila(Modulo_ID, ProtocoloAquisicao, true, false);
            }
        }


        public (bool, List<string>) StatusModulosSEN()
        {
            var _Sensores = Sensores.Where(x => x.Aferir).ToList();
            var _SensoresComFalha = _Sensores.Where(x => !x.Inicializado).ToList();
            bool _sensoresOperantes = _SensoresComFalha.Count() < _Sensores.Count();

            var _Sinaleiros = Sinaleiros.ToList();
            var _SinaleirosComFalha = _Sinaleiros.Where(x => !x.Inicializado).ToList();
            bool _sinaleirosOperantes = !_SinaleirosComFalha.Any();

            var _Reles = Reles.Where(x => x.Controlar).ToList();
            var _RelesComFalha = _Reles.Where(x => !x.Inicializado).ToList();
            bool _relesOperantes = !_RelesComFalha.Any();

            var _Servos = Servos.Where(x => x.Controlar).ToList();
            var _ServosComFalha = _Servos.Where(x => !x.Inicializado).ToList();
            bool _servosOperantes = !_ServosComFalha.Any();

            bool _sensoriamentoOperante = _sensoresOperantes && _relesOperantes && _servosOperantes;
            List<string> ModsComFalha = 
                _SensoresComFalha.Select(x => x.ID)
                .Union(_SinaleirosComFalha.Select(x => x.ID))
                .Union(_RelesComFalha.Select(x => x.ID))
                .Union(_ServosComFalha.Select(x => x.ID))
                .ToList();

            return (_sensoriamentoOperante, ModsComFalha);
        }

        private void VerificaControleLeitura()
        {
            if (!frmDiagnosticos.Diagnosticando)
            {
                var ledOP = Sinaleiros.FirstOrDefault(x => x.ID == "LEDOP" && x.Inicializado);
                var ledAT = Sinaleiros.FirstOrDefault(x => x.ID == "LEDAT" && x.Inicializado);
                var ledMN = Sinaleiros.FirstOrDefault(x => x.ID == "LEDMN" && x.Inicializado);

                var comportamento = VariaveisEquipamento.ComportamentoPorStatus();
                if (ledOP != null && (!ledOP.Comportamento.Equals(comportamento) || (ledOP.LeituraComando != comportamento.statusLED)))
                {
                    GeneralJoystick.EnviarComandoSensoriamento(S_Code.sLED, ledOP.ID, comportamento);
                }

                var statusLedAt = Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.MapaGPS ? StatusLED.Aceso : StatusLED.Apagado;
                if (ledAT != null && (!ledAT.Comportamento.statusLED.Equals(statusLedAt) || (ledAT.LeituraComando != statusLedAt)))
                {
                    ledAT.Comportamento.statusLED = statusLedAt;
                    GeneralJoystick.EnviarComandoSensoriamento(S_Code.sLED, ledAT.ID, ledAT.Comportamento);
                }

                var statusLedMn = Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.Manual ? StatusLED.Aceso : StatusLED.Apagado;
                if (ledMN != null && (!ledMN.Comportamento.statusLED.Equals(statusLedMn) || (ledMN.LeituraComando != statusLedMn)))
                {
                    ledMN.Comportamento.statusLED = statusLedMn;
                    GeneralJoystick.EnviarComandoSensoriamento(S_Code.sLED, ledMN.ID, ledMN.Comportamento);
                }

                foreach (var rele in Reles.Where(x => x.Controlar && x.Inicializado))
                {
                    if (rele.StatusControle != rele.LeituraEstado)
                    {
                        GeneralJoystick.EnviarComandoSensoriamento(S_Code.sRLE, rele.ID, rele.StatusControle);
                    }
                }

                foreach (var servo in Servos.Where(x => x.Controlar && x.Inicializado))
                {
                    if (servo._AnguloControle != servo.LeituraAngulo)
                    {
                        GeneralJoystick.EnviarComandoSensoriamento(S_Code.sFRO, servo.ID, servo._AnguloControle);
                    }
                }
            }
        }

    }

    public class SensorModel
    {
        public string ID { get; set; }
        public int Prioridade { get; set; }
        public string Descricao { get; set; }
        public S_Code Componente { get; set; }
        public bool Aferir { get; set; } = false;
        public int DelayAmostragem { get; set; } = 500;
        private dynamic _leitura = null;
        public dynamic Leitura
        {
            get
            {
                switch (Componente)
                {
                    case S_Code.sTMP:
                        _leitura = Variaveis.OperacaoEmAndamento.DispSen?.Dados?.DadosLeitura?.SensoresTemperatura?.FirstOrDefault(x => x.ID == ID);
                        break;
                    case S_Code.sCOR:
                        _leitura = Variaveis.OperacaoEmAndamento.DispSen?.Dados?.DadosLeitura?.SensoresCorrente?.FirstOrDefault(x => x.ID == ID);
                        break;
                    case S_Code.sFLX:
                        _leitura = Variaveis.OperacaoEmAndamento.DispAtu?.Dados?.DadosLeitura?.SensoresFluxo?.FirstOrDefault(x => x.ID == ID);
                        break;
                    case S_Code.sPRS:
                        _leitura = Variaveis.OperacaoEmAndamento.DispAtu?.Dados?.DadosLeitura?.SensoresPressao?.FirstOrDefault(x => x.ID == ID);
                        break;
                    case S_Code.sMAS:
                        _leitura = Variaveis.OperacaoEmAndamento.DispAtu?.Dados?.DadosLeitura?.SensoresMassa?.FirstOrDefault(x => x.ID == ID);
                        break;
                    default:
                        _leitura = null;
                        break;
                }

                return _leitura;
            }
            set
            {
                _leitura = value;
            }
        }
        public bool Inicializado
        {
            get
            {
                return Leitura?.Iniciado ?? false;
            }
        }
        public bool Testando { get; set; } = false;
        public List<FuncoesPinout> Funcoes { get; set; }
        public List<string[]> Parametros { get; set;} = new List<string[]>();

        public string UnidadeMedida { get; set; }
        public double LimiteMaximo { get; set; }
        public double LimiteMinimo { get; set; }

        public List<SenSensorimanetoGrafico> LogGrafico = new List<SenSensorimanetoGrafico>();

        public string ProtocoloConfiguracao(PinoutDataModel Pinout, bool Conectar)
        {
            var _pinout = new PinoutDataModel()
            {
                ExpansorGPIO = Pinout.ExpansorGPIO, 
                EnderecoExpansor = Pinout.EnderecoExpansor, 
                Pinos = Pinout.Pinos.ToList(), 
            };
            _pinout.Pinos = _pinout.Pinos.Where(x => x.ComponenteID == ID).ToList();
            string Protocolo =
                ID + SerialService.SplitSubParams +
                (Conectar ? "1" : "0") + SerialService.SplitSubParams +
                PinoutModel.PinoProtocolo(_pinout, Funcoes, SerialService.SplitSubParams);
            foreach (var Parametro in Parametros)
            {
                Protocolo += SerialService.SplitSubParams + Parametro[1];
            }
            return Protocolo;
        }
    }

    public class SensorSinaleiroModel
    {
        public string ID { get; set; }
        public string Descricao { get; set; }
        public S_Code Componente { get; set; }
        public List<FuncoesPinout> Funcoes { get; set; }
        public SensorSinaleiroComportamentoModel Comportamento { get; set; }
        private FirmwareSinaleiro _leitura = null;
        public FirmwareSinaleiro Leitura
        {
            get
            {
                _leitura = Variaveis.OperacaoEmAndamento.DispSen?.Dados?.DadosLeitura?.Sinaleiros?.FirstOrDefault(x => x.ID == ID);
                return _leitura;
            }
            set
            {
                _leitura = value;
            }
        }
        public bool Inicializado
        {
            get
            {
                return Leitura?.Iniciado ?? false;
            }
        }
        public StatusLED LeituraComando
        {
            get
            {
                return Leitura?.Comando ?? StatusLED.Apagado;
            }
        }
        public StatusLED LeituraStatus
        {
            get
            {
                return Leitura?.Leitura ?? StatusLED.Apagado;
            }
        }

        public string ProtocoloConfiguracao(PinoutDataModel Pinout, bool Conectar)
        {
            var _pinout = new PinoutDataModel()
            {
                ExpansorGPIO = Pinout.ExpansorGPIO,
                EnderecoExpansor = Pinout.EnderecoExpansor, 
                Pinos = Pinout.Pinos.ToList(), 
            };
            _pinout.Pinos = _pinout.Pinos.Where(x => x.ComponenteID == ID).ToList();
            string Protocolo = 
                ID + SerialService.SplitSubParams +
                (Conectar ? "1" : "0") + SerialService.SplitSubParams +
                PinoutModel.PinoProtocolo(_pinout, Funcoes, SerialService.SplitSubParams);
            return Protocolo;
        }

        public string ProtocoloComando()
        {
            string ProtocoloSinaleiro =
                    ((int)F_Code.Cmd).ToString() + SerialService.SplitMessage + 
                    ID + SerialService.SplitParams +
                    ((int)Componente) + SerialService.SplitParams +
                    (int)Comportamento.statusLED + SerialService.SplitParams +
                    Comportamento.QtdPiscadas.ToString() + SerialService.SplitParams +
                    Comportamento.TempoMs.ToString() + SerialService.SplitParams +
                    Comportamento.PausaMs.ToString();

            return ProtocoloSinaleiro;
        }

    }

    public class SensorReleModel
    {
        public string ID { get; set; }
        public string Descricao { get; set; }
        public S_Code Componente { get; set; }
        public List<FuncoesPinout> Funcoes { get; set; }

        public bool Controlar { get; set; }
        public bool AtuacaoNivelAlto { get; set; }
        public Estado StatusControle { get; set; }
        private FirmwareRele _leitura = null;
        public FirmwareRele Leitura
        {
            get
            {
                _leitura = Variaveis.OperacaoEmAndamento.DispSen?.Dados?.DadosLeitura?.Reles?.FirstOrDefault(x => x.ID == ID);
                return _leitura;
            }
            set
            {
                _leitura = value;
            }
        }
        public bool Inicializado
        {
            get
            {
                return Leitura?.Iniciado ?? false;
            }
        }
        public Estado LeituraEstado
        {
            get
            {
                return Leitura?.Leitura ?? Estado.Desligado;
            }
        }

        public string ProtocoloConfiguracao(PinoutDataModel Pinout, bool Conectar)
        {
            var _pinout = new PinoutDataModel()
            {
                ExpansorGPIO = Pinout.ExpansorGPIO,
                EnderecoExpansor = Pinout.EnderecoExpansor,
                Pinos = Pinout.Pinos.ToList(),
            };
            _pinout.Pinos = _pinout.Pinos.Where(x => x.ComponenteID == ID).ToList();
            string Protocolo = 
                ID + SerialService.SplitSubParams +
                (Conectar ? "1" : "0") + SerialService.SplitSubParams +
                (AtuacaoNivelAlto ? "1" : "0") + SerialService.SplitSubParams +
                PinoutModel.PinoProtocolo(_pinout, Funcoes, SerialService.SplitSubParams);
            return Protocolo;
        }

        public string ProtocoloComando()
        {
            string ProtocoloRele =
                    ((int)F_Code.Cmd).ToString() + SerialService.SplitMessage +
                    ID + SerialService.SplitParams +
                    ((int)Componente) + SerialService.SplitParams +
                    (int)StatusControle;

            return ProtocoloRele;
        }

    }

    public class SensorServoModel
    {
        public string ID { get; set; }
        public string Descricao { get; set; }
        public S_Code Componente { get; set; }
        public List<FuncoesPinout> Funcoes { get; set; }

        public bool Controlar { get; set; }
        public int _AnguloControle { get; set; }
        private FirmwareServoFreio _leitura = null;
        public FirmwareServoFreio Leitura
        {
            get
            {
                _leitura = Variaveis.OperacaoEmAndamento.DispSen?.Dados?.DadosLeitura?.ServoFreios?.FirstOrDefault(x => x.ID == ID);
                return _leitura;
            }
            set
            {
                _leitura = value;
            }
        }
        public bool Inicializado
        {
            get
            {
                return Leitura?.Iniciado ?? false;
            }
        }
        public double LeituraAngulo
        {
            get
            {
                return Leitura?.Angulo ?? 0;
            }
        }

        public string ProtocoloConfiguracao(PinoutDataModel Pinout, bool Conectar)
        {
            var _pinout = new PinoutDataModel()
            {
                ExpansorGPIO = Pinout.ExpansorGPIO,
                EnderecoExpansor = Pinout.EnderecoExpansor,
                Pinos = Pinout.Pinos.ToList(),
            };

            bool incremental = true;
            var freio = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.FirstOrDefault(x => ID.Contains(x.Modulo_ID));
            if (freio != null)
            {
                incremental = freio.MovMotor.ConfigFreio.Incremental;
            }

            _pinout.Pinos = _pinout.Pinos.Where(x => x.ComponenteID == ID).ToList();
            string Protocolo = 
                ID + SerialService.SplitSubParams +
                (Conectar ? "1" : "0") + SerialService.SplitSubParams +
                (incremental ? "1" : "0") + SerialService.SplitSubParams +
                PinoutModel.PinoProtocolo(_pinout, Funcoes, SerialService.SplitSubParams);
            return Protocolo;
        }

        public string ProtocoloComando()
        {
            string ProtocoloFreio =
                    ((int)F_Code.Cmd).ToString() + SerialService.SplitMessage +
                    ID + SerialService.SplitParams +
                    ((int)Componente) + SerialService.SplitParams +
                    _AnguloControle;

            return ProtocoloFreio;
        }

    }


    public class SensorSinaleiroComportamentoModel
    {
        public StatusLED statusLED { get; set; }
        public int QtdPiscadas { get; set; } = 0;
        public int TempoMs { get; set; } = 0;
        public int PausaMs { get; set; } = 0;

        public override bool Equals(object obj)
        {
            if (obj == null || GetType() != obj.GetType())
            {
                return false;
            }

            SensorSinaleiroComportamentoModel other = (SensorSinaleiroComportamentoModel)obj;
            return statusLED == other.statusLED &&
                   QtdPiscadas == other.QtdPiscadas &&
                   TempoMs == other.TempoMs &&
                   PausaMs == other.PausaMs;
        }

        public override int GetHashCode()
        {
            unchecked // Permite overflow de inteiros
            {
                int hash = 17;
                hash = hash * 23 + statusLED.GetHashCode();
                hash = hash * 23 + QtdPiscadas.GetHashCode();
                hash = hash * 23 + TempoMs.GetHashCode();
                hash = hash * 23 + PausaMs.GetHashCode();
                return hash;
            }
        }

        public static bool operator ==(SensorSinaleiroComportamentoModel left, SensorSinaleiroComportamentoModel right)
        {
            if (ReferenceEquals(left, right))
            {
                return true;
            }

            if ((object)left == null || (object)right == null)
            {
                return false;
            }

            return left.Equals(right);
        }

        public static bool operator !=(SensorSinaleiroComportamentoModel left, SensorSinaleiroComportamentoModel right)
        {
            return !(left == right);
        }
    }

    public class SenSensorimanetoGrafico
    {
        public DateTime Momento { get; set; }
        public string ComponenteID { get; set; }
        public S_Code Componente { get; set; }
        public double Leitura1 { get; set; }
        public double Leitura2 { get; set; }
        public double Leitura3 { get; set; }
        public double Leitura4 { get; set; }
        public bool AlarmeMaxima { get; set; }
        public bool AlarmeMinima { get; set; }
    }

 

    public class FirmwareSensorTemperatura
    {
        public string ID { get; set; }
        private bool _iniciado = false;
        public bool Iniciado
        {
            get
            {
                if (Variaveis.OperacaoEmAndamento.DispSen.Dados.DadosLeitura.Momento.AddMilliseconds(SensoriamentoModel.TempoLimiteConexao) < DateTime.Now)
                {
                    _iniciado = false;
                }
                return _iniciado;
            }
            set
            {
                _iniciado = value;
            }
        }
        private int _leitura;
        public int Leitura
        {
            get { return _leitura; }
            set
            {
                _leitura = value;
                AtualizarTemperatura();
            }
        }
        private double _atual;
        public double Temperatura { get { return _atual; } }
        public double ValorMaximo { get; set; }
        public double ValorMinimo { get; set; }
        public double LimiteMaximo
        {
            get
            {
                var sensor = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == ID);
                if (sensor != null)
                {
                    return sensor.LimiteMaximo;
                }
                return 0;
            }
        }
        public double LimiteMinimo
        {
            get
            {
                var sensor = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == ID);
                if (sensor != null)
                {
                    return sensor.LimiteMinimo;
                }
                return 0;
            }
        }

        private KalmanFilter filtroKalman = new KalmanFilter(erroMedicao: 1.0, erroProcesso: 0.05);

        private void AtualizarTemperatura()
        {
            if (Variaveis.OperacaoEmAndamento.DispSen != null)
            {
                SensorModel Sensor = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == ID);
                if (Sensor != null && Sensor.Parametros.Count > 0 && Sensor.Parametros[0].Length > 1)
                {
                    if (double.TryParse(Sensor.Parametros[0][1].Replace(".", ","), out double fatorCalibracao))
                    {
                        double temperaturaAtual = FuncoesMatematicas.CalcularTemperatura(_leitura, fatorCalibracao);

                        _atual = filtroKalman.Filtrar(temperaturaAtual);

                        AtualizarExtremos();
                    }
                    else
                    {
                        Console.WriteLine($"Erro ao converter o parâmetro de calibração para o sensor {ID}");
                    }
                }
            }
        }

        private void AtualizarExtremos()
        {
            if (_atual > ValorMaximo)
            {
                ValorMaximo = _atual;
            }
            if (_atual < ValorMinimo || ValorMinimo == 0)
            {
                ValorMinimo = _atual;
            }
        }
    }

    public class FirmwareSensorCorrente
    {
        public string ID { get; set; }
        private bool _iniciado = false;
        public bool Iniciado
        {
            get
            {
                if (Variaveis.OperacaoEmAndamento.DispSen.Dados.DadosLeitura.Momento.AddMilliseconds(SensoriamentoModel.TempoLimiteConexao) < DateTime.Now)
                {
                    _iniciado = false;
                }
                return _iniciado;
            }
            set
            {
                _iniciado = value;
            }
        }
        public double BusVoltage { get; set; }
        public double ShuntVoltage { get; set; }
        public double? Current 
        { 
            get
            {
                return _atual;
            }
            set
            {
                _atual = value ?? 0;

                AtualizarExtremos();
            }
        }
        public double Power { get; set; }

        public double ValorMaximo { get; set; }
        public double ValorMinimo { get; set; }
        public double LimiteMaximo
        {
            get
            {
                var sensor = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == ID);
                if (sensor != null)
                {
                    return sensor.LimiteMaximo;
                }
                return 0;
            }
        }
        public double LimiteMinimo
        {
            get
            {
                var sensor = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == ID);
                if (sensor != null)
                {
                    return sensor.LimiteMinimo;
                }
                return 0;
            }
        }


        private double _atual = 0;
        private void AtualizarExtremos()
        {
            if (_atual > ValorMaximo)
            {
                ValorMaximo = _atual;
            }
            if (_atual < ValorMinimo || ValorMinimo == 0)
            {
                ValorMinimo = _atual;
            }
        }
    }

    public class FirmwareSinaleiro
    {
        public string ID { get; set; }
        private bool _iniciado = false;
        public bool Iniciado
        {
            get
            {
                if (Variaveis.OperacaoEmAndamento.DispSen.Dados.DadosLeitura.Momento.AddMilliseconds(SensoriamentoModel.TempoLimiteConexao) < DateTime.Now)
                {
                    _iniciado = false;
                }
                return _iniciado;
            }
            set
            {
                _iniciado = value;
            }
        }
        public StatusLED Leitura { get; set; }
        public StatusLED Comando { get; set; }
    }

    public class FirmwareRele
    {
        public string ID { get; set; }
        private bool _iniciado = false;
        public bool Iniciado
        {
            get
            {
                if (Variaveis.OperacaoEmAndamento.DispSen.Dados.DadosLeitura.Momento.AddMilliseconds(SensoriamentoModel.TempoLimiteConexao) < DateTime.Now)
                {
                    _iniciado = false;
                }
                return _iniciado;
            }
            set
            {
                _iniciado = value;
            }
        }
        public Estado Leitura { get; set; }
    }

    public class FirmwareServoFreio
    {
        public string ID { get; set; }
        private bool _iniciado = false;
        public bool Iniciado
        {
            get
            {
                if (Variaveis.OperacaoEmAndamento.DispSen.Dados.DadosLeitura.Momento.AddMilliseconds(SensoriamentoModel.TempoLimiteConexao) < DateTime.Now)
                {
                    _iniciado = false;
                }
                return _iniciado;
            }
            set
            {
                _iniciado = value;
            }
        }
        public int Angulo { get; set; }
    }

    public class FirmwareSensorFluxo
    {
        public string ID { get; set; }
        private bool _iniciado = false;
        public bool Iniciado
        {
            get
            {
                if (Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.Momento.AddMilliseconds(SensoriamentoModel.TempoLimiteConexao) < DateTime.Now)
                {
                    _iniciado = false;
                }
                return _iniciado;
            }
            set
            {
                _iniciado = value;
            }
        }
        public int Pulsos { get; set; }
        private int _periodo;
        public int Periodo
        {
            get
            {
                return _periodo;
            }
            set
            {
                _periodo = value;
                AtualizarVazao();
            }
        }
        private double _atual;
        public double Vazao { get { return _atual; } }
        public double ValorMaximo { get; set; }
        public double ValorMinimo { get; set; }
        public double LimiteMaximo
        {
            get
            {
                var sensor = Variaveis.OperacaoEmAndamento.DispAtu.Dados.Sensores.FirstOrDefault(x => x.ID == ID);
                if (sensor != null)
                {
                    return sensor.LimiteMaximo;
                }
                return 0;
            }
        }
        public double LimiteMinimo
        {
            get
            {
                var sensor = Variaveis.OperacaoEmAndamento.DispAtu.Dados.Sensores.FirstOrDefault(x => x.ID == ID);
                if (sensor != null)
                {
                    return sensor.LimiteMinimo;
                }
                return 0;
            }
        }

        private void AtualizarVazao()
        {
            //_atual = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VazaoFluxoMLpS;
            if (Periodo == 0)
            {
                _atual = 0;
            }
            else
            {
                double Frequencia = ((double)Pulsos / (double)Periodo * 1000);
                //double vazao = (_LeituraPulsos * FatorLeitura) / ((double)_LeituraPeriodo / 1000);
                //double vazao = ((double)1 / FatorLeitura) * (60 * 1000 / _LeituraPeriodo);
                //double vazao = ((double)_LeituraPulsos / (((double)_LeituraPeriodo / 1000) * 8.1)) + 3;
                //double Fator = (double)_LeituraPulsos / (double)_LeituraPeriodo;

                //double vazao = ((double)_LeituraPulsos / (double)_LeituraPeriodo * 1000) * ;

                //double vazao = Frequencia * 1.22;

                double Rh = 0.0047;
                double Rt = 0.0037;
                double vazao = (Frequencia * 2 * Math.PI * Rh * Math.PI * (Rt * Rt)) * 1000000;

                Console.WriteLine("Pulsos: " + Pulsos + " - Periodo: " + Periodo + " ms - Vazão: " + vazao.ToString("0.00000"));

                _atual = vazao;
            }
            AtualizarExtremos();
        }

        private void AtualizarExtremos()
        {
            if (_atual > ValorMaximo)
            {
                ValorMaximo = _atual;
            }
            if (_atual < ValorMinimo || ValorMinimo == 0)
            {
                ValorMinimo = _atual;
            }
        }

    }

    public class FirmwareSensorMassa
    {
        public string ID { get; set; }
        private bool _iniciado = false;
        public bool Iniciado
        {
            get
            {
                if (Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.Momento.AddMilliseconds(SensoriamentoModel.TempoLimiteConexao) < DateTime.Now)
                {
                    _iniciado = false;
                }
                return _iniciado;
            }
            set
            {
                _iniciado = value;
            }
        }
        private double _leitura;
        public double Leitura
        {
            get { return _leitura; }
            set
            {
                _leitura = value;
                AtualizarMassa();
            }
        }
        private double _atual;
        public double Massa { get { return _atual; } }
        public double ValorMaximo { get; set; }
        public double ValorMinimo { get; set; }
        public double LimiteMaximo
        {
            get
            {
                var sensor = Variaveis.OperacaoEmAndamento.DispAtu.Dados.Sensores.FirstOrDefault(x => x.ID == ID);
                if (sensor != null)
                {
                    return sensor.LimiteMaximo;
                }
                return 0;
            }
        }
        public double LimiteMinimo
        {
            get
            {
                var sensor = Variaveis.OperacaoEmAndamento.DispAtu.Dados.Sensores.FirstOrDefault(x => x.ID == ID);
                if (sensor != null)
                {
                    return sensor.LimiteMinimo;
                }
                return 0;
            }
        }

        private void AtualizarMassa()
        {
            if (Variaveis.OperacaoEmAndamento.DispAtu !=  null)
            {
                double leituraMassa = _leitura * -1;
                leituraMassa += Variaveis.OperacaoEmAndamento.DispAtu.Dados._MassaLeituraExtra;

                double FatorLeitura = Variaveis.OperacaoEmAndamento.DispAtu.Dados._MassaRef / Variaveis.OperacaoEmAndamento.DispAtu.Dados._MassaLeituraRef;
                _atual = FatorLeitura * leituraMassa;

                AtualizarExtremos();
            }
        }

        private void AtualizarExtremos()
        {
            if (_atual > ValorMaximo)
            {
                ValorMaximo = _atual;
            }
            if (_atual < ValorMinimo || ValorMinimo == 0)
            {
                ValorMinimo = _atual;
            }
        }

    }

    public class FirmwareSensorPressao
    {
        public string ID { get; set; }
        private bool _iniciado = false;
        public bool Iniciado
        {
            get
            {
                if (Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.Momento.AddMilliseconds(SensoriamentoModel.TempoLimiteConexao) < DateTime.Now)
                {
                    _iniciado = false;
                }
                return _iniciado;
            }
            set
            {
                _iniciado = value;
            }
        }
        public double Leitura { get; set; }
        public double Pressao { get; set; }
    }


    public class SensoriamentoMensagemJsonModel
    {
        public DateTime Momento { get; set; }
        public bool Conectado { get; set; }
        public string Mod_ID { get; set; }
        public int QualidadeWifi { get; set; }
        public int LatenciaLoop { get; set; }
        public List<FirmwareSensorTemperatura> SensoresTemperatura { get; set; } = new List<FirmwareSensorTemperatura>();
        public List<FirmwareSensorCorrente> SensoresCorrente { get; set; } = new List<FirmwareSensorCorrente>();
        public List<FirmwareSinaleiro> Sinaleiros { get; set; } = new List<FirmwareSinaleiro>();
        public List<FirmwareRele> Reles { get; set; } = new List<FirmwareRele>();
        public List<FirmwareServoFreio> ServoFreios { get; set; } = new List<FirmwareServoFreio>();
        public DateTime UltimoComandoRespondido { get; set; }
    }

}