using AgroBase.Comum;
using AgroBase.Forms.Operacoes;
using AgroBase.Models.Modules;
using AgroBase.Models.Operacoes;
using AgroBase.Services;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using static AgroBase.Models.Enums;
using System.Drawing;
using System.Text;
using static AgroBase.Services.OIDCanService.OidHandler;
using AgroBase.Models.Operadores;
using AgroBase.Services.Operadores;
using AgroMonitor;
using Newtonsoft.Json.Linq;

namespace AgroBase.Models
{
    public class OperacaoModel
    {

        public OperacaoModel(ModoOperacao Modo) 
        {
            this.Modo = Modo;

            if (Variaveis.OperacaoEmAndamento != null)
            {
                tmrLogs?.Dispose();
                tmrLogs = new AsyncTaskTimerModel("tmrLogs", tmrLogs_Tick, 1000);

                tmrLeituras?.Dispose();
                tmrLeituras = new AsyncTaskTimerModel("tmrLeitura", tmrLeituras_Tick, 500);
                tmrLeituras.Start();

                tmrComunicacao?.Dispose();
                tmrComunicacao = new AsyncTaskTimerModel("tmrComunicacao", tmrComunicacao_Tick, 1000);
                tmrComunicacao.Start();
            }
        }

        

        public ModoOperacao Modo { get; set; }
        public StatusModulo Status { get; set; }
        public string Descricao { get; set; }
        public string OprPath { get; set; }
        public OperacaoControleModel Controle { get; set; } = new OperacaoControleModel();
        public OperacaoControleModel ControleAnterior { get; set; } = new OperacaoControleModel();
        public DispositivosService<MovimentacaoUnificadaModel> DispMvd { get; set; }
        public DispositivosService<SensoriamentoModel> DispSen { get; set; }
        public DispositivosService<AtuadorModel> DispAtu { get; set; }
        public MapasModel Mapa { get; set; } = new MapasModel();
        public TrajetoriaMapaOperacaoModel Trajetoria { get; set; }
        public List<GPSModel> GPSTrajetoria { get; set; } = new List<GPSModel>();
        public OperacaoParametrosModel Parametros { get; set; } = new OperacaoParametrosModel();
        public OperacaoSensoriamentoLogModel Sensoriamento { get; set; } = new OperacaoSensoriamentoLogModel();
        public PerformanceModel DadosPerformance { get; set; } = new PerformanceModel();
        public Form frmOperacao { get; set; }

        #region STATUS DE CONTEXTO
        public StatusOperacao StatusAtual { get; private set; } = StatusOperacao.NaoIniciado;
        public StatusOperacao StatusAnterior { get; private set; } = StatusOperacao.NaoIniciado;
        public bool Emergencia { get; set; } = false;
        public bool Pausa { get; set; } = false;
        public bool OperacaoLiberada { get; private set; } = false;
        public bool OperacaoConfigurada { get; private set; } = false;
        public string ErroOperacaoLiberada { get; set; }
        public DateTime TempoAguardando { get; private set; } = DateTime.Now;
        public double TempoAguardandoSegs => (TempoAguardando.AddSeconds(TempoIniciarOperacao) - DateTime.Now).TotalSeconds;
        public bool Iniciado { get; set; }
        public bool Finalizando { get; set; } = false;
        public bool Calibrando { get; set; } = false;
        public DateTime DataInicio { get; set; } = DateTime.MinValue;
        public DateTime DataFim { get; set; } = DateTime.MinValue;
        public double TempoDecorridoSegs
        {
            get
            {
                return (StatusAtual == StatusOperacao.Parametrizando ? 0 : ((Variaveis.OperacaoEmAndamento.DataFim != DateTime.MinValue ? Variaveis.OperacaoEmAndamento.DataFim : DateTime.Now) - Variaveis.OperacaoEmAndamento.DataInicio).TotalSeconds);
            }
        }

        public void AtualizarDadosContexto()
        {
            HealthWorkerService.AtualizarDadosContexto();

            Variaveis.OperacaoEmAndamento.StatusAtual = (StatusOperacao)RedisService.GetField<int>(CtxKey.DadosOperacao, "status", 0);
            Variaveis.OperacaoEmAndamento.OperacaoLiberada = RedisService.GetField(CtxKey.DadosOperacao, "liberado", false);
            Variaveis.OperacaoEmAndamento.OperacaoConfigurada = RedisService.GetField(CtxKey.DadosOperacao, "configurado", false);
            Variaveis.OperacaoEmAndamento.Controle.Motivos = RedisService.GetField<List<string>>(CtxKey.DadosControle, "motivos", new List<string>());
            var tempoAguardando = RedisService.GetField<long>(CtxKey.DadosOperacao, "tempo_aguardando", 0);
            Variaveis.OperacaoEmAndamento.TempoAguardando = DateTimeOffset.FromUnixTimeSeconds(tempoAguardando).UtcDateTime.AddSeconds(tempoAguardando % 1).ToLocalTime();
            Variaveis.OperacaoEmAndamento.ErroOperacaoLiberada = RedisService.GetField<string>(CtxKey.DadosOperacao, "motivo_nao_liberado");
            GPSService.CorrecaoRTK_Ntrip = RedisService.GetField<bool>(RedisService.ModKey(T_Code.Gps), "correcao_ntrip", false);

            if (Variaveis.OperacaoEmAndamento.StatusAtual != Variaveis.OperacaoEmAndamento.StatusAnterior)
            {
                AudioAlertaService.AlertaSonoroPorStatus(Variaveis.OperacaoEmAndamento.StatusAtual);
            }

            Variaveis.OperacaoEmAndamento.StatusAnterior = Variaveis.OperacaoEmAndamento.StatusAtual;

            List<ManagerWorkerMessageResponseModulosPendentesModel> saudeAnterior = new List<ManagerWorkerMessageResponseModulosPendentesModel>(HealthWorkerService.ModulosSaude ?? new List<ManagerWorkerMessageResponseModulosPendentesModel>());
            HealthWorkerService.ModulosSaude = RedisService.GetField<ManagerWorkerMessageResponseModulosPendentesModel[]>(CtxKey.DadosOperacao, "status_modulos").ToList();

            foreach (var mod in HealthWorkerService.ModulosSaude)
            {
                var mod_ant = saudeAnterior.FirstOrDefault(x => x.modulo == mod.modulo);
                if (mod.status != mod_ant?.status)
                {
                    string msg = mod.motivos.Any() ? string.Join("; ", mod.motivos) : $"{mod.status} ({mod.saude:0}%)";
                    string msg2 = mod.condicoes_operacionais.Any() ? string.Join("; ", mod.condicoes_operacionais.Select(x => x.descricao)) : null;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.InserirLog(mod.modulo, mod.status, mod.saude, msg, condicoes: msg2);
                }
                if (mod.saude_individual.Any())
                {
                    foreach (var ind  in mod.saude_individual)
                    {
                        var ind_ant = saudeAnterior.FirstOrDefault(x => x.modulo == mod.modulo && x.saude_individual.Any(y => y.id == ind.id))?.saude_individual?.FirstOrDefault(x => x.id == ind.id);
                        if (ind.status != ind_ant?.status)
                        {
                            string msg = ind.motivos.Any() ? string.Join("; ", ind.motivos) : $"{ind.status} ({ind.saude:0}%)";
                            string msg2 = ind.condicoes_operacionais.Any() ? string.Join("; ", ind.condicoes_operacionais.Select(x => x.descricao)) : null;
                            Variaveis.OperacaoEmAndamento.Sensoriamento.InserirLog(mod.modulo, ind.status, ind.saude, msg, condicoes: msg2, id: ind.label);
                        }
                    }
                }
            }

            double saude_geral = HealthWorkerService.ModulosSaude.DefaultIfEmpty().Average(x => x?.saude ?? 0);
            Variaveis.OperacaoEmAndamento.Status = 
                !Variaveis.OperacaoEmAndamento.OperacaoLiberada ? StatusModulo.Falha :
                saude_geral <= 0.0 ? StatusModulo.Desconectado :
                saude_geral < 80.0 ? StatusModulo.Alerta :
                StatusModulo.Operante;

            SerialService.DispositivosMapeados.ForEach(d => d.AtualizarDados());
        }

        

        #endregion


        public bool Treinando { get; set; } = false;
        public bool Simulando { get; set; } = false;
        public double SimulacaoAnguloControle { get; set; } = 0;
        public double SimulacaoRpmControle { get; set; } = 0;

        public Dictionary<T_Code, Dictionary<string, bool>> ModsCalibragem { get; set; } = new Dictionary<T_Code, Dictionary<string, bool>>();
        

        //public List<OperacaoModulosMandatoriosModel> ModulosMandatorios { get; set; } = new List<OperacaoModulosMandatoriosModel>();
        //public List<OperacaoParametrosMandatoriosModel> ParametrosMandatorios { get; set; } = new List<OperacaoParametrosMandatoriosModel>();
        public int TempoIniciarOperacao { get; set; } = 10;
        public string ID { get; set; }
        public double tmrLogsInterval
        {
            get
            {
                return tmrLogs.Interval;
            }
            set
            {
                tmrLogs.SetInterval((int)value);
            }
        }
        private static AsyncTaskTimerModel tmrLogs;
        public double tmrLeiturasInterval
        {
            get
            {
                return tmrLeituras.Interval;
            }
            set
            {
                tmrLeituras.SetInterval((int)value);
            }
        }
        private static AsyncTaskTimerModel tmrLeituras;
        private static AsyncTaskTimerModel tmrComunicacao;



        #region PARAMETRIZACAO

        public bool SalvarParametrizacaoOperacao(
            string descricao, 
            double capacidadeReservatorio, 
            double pressaoLinha, 
            int duracaoAtuacao, 
            int percentualAtuacao, 
            int anguloMaximo, 
            int velocidadeMovimento, 
            int velocidadeServasPercent, 
            int velocidadeCervasPercent, 
            UltrasonicA05Configuracoes ConfigUltrassom, 
            bool sonarAtivado, 
            int qtdCamerasSolo, 
            TiposControladorDirecional tipoControleDirecional,
            bool movimentoAutomatico, 
            bool direcionalAutomatico,
            bool pulverizadorAutomatico,
            bool frenagemAutomatica)
        {
            if (string.IsNullOrEmpty(descricao))
            {
                MessageBox.Show("Preencha a descrição para identificação da operação!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return false;
            }

            if (Variaveis.OperacaoEmAndamento.Parametros.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && x.Mandatorio) && string.IsNullOrEmpty(Variaveis.OperacaoEmAndamento.Mapa?.mapaService?.CaminhoMapa) && !(Variaveis.OperacaoEmAndamento.Mapa?.RuasPercorrer ?? new List<string>()).Any())
            {
                MessageBox.Show("Selecione o mapa da operação e selecione as ruas a serem percorridas!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return false;
            }

            OperacaoParametrosModel Parametros = new OperacaoParametrosModel()
            {
                Modo = Variaveis.OperacaoEmAndamento.Modo,
                Descricao = descricao,
                CapacidadeReservatorio = capacidadeReservatorio,
                Controle = new OperacaoParametrosControleModel()
                {
                    SonarAtivado = sonarAtivado,
                    MovimentoAutomatico = movimentoAutomatico,
                    DirecionalAutomatico = direcionalAutomatico,
                    PulverizadorAutomatico = pulverizadorAutomatico,
                    FrenagemAutomaticaAoParar = frenagemAutomatica,
                    AtuDuracaoAtuacao = duracaoAtuacao,
                    AtuPercentualInicioPulverizacao = percentualAtuacao,
                    AtuPressaoLinha = pressaoLinha,
                    DirAnguloMaximo = anguloMaximo,
                    DirVelocidadeMovimento = velocidadeMovimento,
                    DirTipoMovimento = tipoControleDirecional,
                    MovVelocidadeCErvasPercent = velocidadeCervasPercent,
                    MovVelocidadeSErvasPercent = velocidadeServasPercent,
                },
                
                ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>(Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios),
                ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>(Variaveis.OperacaoEmAndamento.Parametros.ParametrosMandatorios), 
                //Mapa = Variaveis.OperacaoEmAndamento.Mapa, 
                //ConfiguracaoUltrassom = ConfigUltrassom,
                
                QtdCamerasSolo = qtdCamerasSolo,
                
            };
            //Parametros.Mapa.LimparDados(true);

            string ParametrosJson = JsonConvert.SerializeObject(Parametros, Formatting.None);
            SaveFileDialog saveFileDialog = new SaveFileDialog();
            saveFileDialog.Filter = "Arquivo de Operação (*.opr)|*.opr";
            saveFileDialog.DefaultExt = "opr";
            saveFileDialog.AddExtension = true;
            saveFileDialog.InitialDirectory = Variaveis.CaminhoSistema + Variaveis.CaminhoOperacoes;
            saveFileDialog.FileName = descricao;
            if (saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                string filePath = saveFileDialog.FileName;

                File.WriteAllText(filePath, ParametrosJson, Encoding.UTF8);

                MessageBox.Show("Operação salva com sucesso!", "Sucesso", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }

            return true;
        }

        public (bool, List<string>) CarregarParametrizacaoOperacao(Panel pnlMapa, Label lblMapa, string opPath = "")
        {
            string path = Variaveis.CaminhoSistema + Variaveis.CaminhoOperacoes + MapasVariaveisModel.NomeArquivoMapaInterativoSaida;

            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = "Arquivo de Operação (*.opr)|*.opr";
            openFileDialog.DefaultExt = "opr";
            openFileDialog.AddExtension = true;
            openFileDialog.InitialDirectory = Variaveis.CaminhoSistema + Variaveis.CaminhoOperacoes;
            if (!string.IsNullOrEmpty(opPath) || openFileDialog.ShowDialog() == DialogResult.OK)
            {
                string opr_path = !string.IsNullOrEmpty(opPath) ? opPath : openFileDialog.FileName;

                if (!File.Exists(opr_path)) return (false, new List<string>());

                string ParametrosJson = File.ReadAllText(opr_path, Encoding.UTF8);

                var Parametros = JsonConvert.DeserializeObject<OperacaoParametrosModel>(ParametrosJson);

                if (Parametros.Modo == null) return (false, new List<string>());

                CarregarParametrosOperacaoPadrao((ModoOperacao)Parametros.Modo, true);

                Variaveis.OperacaoEmAndamento.Parametros = Parametros;

                Variaveis.OperacaoEmAndamento.Descricao = Parametros.Descricao;
                Variaveis.OperacaoEmAndamento.OprPath = opr_path;
                if (Variaveis.OperacaoEmAndamento.DispSen == null)
                {
                    Variaveis.OperacaoEmAndamento.DispSen = new DispositivosService<SensoriamentoModel>();
                }
                //Variaveis.OperacaoEmAndamento.DispSen.Dados.ConfiguracaoSensorUltrassom = Parametros.ConfiguracaoUltrassom;

                List<string> ruasSelecionadas = new List<string>();
                //if (Parametros.Mapa.mapaService.DadosMapa != null)
                //{
                //    ruasSelecionadas = Parametros.Mapa.RuasPercorrer.ToList();
                //    string geoJson = JsonConvert.SerializeObject(Parametros.Mapa.mapaService.DadosMapa, Formatting.None);
                //    File.WriteAllText(path, geoJson, Encoding.UTF8);
                //    Variaveis.OperacaoEmAndamento.Mapa = Parametros.Mapa;
                //
                //    /*Panel pnlMapa = FuncoesGlobais.FindControlRecursive<Panel>(Variaveis.OperacaoEmAndamento.frmOperacao, "pnlMapa");
                //    Label lblMapa = FuncoesGlobais.FindControlRecursive<Label>(Variaveis.OperacaoEmAndamento.frmOperacao, "lblMapaCarregado");*/
                //    Variaveis.OperacaoEmAndamento.Mapa.pnlMapa = pnlMapa;
                //    Variaveis.OperacaoEmAndamento.Mapa.lblMapa = lblMapa;
                //
                //    Variaveis.OperacaoEmAndamento.Mapa.btnCarregar_Click(new object(), new EventArgs(), path);
                //
                //    //bool condicaoMapaCarregado() => Variaveis.OperacaoEmAndamento.Mapa.mapaService.Carregado;
                //    //bool resultado = await FuncoesGlobais.AguardarCondicaoAsync(condicaoMapaCarregado, 5000, 200);
                //}

                RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));

                return (true, ruasSelecionadas);
            }
            else
            {
                return (false, new List<string>());
            }
        }


        public static OperacaoParametrosModel CarregarParametrosOperacaoPadrao(ModoOperacao Modo, bool isagrobase)
        {
            OperacaoParametrosModel p = new OperacaoParametrosModel()
            {
                Modo = Modo,
                Descricao = $"{Modo} - Padrão",
                QtdCamerasSolo = VariaveisEquipamento.QuantidadeCamerasSolo,
                QtdBicos = VariaveisEquipamento.QuantidadeBicosPulverizadores,
                CapacidadeReservatorio = VariaveisEquipamento.CapacidadeReservatorio,
                RoverId = VariaveisEquipamento.Parametros.serial_number,
                IP = VariaveisEquipamento.Parametros.rover_ip,
                RuasPercorrer = null,
                Mapa = null,
                DadosLeitura = new OperacaoParametrosDadosModel(),
            };

            if (isagrobase)
            {
                var SenConectado = (DispositivosService<SensoriamentoModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Sen);
                var AtuConectado = (DispositivosService<AtuadorModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Atu);
                var MvdConectado = (DispositivosService<MovimentacaoUnificadaModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Mvd);
                tmrLogs?.Stop();
                Variaveis.OperacaoEmAndamento = new OperacaoModel(Modo)
                {
                    Iniciado = false,
                    DataInicio = DateTime.MinValue,
                    DataFim = DateTime.MinValue,
                    DispAtu = AtuConectado,
                    DispSen = SenConectado,
                    DispMvd = MvdConectado,
                    Simulando = false,
                    Mapa = new MapasModel(),
                    GPSTrajetoria = new List<GPSModel>(),
                    Sensoriamento = new OperacaoSensoriamentoLogModel(),
                    Trajetoria = new TrajetoriaMapaOperacaoModel(new List<List<GPSModel>>())
                };
            }

            switch (Modo)
            {
                case ModoOperacao.Manual:
                    p.Controle = new OperacaoParametrosControleModel()
                    {
                        RegistrarDadosPosProcessamento = false,

                        MovimentoAutomatico = false,
                        DirecionalAutomatico = false,
                        PulverizadorAutomatico = false,

                        SonarAtivado = false,
                        FrenagemAutomaticaAoParar = false,
                        ImuParadaPorInclinacao = false,
                        OakParadaPorObstaculo = false,
                        MpcMatrizCusto = false,
                        MpcHorizonte = 4.0,

                        MovVelocidadeSErvasPercent = 35,
                        MovVelocidadeCErvasPercent = 12,
                        DirAnguloMaximo = 30,
                        DirVelocidadeMovimento = 40,

                        DirTipoMovimento = TiposControladorDirecional.Manual,

                        AtuAlturaAreaPulverizacao = 10,
                        AtuDuracaoAtuacao = 200,
                        AtuPercentualErvasBicoOff = 2,
                        AtuPercentualErvasBicoOn = 1,
                        AtuPercentualInicioPulverizacao = 70,
                        AtuPressaoLinha = 85,
                    };
                    p.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
                    {
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Mov,
                            Mandatorio = false,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Dir,
                            Mandatorio = false,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Atu,
                            Mandatorio = false,
                            Utilizar = true,
                        }
                    };
                    p.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
                    {
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Joystick,
                            Mandatorio = false,
                            Utilizar = true,
                        },
                    };
                    if (isagrobase)
                    {
                        Variaveis.OperacaoEmAndamento.frmOperacao = new frmOperacaoManual();
                        Variaveis.OperacaoEmAndamento.ControleAnterior = new OperacaoControleModel();
                        Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
                        {
                            TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
                            Angulo = 0,
                            EmFreio = false,
                            PercentualVelocidadeSP = 0,
                            AlturaBarra = 50,
                            TiposControle = new List<OperacaoControleTipoModel>()
                            {
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Mov,
                                    DelayEnvioComandoBase = 10,
                                    DelayEnvioComando = 250,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now,
                                    DirecaoAtual = Direcao.Parado,
                                    UltimaDirecao = Direcao.Parado
                                },
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Dir,
                                    DelayEnvioComandoBase = 10,
                                    DelayEnvioComando = 250,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now,
                                    DirecaoAtual = Direcao.Parado,
                                    UltimaDirecao = Direcao.Parado
                                },
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Atu,
                                    DelayEnvioComandoBase = 10,
                                    DelayEnvioComando = 10,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now
                                },
                            },
                        };
                    }
                    break;
                case ModoOperacao.MapaGPS:
                    p.Controle = new OperacaoParametrosControleModel()
                    {
                        RegistrarDadosPosProcessamento = false,

                        MovimentoAutomatico = true,
                        DirecionalAutomatico = true,
                        PulverizadorAutomatico = true,

                        SonarAtivado = false,
                        FrenagemAutomaticaAoParar = true,
                        ImuParadaPorInclinacao = true,
                        OakParadaPorObstaculo = true,
                        MpcMatrizCusto = false,
                        MpcHorizonte = 4.0,

                        MovVelocidadeSErvasPercent = 50,
                        MovVelocidadeCErvasPercent = 20,
                        DirAnguloMaximo = 30,
                        DirVelocidadeMovimento = 50,

                        DirTipoMovimento = TiposControladorDirecional.MPC,

                        AtuAlturaAreaPulverizacao = 10,
                        AtuDuracaoAtuacao = 200,
                        AtuPercentualErvasBicoOff = 2,
                        AtuPercentualErvasBicoOn = 1,
                        AtuPercentualInicioPulverizacao = 70,
                        AtuPressaoLinha = 85,
                    };
                    p.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
                    {
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Ipb,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Mov,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Dir,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Sen,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Atu,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Gps,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Cam,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Snr,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                    };
                    p.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
                    {
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Mapa,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                    };
                    if (isagrobase)
                    {
                        Variaveis.OperacaoEmAndamento.frmOperacao = new frmOperacaoMapaGPS();
                        Variaveis.OperacaoEmAndamento.ControleAnterior = new OperacaoControleModel();
                        Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
                        {
                            TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
                            Angulo = 0,
                            EmFreio = false,
                            PercentualVelocidadeSP = 0,
                            AlturaBarra = 50,
                            TiposControle = new List<OperacaoControleTipoModel>()
                            {
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Mov,
                                    DelayEnvioComandoBase = 500,
                                    DelayEnvioComando = 500,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now,
                                    DirecaoAtual = Direcao.Parado,
                                    UltimaDirecao = Direcao.Parado
                                },
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Dir,
                                    DelayEnvioComandoBase = 300,
                                    DelayEnvioComando = 300,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now,
                                    DirecaoAtual = Direcao.Parado,
                                    UltimaDirecao = Direcao.Parado
                                },
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Atu,
                                    DelayEnvioComandoBase = 200,
                                    DelayEnvioComando = 200,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now
                                },
                            },
                        };
                    }
                    break;
                case ModoOperacao.TreinamentoIA:
                    p.Controle = new OperacaoParametrosControleModel()
                    {
                        RegistrarDadosPosProcessamento = false,

                        MovimentoAutomatico = true,
                        DirecionalAutomatico = true,
                        PulverizadorAutomatico = false,

                        SonarAtivado = false,
                        FrenagemAutomaticaAoParar = false,
                        ImuParadaPorInclinacao = false,
                        OakParadaPorObstaculo = false,
                        MpcMatrizCusto = false,
                        MpcHorizonte = 4.0,

                        MovVelocidadeSErvasPercent = 50,
                        MovVelocidadeCErvasPercent = 20,
                        DirAnguloMaximo = 30,
                        DirVelocidadeMovimento = 50,
                        DirTipoMovimento = TiposControladorDirecional.IA,

                        AtuAlturaAreaPulverizacao = 10,
                        AtuDuracaoAtuacao = 200,
                        AtuPercentualErvasBicoOff = 2,
                        AtuPercentualErvasBicoOn = 1,
                        AtuPercentualInicioPulverizacao = 70,
                        AtuPressaoLinha = 85,
                    };
                    p.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
                    {
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Mov,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Dir,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Atu,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Gps,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Sen,
                            Mandatorio = false,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Wit,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Pzm,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Lra,
                            Mandatorio = true,
                        }
                    };
                    p.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
                    {
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.CameraSolo,
                            Mandatorio = true,
                        },
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Sonar,
                            Mandatorio = true,
                        },
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Mapa,
                            Mandatorio = true,
                        }
                    };
                    if (isagrobase)
                    {
                        Variaveis.OperacaoEmAndamento.ControleAnterior = new OperacaoControleModel();
                        Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
                        {
                            TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
                            Angulo = 0,
                            EmFreio = false,
                            PercentualVelocidadeSP = 0,
                            TiposControle = new List<OperacaoControleTipoModel>()
                            {
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Mov,
                                    DelayEnvioComandoBase = 500,
                                    DelayEnvioComando = 500,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now,
                                    DirecaoAtual = Direcao.Parado,
                                    UltimaDirecao = Direcao.Parado
                                },
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Dir,
                                    DelayEnvioComandoBase = 1000,
                                    DelayEnvioComando = 1000,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now,
                                    DirecaoAtual = Direcao.Parado,
                                    UltimaDirecao = Direcao.Parado
                                },
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Atu,
                                    DelayEnvioComandoBase = 500,
                                    DelayEnvioComando = 500,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now
                                },
                            },
                        };
                    }
                    break;
                case ModoOperacao.MapeamentoVisual:
                    p.Controle = new OperacaoParametrosControleModel()
                    {
                        RegistrarDadosPosProcessamento = false,

                        MovimentoAutomatico = true,
                        DirecionalAutomatico = true,
                        PulverizadorAutomatico = false,
                        
                        SonarAtivado = false,
                        FrenagemAutomaticaAoParar = true,
                        ImuParadaPorInclinacao = true,
                        OakParadaPorObstaculo = true,
                        MpcMatrizCusto = false,
                        MpcHorizonte = 4.0,

                        MovVelocidadeSErvasPercent = 40,
                        MovVelocidadeCErvasPercent = 20,
                        DirAnguloMaximo = 30,
                        DirVelocidadeMovimento = 50,
                        
                        DirTipoMovimento = TiposControladorDirecional.PID,

                        AtuAlturaAreaPulverizacao = 10,
                        AtuDuracaoAtuacao = 200,
                        AtuPercentualErvasBicoOff = 2,
                        AtuPercentualErvasBicoOn = 1,
                        AtuPercentualInicioPulverizacao = 70,
                        AtuPressaoLinha = 85,
                    };
                    p.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
                    {
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Ipb,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Mov,
                            Mandatorio = true,
                            Utilizar = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Dir,
                            Mandatorio = true,
                            Utilizar = true,
                        }
                    };
                    p.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
                    {
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Sonar,
                            Mandatorio = true,
                            Utilizar = true,
                        }
                    };
                    if (isagrobase)
                    {
                        Variaveis.OperacaoEmAndamento.ControleAnterior = new OperacaoControleModel();
                        Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
                        {
                            TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
                            Angulo = 0,
                            EmFreio = false,
                            PercentualVelocidadeSP = 0,
                            TiposControle = new List<OperacaoControleTipoModel>()
                            {
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Mov,
                                    DelayEnvioComandoBase = 500,
                                    DelayEnvioComando = 500,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now,
                                    DirecaoAtual = Direcao.Parado,
                                    UltimaDirecao = Direcao.Parado
                                },
                                new OperacaoControleTipoModel()
                                {
                                    Tipo = T_Code.Dir,
                                    DelayEnvioComandoBase = 200,
                                    DelayEnvioComando = 200,
                                    DelayEnvioComandoExtra = 0,
                                    Comandos = new List<string>(),
                                    UltimoComando = DateTime.Now,
                                    DirecaoAtual = Direcao.Parado,
                                    UltimaDirecao = Direcao.Parado
                                }
                            },
                        };
                    }
                    break;
            }

            p.ModulosMandatorios.Add(new OperacaoModulosMandatoriosModel() { Dispositivo = T_Code.Npc, Mandatorio = true, Utilizar = true });
            p.ModulosMandatorios.Add(new OperacaoModulosMandatoriosModel() { Dispositivo = T_Code.Can, Mandatorio = true, Utilizar = true });
            p.ModulosMandatorios.Add(new OperacaoModulosMandatoriosModel() { Dispositivo = T_Code.Bat, Mandatorio = true, Utilizar = true });
            p.ModulosMandatorios.ForEach(m => m.ComponentesEmUso = Variaveis.OperacaoEmAndamento.PreencherComponentesEmUso(m.Dispositivo));

            if (isagrobase)
            {
                Variaveis.OperacaoEmAndamento.Parametros = p;
                Variaveis.OperacaoEmAndamento.DefinirComponentesEmUso();
                RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));
                Variaveis.OperacaoEmAndamento.Sensoriamento.AtualizarDados();
            }

            return p;
        }

        private Dictionary<string, (bool, bool)> PreencherComponentesEmUso(T_Code Modulo)
        {
            Dictionary<string, (bool, bool)> d = new Dictionary<string, (bool, bool)>();
            switch (Modulo)
            {
                case T_Code.Mov:
                    if (Variaveis.OperacaoEmAndamento.DispMvd != null)
                    {
                        Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos?.ForEach(m => d.Add(m.MovMotor.Mod_ID, (true, m.MovMotor.Comandar)));
                    }
                    break;
                case T_Code.Dir:
                    if (Variaveis.OperacaoEmAndamento.DispMvd != null)
                    {
                        Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos?.ForEach(m => d.Add(m.DirMotor.Mod_ID, (true, m.DirMotor.Comandar)));
                    }
                    break;
                case T_Code.Atu:
                    if (Variaveis.OperacaoEmAndamento.DispAtu != null)
                    {
                        var da = Variaveis.OperacaoEmAndamento.DispAtu.Dados;
                        da.Sensores?.ForEach(s => d.Add(s.ID, (s.Mandatorio, s.Aferir)));
                        da.BombasPressurizadoras?.ForEach(b => d.Add(b.ID, (b.Mandatorio, b.Comandar)));
                        da.BicosPulverizadores?.ForEach(b => d.Add(b.ID, (b.Mandatorio, b.Comandar)));
                    }
                    break;
                case T_Code.Sen:
                    if (Variaveis.OperacaoEmAndamento.DispSen != null)
                    {
                        var ds = Variaveis.OperacaoEmAndamento.DispSen.Dados;
                        ds.Sensores?.ForEach(s => d.Add(s.ID, (s.Mandatorio, s.Aferir)));
                        ds.Sinaleiros?.ForEach(s => d.Add(s.ID, (s.Mandatorio, s.Controlar)));
                        ds.Servos?.ForEach(s => d.Add(s.ID, (s.Mandatorio, s.Controlar)));
                        ds.Reles?.ForEach(r => d.Add(r.ID, (r.Mandatorio, r.Controlar)));
                    }
                    break;
            }
            return d;
        }

        private void DefinirComponentesEmUso()
        {
            Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios.ForEach(m =>
            {
                switch (m.Dispositivo)
                {
                    case T_Code.Mov:
                        foreach (var c in m.ComponentesEmUso)
                        {
                            var d = Variaveis.OperacaoEmAndamento.DispMvd?.Dados?.Modulos?.FirstOrDefault(x => x?.MovMotor?.Mod_ID == c.Key)?.MovMotor;
                            if (d != null)
                                d.Comandar = c.Value.Item2;
                        }
                        break;
                    case T_Code.Dir:
                        foreach (var c in m.ComponentesEmUso)
                        {
                            var d = Variaveis.OperacaoEmAndamento.DispMvd?.Dados?.Modulos?.FirstOrDefault(x => x?.DirMotor?.Mod_ID == c.Key)?.DirMotor;
                            if (d != null)
                                d.Comandar = c.Value.Item2;
                        }
                        break;
                    case T_Code.Atu:
                        var da = Variaveis.OperacaoEmAndamento.DispAtu?.Dados;
                        foreach (var c in m.ComponentesEmUso)
                        {
                            var s = da?.Sensores?.FirstOrDefault(x => x.ID == c.Key);
                            if (s != null)
                            {
                                s.Mandatorio = c.Value.Item1;
                                s.Aferir = c.Value.Item2;
                                continue;
                            }
                            var bc = da?.BicosPulverizadores?.FirstOrDefault(x => x.ID == c.Key);
                            if (bc != null)
                            {
                                bc.Mandatorio = c.Value.Item1;
                                bc.Comandar = c.Value.Item2;
                                continue;
                            }
                            var bo = da?.BombasPressurizadoras?.FirstOrDefault(x => x.ID == c.Key);
                            if (bo != null)
                            {
                                bo.Mandatorio = c.Value.Item1;
                                bo.Comandar = c.Value.Item2;
                                continue;
                            }
                        }
                        break;
                    case T_Code.Sen:
                        var ds = Variaveis.OperacaoEmAndamento.DispSen?.Dados;
                        foreach (var c in m.ComponentesEmUso)
                        {
                            var s = ds?.Sensores?.FirstOrDefault(x => x.ID == c.Key);
                            if (s != null)
                            {
                                s.Mandatorio = c.Value.Item1;
                                s.Aferir = c.Value.Item2;
                                continue;
                            }
                            var sv = ds?.Servos?.FirstOrDefault(x => x.ID == c.Key);
                            if (sv != null)
                            {
                                sv.Mandatorio = c.Value.Item1;
                                sv.Controlar = c.Value.Item2;
                                continue;
                            }
                            var rl = ds?.Reles?.FirstOrDefault(x => x.ID == c.Key);
                            if (rl != null)
                            {
                                rl.Mandatorio = c.Value.Item1;
                                rl.Controlar = c.Value.Item2;
                                continue;
                            }
                            var ld = ds?.Sinaleiros?.FirstOrDefault(x => x.ID == c.Key);
                            if (ld != null)
                            {
                                ld.Mandatorio = c.Value.Item1;
                                ld.Controlar = c.Value.Item2;
                                continue;
                            }
                        }
                        break;
                }
            });
        }

        public (bool, List<string>) CarregarParamerosOperacaoBase(OperacaoParametrosModel Parametros)
        {
            if (Parametros.Modo == null) return (false, new List<string>());

            CarregarParametrosOperacaoPadrao((ModoOperacao)Parametros.Modo, true);

            Variaveis.OperacaoEmAndamento.Descricao = Parametros.Descricao;
            Variaveis.OperacaoEmAndamento.OprPath = $"Base ({VariaveisEquipamento.Parametros.base_ip})";
            var p = Variaveis.OperacaoEmAndamento.Parametros;
            p.Descricao = Parametros.Descricao;
            p.CapacidadeReservatorio = Parametros.CapacidadeReservatorio;
            p.Controle = Parametros.Controle;
            p.QtdBicos = Parametros.QtdBicos;
            p.QtdCamerasSolo = Parametros.QtdCamerasSolo;
            p.Mapa = Parametros.Mapa;
            p.RuasPercorrer = Parametros.RuasPercorrer;
            p.ModulosMandatorios = Parametros.ModulosMandatorios;
            p.ParametrosMandatorios = Parametros.ParametrosMandatorios;

            List<string> ruasSelecionadas = Parametros.RuasPercorrer ?? new List<string>();
            if (Parametros.Mapa != null)
            {
                Variaveis.OperacaoEmAndamento.Mapa = new MapasModel() { RuasPercorrer = ruasSelecionadas };
                Variaveis.OperacaoEmAndamento.Mapa.PopularTrajetoriaMapa(Parametros.Mapa);
            }

            RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));

            return (true, ruasSelecionadas);
        }


        public async Task IniciarOperacao()
        {
            Variaveis.OperacaoEmAndamento.Sensoriamento.UltimoRegistroLog = DateTime.Now;
            tmrLogs?.Start();

            Iniciado = true;
            Simulando = false;
            Treinando = false;
            Emergencia = false;
            Pausa = false;
            DataInicio = DateTime.Now;
            DataFim = DateTime.MinValue;
            idxLog = 0;

            ID = DataInicio.ToString("dd_MM_yyyy_HH_mm_ss") + "_" + Modo.ToString();
            Directory.CreateDirectory(Variaveis.CaminhoOperacoes + ID + "/");

            SalvarOperacao();

            Sensoriamento.AtualizarDados();

            DispMvd?.Dados?.ReiniciarLeituras(DispMvd?.Dados);
            DispAtu?.Dados?.ReiniciarLeituras(DispAtu?.Dados);
            DispSen?.Dados?.ReiniciarLeituras(DispSen?.Dados);

            ModsCalibragem = new Dictionary<T_Code, Dictionary<string, bool>>()
            {
                { T_Code.Mov, new Dictionary<string, bool>() { } },
                { T_Code.Dir, new Dictionary<string, bool>() { } },
                { T_Code.Atu, new Dictionary<string, bool>() { } },
            };

            RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));
            WeedWorkerService.ReiniciarLeituraAnalise();
            VisualWorkerService.ReiniciarLeituraAnalise();

            Controle.Reiniciar();
            ControleAnterior.Reiniciar();

            GPSTrajetoria = new List<GPSModel>();

            Trajetoria?.ProjetarTrajetoriaFixa();
            Trajetoria.VerificacaoInicialMeioRuaConcluida = false;
            RedisService.Publish(CmdKey.ManagerWorkerRx, JsonConvert.SerializeObject(new { cmd = ManagerWorkerCommandType.IniciarMPC }));

            await RealizarCalibragemInicialAsync(true);
        }

        public async Task FinalizarOperacao()
        {
            if (Variaveis.OperacaoEmAndamento.Finalizando)
            {
                return;
            }

            Variaveis.OperacaoEmAndamento.Finalizando = true;

            Variaveis.OperacaoEmAndamento.Trajetoria?.LoopAtualizaDados();

            await Task.Delay(2000);

            Variaveis.OperacaoEmAndamento.Iniciado = false;
            Variaveis.OperacaoEmAndamento.Emergencia = false;
            Variaveis.OperacaoEmAndamento.Pausa = false;

            Variaveis.OperacaoEmAndamento.DataFim = DateTime.Now;

            tmrLogs?.Stop();

            SalvarLogs(false);

            Variaveis.OperacaoEmAndamento.Finalizando = false;
            Variaveis.OperacaoEmAndamento.Trajetoria?.AutonomiaCorredor?.Parar();
        }

        public void ReiniciarOperacao(bool daBase)
        {
            RedisService.AtualizarCampos(
                CtxKey.DadosOperacao,
                ("status", StatusOperacao.Parametrizando),
                ("iniciado", false)
            );

            CarregarParamerosOperacaoBase(Variaveis.OperacaoEmAndamento.Parametros);

            if (daBase)
                EnviarParametorsOperacao();
        }

        public async Task RealizarCalibragemInicialAsync(bool forcar)
        {
            bool modsCalibrados = Variaveis.OperacaoEmAndamento.ModsCalibragem.All(x => x.Value.Values.Count > 0 && x.Value.Values.All(y => y == true));
            if (!forcar && modsCalibrados) return;

            var DispAtu = Variaveis.OperacaoEmAndamento.DispAtu;
            var DispMvd = Variaveis.OperacaoEmAndamento.DispMvd;
            List<StatusModulo> sv = new List<StatusModulo>() { StatusModulo.Operante, StatusModulo.Alerta };
            var s = HealthWorkerService.ModulosSaude;
            var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle;
            var _Controle = Variaveis.OperacaoEmAndamento.Controle;

            bool calibragemAtuNecessaria = pControle.PulverizadorAutomatico && (DispAtu?.Dados != null && sv.Contains(s.FirstOrDefault(x => x.modulo == T_Code.Atu)?.status ?? StatusModulo.Desconectado) && (forcar || Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Atu].Any(x => !x.Value) || !Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Atu].Any()));
            bool calibragemDirNecessaria = (DispMvd?.Dados != null && sv.Contains(s.FirstOrDefault(x => x.modulo == T_Code.Dir)?.status ?? StatusModulo.Desconectado) && (forcar || Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Dir].Any(x => !x.Value) || !Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Dir].Any()));
            bool calibragemMovNecessaria = (DispMvd?.Dados != null && sv.Contains(s.FirstOrDefault(x => x.modulo == T_Code.Mov)?.status ?? StatusModulo.Desconectado) && (forcar || Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Mov].Any(x => !x.Value) || !Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Mov].Any()));
            calibragemDirNecessaria = false;

            if (!calibragemAtuNecessaria && !calibragemDirNecessaria && !calibragemMovNecessaria) return;

            Console.WriteLine("Pausa para calibragem inicial");
            Variaveis.OperacaoEmAndamento.Pausa = true;
            await Task.Delay(5000);

            Console.WriteLine("Calibragem dos modulos inciada...");
            Variaveis.OperacaoEmAndamento.Calibrando = true;
            RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("calibrando", Variaveis.OperacaoEmAndamento.Calibrando));

            TipoMovimentoDirecional tipoControle = _Controle.TipoMovimento;

            var tasks = new List<Task>();
            
            if (calibragemAtuNecessaria) tasks.AddRange(DispAtu.Dados.RealizarCalibragemAsync(forcar));
            if (calibragemDirNecessaria) tasks.AddRange(DispMvd.Dados.RealizarCalibragemDirAsync(forcar));
            if (calibragemMovNecessaria) tasks.AddRange(DispMvd.Dados.RealizarCalibragemMovAsync(forcar));

            if (tasks.Count == 0)
            {
                Console.WriteLine("Nenhuma calibragem foi iniciada.");
                _Controle.TipoMovimento = tipoControle;
                Variaveis.OperacaoEmAndamento.Calibrando = false;
                Variaveis.OperacaoEmAndamento.Pausa = false;
                return;
            }

            try
            {
                var allTasks = Task.WhenAll(tasks);
                var completed = await Task.WhenAny(allTasks, Task.Delay(2 * 60 * 1000));

                if (completed == allTasks)
                {
                    Console.WriteLine("Calibragem finalizada com sucesso!");
                }
                else
                {
                    Console.WriteLine("Timeout na calibragem. Continuando mesmo assim.");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Erro durante calibragem: {ex.Message}");
            }
            _Controle.TipoMovimento = tipoControle;
            Variaveis.OperacaoEmAndamento.Calibrando = false;
            Variaveis.OperacaoEmAndamento.Pausa = false;
            RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("calibrando", Variaveis.OperacaoEmAndamento.Calibrando));
        }


        public async Task IniciarSimulacao()
        {
            Iniciado = true;
            Simulando = true;
            Treinando = false;
            DataInicio = DateTime.Now;
            DataFim = DateTime.MinValue;

            ID = "";

            Sensoriamento.AtualizarDados();

            DispMvd?.Dados?.ReiniciarLeituras(DispMvd.Dados);
            DispAtu?.Dados?.ReiniciarLeituras(DispAtu.Dados);
            DispSen?.Dados?.ReiniciarLeituras(DispSen.Dados);

            RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));
            WeedWorkerService.ReiniciarLeituraAnalise();
            VisualWorkerService.ReiniciarLeituraAnalise();

            Controle.Reiniciar();
            ControleAnterior.Reiniciar();

            GPSTrajetoria = new List<GPSModel>();

            Trajetoria?.ProjetarTrajetoriaFixa();
            Trajetoria.VerificacaoInicialMeioRuaConcluida = false;
            RedisService.Publish(CmdKey.ManagerWorkerRx, JsonConvert.SerializeObject(new { cmd = ManagerWorkerCommandType.IniciarMPC }));
        }

        public void ReiniciarSimulacao()
        {
            ReiniciarOperacao(false);

            var Topico = Variaveis.MqttServiceLocal.Topicos.FirstOrDefault(x => x.Topico == MapasVariaveisModel.TopicoSelecaoRuasMapa);
            Topico.Mensagens.Add(new MqttService.MqttTopicosMensagensModel()
            {
                Mensagem = "[]",
                Momento = DateTime.Now
            });
        }


        public void IniciarTreinamento()
        {
            Iniciado = true;
            Treinando = true;
            DataInicio = DateTime.Now;
            DataFim = DateTime.MinValue;

            ID = "";

            if (DispMvd != null)
            {
                DispMvd.Dados.ReiniciarLeituras(DispMvd.Dados);
            }
            if (DispAtu != null)
            {
                DispAtu.Dados.ReiniciarLeituras(DispAtu.Dados);
            }
            if (DispSen != null)
            {
                DispSen.Dados.ReiniciarLeituras(DispSen.Dados);
            }

            Controle.Angulo = 0;
            Controle.PercentualVelocidadeSP = 0;

            GPSTrajetoria = new List<GPSModel>();
        }


        public static string DeserializarDadosOperacao(string caminho, string arquivo)
        {
            string opPath = caminho.Replace("data.lgop", arquivo) + ".json";
            string opStr = "";
            if (File.Exists(opPath))
                opStr = File.ReadAllText(opPath);
            else
                opStr = "[";
            if (opStr != "" && !opStr.EndsWith("]"))
            {
                opStr += "]";
            }
            return opStr;
        }

        private void SalvarOperacao()
        {
            if (string.IsNullOrEmpty(Variaveis.OperacaoEmAndamento.OprPath)) return;

            var Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID;
            if (!Directory.Exists(Caminho))
            {
                Directory.CreateDirectory(Caminho);
            }

            Caminho += "/operacao.opr";
            File.Copy(Variaveis.OperacaoEmAndamento.OprPath, Caminho);
        }


        #endregion

        #region CONTROLE DA OPERACAO

        public void AtualizaInformacoesControleOperacao()
        {
            var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle;
            if (pControle.MovimentoAutomatico)
            {
                Variaveis.OperacaoEmAndamento.AtualizarDadosControle(false, new List<T_Code>() { T_Code.Mov });
            }
            if (pControle.DirecionalAutomatico)
            {
                Variaveis.OperacaoEmAndamento.AtualizarDadosControle(false, new List<T_Code>() { T_Code.Dir });
            }
            if (pControle.PulverizadorAutomatico)
            {
                Variaveis.OperacaoEmAndamento.AtualizarDadosControle(false, new List<T_Code>() { T_Code.Atu });
            }
        }

        public void AtualizarDadosControle(bool ForcarEnvio, List<T_Code> Dispositivos)
        {
            DateTime Agora = DateTime.Now;

            var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle;
            var _Controle = Variaveis.OperacaoEmAndamento.Controle;
            var mm = Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios;

            foreach (var Ctrl in _Controle.TiposControle.Where(x => Dispositivos.Contains(x.Tipo)))
            {
                if (!ForcarEnvio && false)
                {
                    if (mm.Any(x => x.Dispositivo == Ctrl.Tipo && !x.Utilizar))
                        continue;
                    if (Ctrl.Tipo == T_Code.Atu && !pControle.PulverizadorAutomatico)
                        continue;
                    if (Ctrl.Tipo == T_Code.Mov && !pControle.MovimentoAutomatico)
                        continue;
                    if (Ctrl.Tipo == T_Code.Dir && !pControle.DirecionalAutomatico)
                        continue;
                }

                if (ForcarEnvio || ((Agora - Ctrl.UltimoComando).TotalMilliseconds > Ctrl.DelayEnvioComando))
                {
                    var Protocolos = EnviarProtocoloComando(Ctrl.Tipo, ForcarEnvio);
                    Ctrl.UltimoComando = Agora;
                    Ctrl.DelayEnvioComando = Ctrl.DelayEnvioComandoBase + Ctrl.DelayEnvioComandoExtra;
                    Ctrl.DelayEnvioComandoExtra = 0;
                    Ctrl.Comandos.AddRange(Protocolos);
                }
            }
        }

        public List<string> EnviarProtocoloComando(T_Code Tipo, bool ForcarEnvio)
        {
            if (!Variaveis.OperacaoEmAndamento.Iniciado && !ForcarEnvio)
            {
                return new List<string>();
            }

            List<string> Protocolos = new List<string>();

            var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle;
            var _Controle = Variaveis.OperacaoEmAndamento.Controle;
            var _ControleAnterior = Variaveis.OperacaoEmAndamento.ControleAnterior;
            var DirecaoAtual = _Controle.TiposControle.FirstOrDefault(x => x.Tipo == Tipo).DirecaoAtual;

            switch (Tipo)
            {
                case T_Code.Mov:
                    {
                        var modsAtualizar = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Where(Mod => Mod.MovMotor.NovoRPMNecessario).Select(x => x.Modulo_ID).ToList();
                        bool envioNecessario = ForcarEnvio || _Controle.RPM_SP != _ControleAnterior.RPM_SP || _Controle.EmFreio != _ControleAnterior.EmFreio;
                        if (envioNecessario || modsAtualizar.Any())
                        {
                            foreach (var Mod in Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Where(x => envioNecessario ? true : modsAtualizar.Contains(x.Modulo_ID)))
                            {
                                Mod.MovMotor.EnviarComandoControle(DirecaoAtual);
                            }
                        }

                        //Variaveis.MostrarLog($"Velocidade SP alterada de {_ControleAnterior.PercentualVelocidadeSP} para {_Controle.PercentualVelocidadeSP}");

                        _ControleAnterior.PercentualVelocidadeSP = _Controle.PercentualVelocidadeSP;
                        _ControleAnterior.EmFreio = _Controle.EmFreio;

                        RedisService.AtualizarCampos(
                            CtxKey.DadosControle, 
                            ("velocidade_sp_ant", _Controle.PercentualVelocidadeSP),
                            ("em_freio_ant", _Controle.EmFreio)
                        );

                        Protocolos = new List<string>()
                        {
                            DirecaoAtual.ToString() + ";" + _Controle.RPM_SP.ToString() + ";" + (ForcarEnvio ? "1": "0")
                        };
                        break;
                    }
                case T_Code.Dir:
                    {
                        bool envioNecessario = ForcarEnvio || _Controle.Angulo != _ControleAnterior.Angulo || _Controle.TipoMovimento != _ControleAnterior.TipoMovimento;
                        var modsAtualizar = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Where(Mod => !Mod.DirMotor.AtingiuAnguloSP).Select(x => x.Modulo_ID).ToList();
                        if (!MKS057DCanService.Referenciando && (envioNecessario || modsAtualizar.Any()))
                        {
                            foreach (var Mod in Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Where(x => envioNecessario ? true : modsAtualizar.Contains(x.Modulo_ID)))
                            {
                                Mod.DirMotor.EnviarComandoControle(DirecaoAtual);
                            }
                        }

                        //Variaveis.MostrarLog($"Angulo SP alterado de {_ControleAnterior.Angulo:F2} para {_Controle.Angulo:F2}");

                        _ControleAnterior.Angulo = _Controle.Angulo;
                        _ControleAnterior.TipoMovimento = _Controle.TipoMovimento;

                        RedisService.AtualizarCampos(
                            CtxKey.DadosControle,
                            ("angulo_sp_ant", _Controle.Angulo),
                            ("tipo_movimento_direcional_ant", _Controle.TipoMovimento)
                        );

                        Protocolos = new List<string>()
                        {
                            DirecaoAtual.ToString() + ";" + _Controle.Angulo.ToString() + ";" + _Controle.TipoMovimento.ToString() + ";" + (ForcarEnvio ? "1": "0")
                        };
                        break;
                    }
                case T_Code.Atu:
                    {
                        bool enviarComando = false;
                        for (int i = 0; i < _Controle.Bicos.Count; i++)
                        {
                            Estado comandoEstado = _Controle.Bicos[i].ComandoAtuar ? Estado.Ligado : Estado.Desligado;
                            if (ForcarEnvio || comandoEstado != _Controle.Bicos[i]._EstadoLeitura)
                            {
                                GeneralJoystick.EnviarComandoAtuador(_Controle.Bicos[i].Componente, _Controle.Bicos[i].ID, Status: _Controle.Bicos[i].ComandoAtuar);
                                enviarComando = true;
                            }
                        }

                        // Ligar a bomba caso esteja desligada e tenha herbicida suficiente no reservatorio
                        if ((Variaveis.OperacaoEmAndamento.DispAtu?.Dados?.ContadorCarga?.PulverizadorLiberado ?? false) && enviarComando)
                        {
                            foreach (var Bomba in Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombasPressurizadoras)
                            {
                                if (Bomba._EstadoLeitura == Estado.Desligado)
                                {
                                    GeneralJoystick.EnviarComandoAtuador(Bomba.Componente, Bomba.ID, Status: true);
                                }
                            }
                        }

                        Protocolos = new List<string>()
                        {
                            string.Join(";", _Controle.Bicos.Select(x => x.ComandoAtuar ? "1" : "0")) + ";" + (ForcarEnvio ? "1": "0")
                        };
                        break;
                    }
            }

            _Controle.TiposControle.FirstOrDefault(x => x.Tipo == Tipo).UltimaDirecao = DirecaoAtual;

            return Protocolos;
        }

        private async Task tmrLeituras_Tick()
        {
            if (Variaveis.IsAgroMonitor)
            {
                return;
            }

            Variaveis.OperacaoEmAndamento.Sensoriamento.AtualizarDados();
            //Variaveis.LoraService?.EnviarDadosParaBase();

            if (Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.Manual)
            {
                var Sonar = Variaveis.OperacaoEmAndamento.Sensoriamento.OperadorVisual;
                Sonar?.Resumo?.AtualizarStatusBloqueio(true);
                if (Sonar?.Resumo?.EnviarComandoParada ?? false)
                {
                    Variaveis.MostrarLog("[OperacaoModel] Deve enviar o comando de parada em tmrLeituras_Tick");
                    //GeneralJoystick.EnviaComandoMotor(Keys.Escape, Disp: T_Code.Mov, ForcarComando: true);
                    GeneralJoystick.ProcessarDadosControle(BotoesJoystick.Xis, true, ForcarComando: true);
                    if (Variaveis.OperacaoEmAndamento.Parametros?.Controle?.FrenagemAutomaticaAoParar ?? false)
                    {
                        Variaveis.MostrarLog("[OperacaoModel] Deve enviar o comando de freio em tmrLeituras_Tick");
                        GeneralJoystick.ProcessarDadosControle(BotoesJoystick.Bolinha, false, ForcarComando: true);
                    }
                }

                if (!Variaveis.OperacaoEmAndamento.OperacaoLiberada)
                {
                    var _Controle = Variaveis.OperacaoEmAndamento.Controle;
                    if (_Controle.TiposControle?.FirstOrDefault(x => x?.Tipo == T_Code.Mov)?.DirecaoAtual != Direcao.Parado)
                    {
                        //GeneralJoystick.EnviaComandoMotor(Keys.Escape, Disp: T_Code.Mov, ForcarComando: true);
                        GeneralJoystick.ProcessarDadosControle(BotoesJoystick.Xis, true, ForcarComando: true);
                    }
                    if (_Controle.TiposControle?.FirstOrDefault(x => x?.Tipo == T_Code.Dir)?.UltimaDirecao != Direcao.Parado)
                    {
                        //GeneralJoystick.EnviaComandoMotor(Keys.Escape, Disp: T_Code.Dir, ForcarComando: true);
                        GeneralJoystick.ProcessarDadosControle(BotoesJoystick.SEsquerda, true, ForcarComando: true);
                    }
                }
            }
        }

        private void EnviarParametorsOperacao()
        {
            var topico = Variaveis.MqttServiceBase.Topicos.FirstOrDefault(x => x.Topico == VariaveisEquipamento.TopicoMqttParametros.Replace("<id>", VariaveisEquipamento.Parametros.serial_number));
            var p = Variaveis.OperacaoEmAndamento.Parametros;
            string msg = JsonConvert.SerializeObject(p);
            Task.Run(async () => await Variaveis.MqttServiceBase.PublishAsync(topico, msg));
        }

        public void ExecutaComandoDaBase(OperacaoComandoBaseModel controleBase)
        {
            if (controleBase.Dispositivo == T_Code.Mod)
            {
                var _Parametros = controleBase.Parametros;

                
                switch (controleBase.Tecla)
                {
                    case BotoesJoystick.Share: // Requisitar parametros da operacao
                        EnviarParametorsOperacao();
                        break;
                    case BotoesJoystick.Options: // Operacao nao iniciada, carrega todos os parametros compeltos
                        Variaveis.OperacaoEmAndamento.CarregarParamerosOperacaoBase(_Parametros);
                        EnviarParametorsOperacao();
                        break;
                    case BotoesJoystick.Touchpad: // Operacao em andamento, atualiza apenas os dados de controle
                        if (_Parametros.Modo != null) Variaveis.OperacaoEmAndamento.Parametros.Modo = _Parametros.Modo;
                        if (_Parametros.QtdBicos != null) Variaveis.OperacaoEmAndamento.Parametros.QtdBicos = _Parametros.QtdBicos;
                        if (_Parametros.Descricao != null) Variaveis.OperacaoEmAndamento.Parametros.Descricao = _Parametros.Descricao;
                        if (_Parametros.QtdCamerasSolo != null) Variaveis.OperacaoEmAndamento.Parametros.QtdCamerasSolo = _Parametros.QtdCamerasSolo;
                        if (_Parametros.CapacidadeReservatorio != null) Variaveis.OperacaoEmAndamento.Parametros.CapacidadeReservatorio = _Parametros.CapacidadeReservatorio;

                        if (_Parametros.Controle != null) Variaveis.OperacaoEmAndamento.Parametros.Controle = _Parametros.Controle;
                        if (_Parametros.ParametrosMandatorios != null) Variaveis.OperacaoEmAndamento.Parametros.ParametrosMandatorios = _Parametros.ParametrosMandatorios;
                        if (_Parametros.ModulosMandatorios != null)
                        {
                            Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios = _Parametros.ModulosMandatorios;
                            Variaveis.OperacaoEmAndamento.DefinirComponentesEmUso();
                        }

                        HealthWorkerService.AtualizarDadosOperacao(true);
                        EnviarParametorsOperacao();
                        break;
                    case BotoesJoystick.L1: // Inicia o modo simulador
                        if (!Variaveis.OperacaoEmAndamento.Iniciado)
                            Task.Run(async () => await Variaveis.OperacaoEmAndamento.IniciarSimulacao());
                        break;
                    case BotoesJoystick.L2: // Inicia a operacao
                        if (!Variaveis.OperacaoEmAndamento.Iniciado)
                            Task.Run(async () => await Variaveis.OperacaoEmAndamento.IniciarOperacao());
                        break;
                    case BotoesJoystick.L3: // Finaliza a operacao
                        if (Variaveis.OperacaoEmAndamento.Iniciado)
                            Task.Run(async () => await Variaveis.OperacaoEmAndamento.FinalizarOperacao());
                        else
                            ReiniciarOperacao(true);
                        break;
                    case BotoesJoystick.R1: // Libera a operacao interrompida mediante supervisao humana
                        if (!(Variaveis.OperacaoEmAndamento.Trajetoria?.AutonomiaCorredor?.Liberado ?? false))
                        {
                            var (idx_corredor, b_liberada, h_liberado) = ((JObject)controleBase._comp_value).ToObject<(int, bool, bool)>();
                            Variaveis.OperacaoEmAndamento.Trajetoria?.AtualizarDadosAutonomiaCorredor(idxCorredor: idx_corredor, bat_liberada: b_liberada, herb_liberado: h_liberado);
                        }
                        break;
                }
                return;
            }

            if (controleBase.Dispositivo == T_Code.Ipb)
            {
                if (controleBase._comp_value == true)
                {
                    Variaveis.IniciarUDP();
                }
                else
                {
                    Variaveis.StopUdpChannel();
                }
                return;
            }

            if (controleBase.Dispositivo == T_Code.Gps)
            {
                var (la_frontal, la_lateral) = ((JObject)controleBase._comp_value).ToObject<(double?, double?)>();
                if (la_lateral != null || la_frontal != null)
                    GPSService.LeverArm = new GeoLeverArm(offsetFisicoFrontalCm: VariaveisEquipamento.LeverArmFrontalCm, offsetFisicoLateralCm: VariaveisEquipamento.LeverArmLateralCm, offsetCampoFrontalCm: la_frontal ?? 0, offsetCampoLateralCm: la_lateral ?? 0);
                return;
            }

            if (controleBase.Dispositivo == T_Code.Snr && Variaveis.OperacaoEmAndamento.DispSen?.Dados?.CameraCaminho?.Id != null)
            {
                RedisService.AtualizarCampos(
                    RedisService.CamKey(Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraCaminho.Id),
                    ("streaming", controleBase.Tecla == BotoesJoystick.L1),
                    ("frame_type", (TipoFrameCamera)controleBase._comp_value)
                );
                return;
            }

            if (controleBase.Dispositivo == T_Code.Cam && (Variaveis.OperacaoEmAndamento.DispSen?.Dados?.CamerasSolo?.Any(x => !string.IsNullOrEmpty(x.Id)) ?? false))
            {
                RedisService.AtualizarCampos(
                    RedisService.CamKey(Variaveis.OperacaoEmAndamento.DispSen.Dados.CamerasSolo.FirstOrDefault(x => !string.IsNullOrEmpty(x.Id)).Id),
                    ("streaming", controleBase.Tecla == BotoesJoystick.L1),
                    ("frame_type", (TipoFrameCamera)controleBase._comp_value)
                );
                return;
            }

            if (controleBase.Dispositivo == T_Code.Atu && Variaveis.OperacaoEmAndamento.DispAtu != null)
            {
                if (controleBase.Controle == null) return;

                S_Code get_comp(string id)
                {
                    if (string.IsNullOrEmpty(id)) return S_Code.sMOD;
                    var d_atu = Variaveis.OperacaoEmAndamento.DispAtu.Dados;
                    if (d_atu.BicosPulverizadores.Any(x => x.ID == id)) return S_Code.sBIC;
                    if (d_atu.BombasPressurizadoras.Any(x => x.ID == id)) return S_Code.sBMB;
                    if (d_atu.Sensores.Any(x => x.ID == id)) return d_atu.Sensores.First(x => x.ID == id).Componente;
                    return S_Code.sVZO;
                }

                S_Code comp = get_comp(controleBase._comp_id);

                switch (comp)
                {
                    case S_Code.sMOD:
                        if (controleBase.Controle.Altura != null) Variaveis.OperacaoEmAndamento.Controle.AlturaBarra = (double)controleBase.Controle.Altura;
                        break;
                    case S_Code.sBIC:
                        if (controleBase._comp_value != null)
                        {
                            var bico = Variaveis.OperacaoEmAndamento.Controle.Bicos.FirstOrDefault(x => x.ID == controleBase._comp_id);
                            if (bico != null)
                            {
                                bico.AnguloAbertura = (int)controleBase._comp_value;
                            }
                        }
                        break;
                }

                GeneralJoystick.EnviarComandoAtuador(comp, controleBase._comp_id, Status: controleBase.Controle.Estado, Valor: controleBase.Controle.AnguloSP, Forcar: true);
                return;
            }

            if (controleBase.Dispositivo == T_Code.Sen && Variaveis.OperacaoEmAndamento.DispSen != null)
            {
                S_Code get_comp(string id)
                {
                    if (string.IsNullOrEmpty(id)) return S_Code.sMOD;
                    var d_sen = Variaveis.OperacaoEmAndamento.DispSen.Dados;
                    if (d_sen.Reles.Any(x => x.ID == id)) return S_Code.sRLE;
                    if (d_sen.Servos.Any(x => x.ID == id)) return S_Code.sSRV;
                    if (d_sen.Sinaleiros.Any(x => x.ID == id)) return S_Code.sLED;
                    if (d_sen.Sensores.Any(x => x.ID == id)) return d_sen.Sensores.First(x => x.ID == id).Componente;
                    return S_Code.sVZO;
                }

                S_Code comp = get_comp(controleBase._comp_id);
                GeneralJoystick.EnviarComandoSensoriamento(comp, controleBase._comp_id, controleBase._comp_value, Forcar: true);
                return;
            }

            if (controleBase.Dispositivo == T_Code.Dir && controleBase.Tecla == BotoesJoystick.R3)
            {
                //GeneralJoystick.EnviaComandoMotor(Keys.R, ForcarComando: true, ID: controleBase._comp_id);
                GeneralJoystick.ProcessarDadosControle(BotoesJoystick.R3, false);
                return;
            }

            if (controleBase.Dispositivo == T_Code.Npc)
            {
                var (modo, e_entrada, e_saida, t_ligar, t_turbo) = ((JObject)controleBase._comp_value).ToObject<(CoolerControlService.CoolerMode, Estado?, Estado?, double?, double?)>();
                Variaveis.OperacaoEmAndamento.DispSen?.Dados?.CoolerControl?.AlterarControle(modo, entrada: e_entrada, saida: e_saida, tempOn: t_ligar, tempTurbo: t_turbo);
                return;
            }

            if (controleBase.Dispositivo == T_Code.Trj)
            {
                var (lat, lon, pontosRetorno) = ((JObject)controleBase._comp_value).ToObject<(double?, double?, List<double[]>)>();
                if (lat == null || lon == null) return;
                GPSModel posicaoBase = new GPSModel() { Latitude = lat.Value, Longitude = lon.Value };
                List<GPSModel> pontosRetornoPos = null;
                if (pontosRetorno?.Any() ?? false)
                    pontosRetornoPos = pontosRetorno.Select(x => new GPSModel() { Latitude = x[0], Longitude = x[1] }).ToList();
                Variaveis.OperacaoEmAndamento.Trajetoria?.IniciarRetornoBase(posicaoBase, pontosRetornoPos);
                return;
            }

            Variaveis.OperacaoEmAndamento.Emergencia = controleBase.Emergencia;
            if (Variaveis.OperacaoEmAndamento.Emergencia) return;

            Variaveis.OperacaoEmAndamento.Pausa = controleBase.Pausa;
            if (Variaveis.OperacaoEmAndamento.Pausa) return;

            if (controleBase.Controle == null) return;

            var cmdRover = GeneralJoystick.DeParaComandos.FirstOrDefault(x => x.botaoJoy == controleBase.Tecla);

            if (cmdRover?.Dispositivo == T_Code.Mov && (Variaveis.OperacaoEmAndamento.Parametros?.Controle?.MovimentoAutomatico ?? false) && Variaveis.OperacaoEmAndamento.Iniciado) return;
            if (cmdRover?.Dispositivo == T_Code.Dir && (Variaveis.OperacaoEmAndamento.Parametros?.Controle?.DirecionalAutomatico ?? false) && Variaveis.OperacaoEmAndamento.Iniciado) return;

            var _Controle = Variaveis.OperacaoEmAndamento.Controle;
            if (controleBase.Controle.PercentualVelocidadeSP != null) _Controle.PercentualVelocidadeSP = (double)controleBase.Controle.PercentualVelocidadeSP;
            if (controleBase.Controle.AnguloSP != null) _Controle.Angulo = (double)controleBase.Controle.AnguloSP;
            if (controleBase.Controle.TipoMovimentoDirecional != null) _Controle.TipoMovimento = (TipoMovimentoDirecional)controleBase.Controle.TipoMovimentoDirecional;
            if (controleBase.Controle.EmFreio != null) _Controle.EmFreio = (bool)controleBase.Controle.EmFreio;

            //GeneralJoystick.EnviaComandoMotor(tecla, controleBase.Dispositivo, ForcarComando: true, ID: controleBase._comp_id);

            switch (cmdRover?.Dispositivo)
            {
                case T_Code.Mov:
                    GeneralJoystick.ProcessarDadosControle(cmdRover.botaoJoy, controleBase.Solto, valorDesejado: _Controle.PercentualVelocidadeSP, ForcarComando: true);
                    break;
                case T_Code.Dir:
                    GeneralJoystick.ProcessarDadosControle(cmdRover.botaoJoy, controleBase.Solto, valorDesejado: _Controle.Angulo, ForcarComando: true);
                    break;
            }
        }

        private async Task tmrComunicacao_Tick()
        {
            if (Variaveis.MqttServiceBase == null) return;

            bool base_encontrada = (DateTime.Now - VariaveisOperacao.PosicaoBase.UltimoComandoRespondido).TotalSeconds < 10;
            MqttService.MqttTopicosModel topico = null;
            string msg = string.Empty;
            if (!base_encontrada)
            {
                topico = Variaveis.MqttServiceBase.Topicos.FirstOrDefault(x => x.Topico == VariaveisMonitoramento.TopicoMqttDispositivos);
                msg = $"{VariaveisEquipamento.Parametros.serial_number},{VariaveisEquipamento.Parametros.rover_ip}";
            }
            else
            {
                topico = Variaveis.MqttServiceBase.Topicos.FirstOrDefault(x => x.Topico == VariaveisEquipamento.TopicoMqttTelemetria.Replace("<id>", VariaveisEquipamento.Parametros.serial_number));
                Variaveis.OperacaoEmAndamento.Parametros.DadosLeitura?.Atualizar();
                var data = Variaveis.OperacaoEmAndamento.Parametros.DadosLeitura?.Clone();
                msg = JsonConvert.SerializeObject(data);
            }
            if (topico != null && !string.IsNullOrEmpty(msg))
            {
                await Variaveis.MqttServiceBase.PublishAsync(topico, msg);
                if (Variaveis.OperacaoEmAndamento.Parametros.DadosLeitura != null)
                    Variaveis.OperacaoEmAndamento.Parametros.DadosLeitura.UltimoEnvioLog = DateTime.Now;
            }
        }

        #endregion

        #region REGISTRO DE LOGS

        private int idxLog = 0;

        private async Task tmrLogs_Tick()
        {
            if (Variaveis.OperacaoEmAndamento.Iniciado)
            {
                SalvarLogs(false);

                if (idxLog % 10 == 0)
                {
                    AudioAlertaService.AlertaSonoroPorStatus(Variaveis.OperacaoEmAndamento.StatusAtual);
                }

                if (idxLog % 5 == 0 && !Variaveis.OperacaoEmAndamento.Calibrando)
                {
                    Task.Run(async () => await RealizarCalibragemInicialAsync(false));
                }
            }
        }

        public void SalvarLogs(bool Fim)
        {
            try
            {
                if (!string.IsNullOrEmpty(Variaveis.OperacaoEmAndamento.ID))
                {
                    DateTime Agora = DateTime.Now;

                    OperacaoSensoriamentoLogModel logGeral = Variaveis.OperacaoEmAndamento.Sensoriamento.Clone();
                    logGeral.Momento = Agora;
                    SalvarLog("operacao", logGeral, Fim);
                    Variaveis.OperacaoEmAndamento.Sensoriamento.UltimoRegistroLog = DateTime.Now;
                    Variaveis.OperacaoEmAndamento.Controle.TiposControle.ForEach(x => x.Comandos.Clear());

                    Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.ForEach(Modulo =>
                    {
                        MovSensoriamentoLogModel logMov = new MovSensoriamentoLogModel()
                        {
                            Momento = Agora,
                            Modulo_ID = Modulo.Modulo_ID,
                            Inicializado = Modulo.MovMotor.Inicializado,
                            RPM_SP = Modulo.MovMotor.RPM_SP,
                            RPM_Motor = Modulo.MovMotor.RPM_Motor,
                            RPM_Roda = Modulo.MovMotor.RPM_Roda,
                            Corrente_Motor = Modulo.MovMotor.Corrente_Motor,
                            Temperatura = Modulo.MovMotor.Temperatura,
                            TemperaturaDriver = Modulo.MovMotor.TemperaturaDriver,
                            Tensao = Modulo.MovMotor.Tensao,
                            Sentido_SP = Modulo.MovMotor.Sentido_SP,
                            Sentido = Modulo.MovMotor.Sentido,
                            Velocidade = Modulo.MovMotor.VelocidadeInstantanea,
                            CodAlarme = Modulo.MovMotor.CodigoAlarme,
                            AlarmeSensores = Modulo.MovMotor.AlarmeSensores,
                            AlarmeComando = Modulo.MovMotor.AlarmeComando,
                            EmFreio = Modulo.MovMotor.ConfigFreio.Leitura,
                            Ativado = Modulo.MovMotor.LeituraLigado,
                            UltimoComandoRespondido = Modulo.MovMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
                            Corrente_Barramento = Modulo.MovMotor.Corrente_Barramento,
                            Potencia = Modulo.MovMotor.Potencia,
                            CicloTrabalho = Modulo.MovMotor.CicloTrabalho
                        };
                        SalvarLog(T_Code.Mov.ToString(), logMov, false);

                        DirSensoriamentoLogModel logDir = new DirSensoriamentoLogModel()
                        {
                            Mod_ID = Modulo.Modulo_ID,
                            Iniciado = Modulo.DirMotor.Inicializado,
                            AnguloDriver = Modulo.DirMotor.AnguloDriver,
                            Angulo_SP = Modulo.DirMotor.Angulo_SP,
                            Controlar = Modulo.DirMotor.Comandar,
                            Sentido_SP = Modulo.DirMotor.Sentido_SP,
                            Sentido = Modulo.DirMotor.Sentido,
                            SentidoReal = Modulo.DirMotor.SentidoReal, 
                            Velocidade = (Modulo.DirMotor.Velocidade / Modulo.DirMotor.Velocidade_Max) * 100.0,
                            FolgaMecanica = Modulo.DirMotor.FolgaMecanica, 
                            UltimoComandoRespondido = Modulo.DirMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
                            AnguloLeitura = Modulo.DirMotor.AnguloLeitura,
                            AnguloFolgaCompensar = Modulo.DirMotor.AnguloFolgaCompensar,
                            AnguloReal = Modulo.DirMotor.AnguloReal
                        };
                        SalvarLog(T_Code.Dir.ToString(), logDir, false);
                    });

                    AtuSensoriamentoLogModel logAtu = new AtuSensoriamentoLogModel()
                    {
                        Momento = Agora,
                        Inicializado = Variaveis.OperacaoEmAndamento.DispAtu.Dados.ConexaoAtiva,
                        QualidadeWifi = Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.QualidadeWifi,
                        LatenciaLoop = Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.LatenciaLoop,
                        MassaReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.ContadorCarga.MassaAtual_Kg,
                        PercentualReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.ContadorCarga.PercentualAtual,
                        VolumeReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.ContadorCarga.VolumeAtual_L,
                        PressaoLinha_SP = Variaveis.OperacaoEmAndamento.Parametros.Controle.AtuPressaoLinha,
                        PressaoLinha = Variaveis.OperacaoEmAndamento.DispAtu.Dados.PressaoLinha,
                        PotenciaBomba = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombasPressurizadoras.FirstOrDefault()?._Potencia ?? 0,
                        BombaLigada = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombasPressurizadoras.FirstOrDefault().ComandoAtuar,
                        VazaoFluxoMLpSInstantanea = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VazaoFluxoMLpSInstantanea,
                        VazaoFluxoMLpSMedia = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VazaoMediaMLs,
                        VolumeVazaoML = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VolumeVazadoML,
                        QuantidadeBicos = Variaveis.OperacaoEmAndamento.Parametros.QtdBicos ?? VariaveisEquipamento.QuantidadeBicosPulverizadores,
                        TempoPulverizadorAtuado = Variaveis.OperacaoEmAndamento.DispAtu.Dados.TempoAtuado,
                        Bicos = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BicosPulverizadores.Select(Bico => new AtuBicoSensoriamentoLogModel()
                        {
                            ID = Bico.ID,
                            Inicializado = Bico.Inicializado,
                            Comandar = Bico.Comandar,
                            Atuado = Bico.ComandoAtuar,
                            MediaNivelFluxo = Bico.VazaoMediaMLs,
                            Posicao = Bico.Posicao,
                            StatusBico = Bico._EstadoLeitura == Estado.Ligado,
                            Atuacoes = Bico.Atuacoes,
                            TempoAtuado = Bico.TempoAtuado,
                        }).ToList(),
                        UltimoComandoRespondido = Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.Momento,
                    };
                    SalvarLog(T_Code.Atu.ToString(), logAtu, false);

                    var senLeitura = Variaveis.OperacaoEmAndamento.DispSen.Dados;
                    SensoriamentoMensagemJsonModel logSen = new SensoriamentoMensagemJsonModel()
                    {
                        Momento = Agora,
                        Conectado = senLeitura.DadosLeitura.Conectado,
                        LatenciaLoop = senLeitura.DadosLeitura.LatenciaLoop,
                        QualidadeWifi = senLeitura.DadosLeitura.QualidadeWifi,
                        Mod_ID = senLeitura.DadosLeitura.Mod_ID,
                        UltimoComandoRespondido = senLeitura.DadosLeitura.UltimoComandoRespondido,
                        Reles = new List<SensorReleModel>(senLeitura.Reles),
                        Sensores = new List<SensorModel>(senLeitura.Sensores),
                        Servos = new List<SensorServoModel>(senLeitura.Servos),
                        Sinaleiros = new List<SensorSinaleiroModel>(senLeitura.Sinaleiros),
                    };
                    SalvarLog(T_Code.Sen.ToString(), logSen, false);

                    SalvarLogCameraSolo();
                    SalvarLogCameraCaminho();

                    string ArquivoOp = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/data.lgop";
                    if (!File.Exists(ArquivoOp))
                    {
                        var data = new OperacaoDadosModel()
                        {
                            id = Variaveis.OperacaoEmAndamento.ID,
                            operacao = "operacao",
                            dir = T_Code.Dir.ToString(),
                            mov = T_Code.Mov.ToString(),
                            atu = T_Code.Atu.ToString(),
                            sen = T_Code.Sen.ToString(),
                            cam_caminho = T_Code.Snr.ToString(),
                            cam_solo = Variaveis.OperacaoEmAndamento.DispSen.Dados.CamerasSolo.Select((x, i) => x.Dispositivo.ToString() + i).ToList(),
                        };
                        File.WriteAllText(ArquivoOp, JsonConvert.SerializeObject(data));
                    }

                    Variaveis.OperacaoEmAndamento.idxLog++;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erro ao salvar log: " + ex.Message);
            }
        }

        private void SalvarLog<T>(string Arquivo, T Objeto, bool Fim)
        {
            var Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID;
            if (!Directory.Exists(Caminho))
            {
                Directory.CreateDirectory(Caminho);
            }

            Caminho += "/" + Arquivo + ".json";
            string jsonLog = JsonConvert.SerializeObject(Objeto, Formatting.None);

            if (!File.Exists(Caminho))
            {
                File.WriteAllText(Caminho, "[" + jsonLog);
            }
            else
            {
                File.AppendAllText(Caminho, "," + jsonLog + (Fim ? "]" : ""));
            }
        }

        private void SalvarLogCameraSolo()
        {
            foreach (var Camera in Variaveis.OperacaoEmAndamento.DispSen.Dados.CamerasSolo)
            {
                string camera_name = Camera.Dispositivo.ToString() + Variaveis.OperacaoEmAndamento.DispSen.Dados.CamerasSolo.IndexOf(Camera);
                string Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/" + camera_name;
                if (!Directory.Exists(Caminho))
                {
                    Directory.CreateDirectory(Caminho);
                }

                string nome = Variaveis.OperacaoEmAndamento.idxLog.ToString();
                var frames_salvar = new List<TipoFrameCamera>() { TipoFrameCamera.Rgb, TipoFrameCamera.Segmentacao };
                if (Variaveis.OperacaoEmAndamento.Parametros.Controle.RegistrarDadosPosProcessamento) frames_salvar.Add(TipoFrameCamera.Raw4);
                Camera.SaveFrames(frames_salvar, nome, Caminho);

                var cameras_conectadas = JsonConvert.DeserializeObject<Dictionary<string, object>>(RedisService.Get(CtxKey.DadosCameras));
                bool conectada = cameras_conectadas.ContainsKey(Camera?.Id ?? "");
                if (conectada)
                {
                    var cam_data = JsonConvert.DeserializeObject<Dictionary<string, object>>(RedisService.Get(RedisService.CamKey(Camera.Id)));
                    SalvarLog(camera_name, cam_data, false);
                }
            }
        }

        private void SalvarLogCameraCaminho()
        {
            var Camera = Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraCaminho;

            string Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/" + Camera.Dispositivo;
            if (!Directory.Exists(Caminho))
            {
                Directory.CreateDirectory(Caminho);
            }

            string nome = Variaveis.OperacaoEmAndamento.idxLog.ToString();
            var frames_salvar = new List<TipoFrameCamera>() { TipoFrameCamera.Rgb, TipoFrameCamera.Segmentacao };
            if (Variaveis.OperacaoEmAndamento.Parametros.Controle.RegistrarDadosPosProcessamento) frames_salvar.Add(TipoFrameCamera.Heatmap);
            Camera.SaveFrames(frames_salvar, nome, Caminho);

            var cameras_conectadas = JsonConvert.DeserializeObject<Dictionary<string, object>>(RedisService.Get(CtxKey.DadosCameras));
            bool conectada = cameras_conectadas.ContainsKey(Camera?.Id ?? "");
            if (conectada)
            {
                var cam_data = JsonConvert.DeserializeObject<Dictionary<string, object>>(RedisService.Get(RedisService.CamKey(Camera.Id)));
                SalvarLog(Camera.Dispositivo.ToString(), cam_data, false);
            }
        }


        #endregion

        #region FORMULARIO

        public void AbrirForm()
        {
            if (Variaveis.OperacaoEmAndamento.OperacaoLiberada)
            {
                frmOperacao =
                    Modo == ModoOperacao.Manual ? new frmOperacaoManual() :
                    Modo == ModoOperacao.MapaGPS ? new frmOperacaoMapaGPS() :
                    new Form();

                frmOperacao.Show();
            }
            else
            {
                MessageBox.Show(Variaveis.OperacaoEmAndamento.ErroOperacaoLiberada, "Conexão de módulos pendentes", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }
    
        public string TextoFormOperacao(string ModoNome)
        {
            var statusAtual = Variaveis.OperacaoEmAndamento.StatusAtual;

            if (statusAtual == StatusOperacao.Parametrizando)
            {
                return "Operação " + ModoNome + " - Parametrização";
            }
            else if (statusAtual == StatusOperacao.Aguardando)
            {
                return "Operação " + ModoNome + " - Iniciando em " + (Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) - DateTime.Now).TotalSeconds.ToString("0") + " segundo" + ((Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) - DateTime.Now).TotalSeconds < 1 ? "" : "s") + "...";
            }
            else if (statusAtual == StatusOperacao.Concluido)
            {
                return "Operação " + ModoNome + " - Concluída";
            }
            else if (statusAtual == StatusOperacao.EmAndamento)
            {
                return "Operação " + ModoNome + " - Em andamento";
            }
            else if (statusAtual == StatusOperacao.Parado)
            {
                return "Operação " + ModoNome + " - Parado";
            }
            else
            {
                return "Operação " + ModoNome;
            }
        }

        #endregion

        #region DIAGNOSTICO

        public static void PopularTreeView(TreeView treeView, List<ManagerWorkerMessageResponseModulosPendentesModel> modulos)
        {
            treeView.Font = new Font("Consolas", 10);
            treeView.Nodes.Clear();

            foreach (var modulo in modulos)
            {
                string nomeModulo = $"{modulo.modulo} {modulo.status} (Saúde: {modulo.saude:0}%)";
                TreeNode nodoModulo = new TreeNode(nomeModulo);

                if (modulo.saude_individual.Any())
                {
                    foreach (var item in modulo.saude_individual.Where(x => x.em_uso))
                    {
                        string nomeItem = $"{item.label} ({item.id}) {item.status} (Saúde: {item.saude:0}%)";
                        TreeNode nodoItem = new TreeNode(nomeItem);

                        // Adiciona os motivos normais (de saúde)
                        foreach (var motivo in item.motivos)
                        {
                            nodoItem.Nodes.Add(new TreeNode(motivo));
                        }

                        // Agrupamento das condições operacionais (se houver)
                        if (item.condicoes_operacionais != null && item.condicoes_operacionais.Count > 0)
                        {
                            TreeNode nodoCondicoes = new TreeNode("Condições Operacionais");

                            foreach (var cond in item.condicoes_operacionais)
                            {
                                string textoCond = $"{cond.descricao} (Valor: {cond.valor}, Severidade: {cond.severidade:0}%)";
                                nodoCondicoes.Nodes.Add(new TreeNode(textoCond));
                            }

                            nodoItem.Nodes.Add(nodoCondicoes);
                        }

                        nodoModulo.Nodes.Add(nodoItem);
                    }
                }
                else
                {
                    // Adiciona os motivos normais (de saúde)
                    foreach (var motivo in modulo.motivos)
                    {
                        nodoModulo.Nodes.Add(new TreeNode(motivo));
                    }
                }
                if (modulo.condicoes_operacionais?.Any() ?? false)
                {
                    // Agrupamento das condições operacionais (se houver)
                    if (modulo.condicoes_operacionais != null && modulo.condicoes_operacionais.Count > 0)
                    {
                        TreeNode nodoCondicoes = new TreeNode("Condições Operacionais");

                        foreach (var cond in modulo.condicoes_operacionais)
                        {
                            string textoCond = $"{cond.descricao} (Valor: {cond.valor}, Severidade: {cond.severidade:0}%)";
                            nodoCondicoes.Nodes.Add(new TreeNode(textoCond));
                        }

                        nodoModulo.Nodes.Add(nodoCondicoes);
                    }
                }

                treeView.Nodes.Add(nodoModulo);
            }

            treeView.ExpandAll();
        }


        #endregion

    }


    public class OperacaoControleModel
    {
        public double Angulo { get; set; }
        public int heartbeat { get; set; } = 1;
        public DateTime ticks_sem_resposta { get; set; } = DateTime.MinValue;
        public int RPM_SP
        {
            get
            {
                return Convert.ToInt32(VariaveisEquipamento.RPM_Max_Roda * (PercentualVelocidadeSP / 100.0));
            }
        }
        public int RPM_Motor
        {
            get
            {
                return Convert.ToInt32(RPM_SP * VariaveisEquipamento.RelacaoRPM);
            }
        }
        private double _pctVelSp;
        public double PercentualVelocidadeSP
        {
            get
            {
                return _pctVelSp;
            } 
            set
            {
                _pctVelSp = value;
            }
        }
        public double PercentualVelocidadeSPKmh
        {
            get
            {
                return FuncoesMatematicas.ConverteMsParaKmh(FuncoesMatematicas.CalculaVelocidadeMsPercentual(PercentualVelocidadeSP));
            }
        }
        public bool EmFreio { get; set; } = false;
        //public Direcao Direcao { get; set; } = Direcao.Parado;
        public List<AtuadorBicoModel> Bicos => Variaveis.OperacaoEmAndamento.DispAtu?.Dados?.BicosPulverizadores;
        public double AlturaBarra { get; set; }
        private TipoMovimentoDirecional _tipoMovimento = TipoMovimentoDirecional.Diagnostico;
        public TipoMovimentoDirecional TipoMovimento 
        { 
            get
            {
                return _tipoMovimento;
            }
            set
            {
                var DispMvd = Variaveis.OperacaoEmAndamento.DispMvd;
                if (DispMvd != null)
                {
                    if (value != _tipoMovimento)
                    {
                        var _Controle = Variaveis.OperacaoEmAndamento.Controle;
                        switch (value)
                        {
                            case TipoMovimentoDirecional.RodasDianteiras:
                                DispMvd.Dados.Modulos.ForEach(x =>
                                {
                                    x.MovMotor.Comandar = true;
                                    x.DirMotor.Comandar = x.Modulo_ID.Contains("F");
                                    x.DirMotor.Angulo_SP = x.DirMotor.Comandar ? _Controle.Angulo : 0;
                                });
                                break;
                            case TipoMovimentoDirecional.RodasTraseiras:
                                DispMvd.Dados.Modulos.ForEach(x =>
                                {
                                    x.MovMotor.Comandar = true;
                                    x.DirMotor.Comandar = x.Modulo_ID.Contains("T");
                                    x.DirMotor.Angulo_SP = x.DirMotor.Comandar ? _Controle.Angulo : 0;
                                });
                                break;
                            default:
                                DispMvd.Dados.Modulos.ForEach(x =>
                                {
                                    x.MovMotor.Comandar = true;
                                    x.DirMotor.Comandar = true;
                                    x.DirMotor.Angulo_SP = _Controle.Angulo;
                                });
                                break;
                        }
                    }
                }
                _tipoMovimento = value;
            }
        }
        public List<OperacaoControleTipoModel> TiposControle { get; set; } = new List<OperacaoControleTipoModel>();
        public List<MPCSimulacaoModel> SimulacaoMPC { get; set; } = new List<MPCSimulacaoModel>();
        public double Latencia { get; set; }
        public double ErroLateral { get; set; } = 0.0;
        public Dictionary<string, ManagerWorkerMessageResponseDebugCustoModel> DebugCustoMpc { get; set; } = new Dictionary<string, ManagerWorkerMessageResponseDebugCustoModel>();
        public List<string> Motivos { get; set; } = new List<string>();

        public void Reiniciar()
        {
            var _Parametros = Variaveis.OperacaoEmAndamento.Parametros.Controle;
            PercentualVelocidadeSP = 0; // _Parametros.MovimentoAutomatico ? 0 : _Parametros.MovVelocidadeCErvasPercent;
            Angulo = 0; // _Parametros.DirecionalAutomatico ? 0 : _Parametros.DirAnguloMaximo;
            EmFreio = false;
            TipoMovimento = TipoMovimentoDirecional.RodasDianteiras;
            TiposControle.ForEach(x =>
            {
                x.DirecaoAtual = Direcao.Parado;
                x.UltimaDirecao = Direcao.Parado;
            });
        }

        public OperacaoControleModel Clone()
        {
            return new OperacaoControleModel()
            {
                Angulo = Angulo,
                PercentualVelocidadeSP = PercentualVelocidadeSP, 
                _tipoMovimento = _tipoMovimento, 
                TipoMovimento = TipoMovimento,
                TiposControle = new List<OperacaoControleTipoModel>(TiposControle),
                SimulacaoMPC = new List<MPCSimulacaoModel>(SimulacaoMPC),
                AlturaBarra = AlturaBarra,
                heartbeat = heartbeat,
                ticks_sem_resposta = ticks_sem_resposta,
                Latencia = Latencia,
                EmFreio = EmFreio,
                ErroLateral = ErroLateral,
                DebugCustoMpc = new Dictionary<string, ManagerWorkerMessageResponseDebugCustoModel>(DebugCustoMpc ?? new Dictionary<string, ManagerWorkerMessageResponseDebugCustoModel>()),
                Motivos = new List<string>(Motivos ?? new List<string>())
            };
        }
    }

    public class OperacaoControleTipoModel
    {
        public T_Code Tipo { get; set; }
        public int DelayEnvioComandoBase { get; set; }
        public int DelayEnvioComando { get; set; }
        public int DelayEnvioComandoExtra { get; set; }
        public DateTime UltimoComando { get; set; }
        public List<string> Comandos { get; set; }
        public Direcao DirecaoAtual { get; set; } = Direcao.Parado;
        public Direcao UltimaDirecao { get; set; } = Direcao.Parado;
    }

    public class OperacaoModulosMandatoriosModel
    {
        public T_Code Dispositivo { get; set; }
        public bool Mandatorio { get; set; }
        public bool Utilizar { get; set; }
        public bool Conectado { get; set; }
        public Dictionary<string, (bool, bool)> ComponentesEmUso { get; set; }
    }

    public class OperacaoParametrosMandatoriosModel
    {
        public ParametrosOperacao Parametro { get; set; }
        public bool Mandatorio { get; set; }
        public bool Utilizar { get; set; }
    }

    public class OperacaoComandoBaseModel
    {
        public DateTime Momento { get; set; }
        public BotoesJoystick Tecla { get; set; }
        public bool Solto { get; set; }
        public T_Code Dispositivo { get; set; }
        public bool Emergencia { get; set; }
        public bool Pausa { get; set; }
        public string _comp_id { get; set; }
        public dynamic _comp_value { get; set; }
        public OperacaoParametrosModel Parametros { get; set; }
        public OperacaoComandoBaseControleModel Controle { get; set; }
    }

    public class OperacaoComandoBaseControleModel
    {
        public double? PercentualVelocidadeSP { get; set; }
        public double? AnguloSP { get; set; }
        public TipoMovimentoDirecional? TipoMovimentoDirecional { get; set; }
        public bool? EmFreio { get; set; }
        public bool? Estado { get; set; }
        public double? Altura { get; set; }
    }


    public class OperacaoDadosModel
    {
        public string id { get; set; }
        public string operacao { get; set; }
        public string dir { get; set; }
        public string mov { get; set; }
        public string atu { get; set; }
        public string sen { get; set; }
        public string cam_caminho { get; set; }
        public List<string> cam_solo { get; set; }
    }

    public class OperacaoSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public ModoOperacao Modo { get; set; }
        public StatusModulo Status { get; set; }
        public string ErroOperacaoLiberada { get; set; }
        public bool OperacaoLiberada { get; set; }
        public bool OperacaoIniciada { get; set; }
        public bool Emergencia { get; set; }
        public bool Pausa { get; set; }
        public StatusOperacao StatusOperacao { get; set; } = StatusOperacao.Parado;
        public DateTime DataInicio { get; set; }
        public DateTime DataFim { get; set; }
        public double TempoAguardandoSeg { get; set; }
        public double TempoDecorridoSeg { get; set; }
        public DateTime TempoDecorrido
        {
            get
            {
                return new DateTime().AddSeconds(TempoDecorridoSeg);
            }
        }
        public OperacaoSensoriamentoLogImuModel IMU { get; set; }
        public OperacaoSensoriamentoLogAtuModel Atuador { get; set; }
        public OperacaoSensoriamentoLogMovModel Movimentacao { get; set; }
        public OperacaoSensoriamentoLogDirModel Direcional { get; set; }
        public OperacaoSensoriamentoLogBateriaModel Bateria { get; set; }
        public OperacaoSensoriamentoLogTrajetoriaModel Trajetoria { get; set; }
        public LraSensoriamentoLogModel DadosLoRa { get; set; }
        public GPSModel Gps { get; set; }
        public PerformanceModel DadosPerformance { get; set; } = new PerformanceModel();
        public OperacaoControleModel Controle { get; set; }
        public VisualWorkerModel OperadorVisual { get; set; }
        public WeedWorkerModel OperadorErvas { get; set; }
        public LivoxModel LivoxLidar { get; set; }
        public List<OperacaoModulosMandatoriosModel> ModulosMandatorios { get; set; }
        public List<OperacaoParametrosMandatoriosModel> ParametrosMandatorios { get; set; }
        public List<ManagerWorkerMessageResponseModulosPendentesModel> ModulosSaude { get; set; }
        public List<DispositivoDetalhesModel> DispositivosMapeados { get; set; }
        public Dictionary<T_Code, Dictionary<string, bool>> ModsCalibragem { get; set; }
        public bool CanSerialAtivado { get; set; }
        public List<OperacaoSensoriamentoLogErrosModel> Logs { get; set; }
        public DateTime UltimoRegistroLog { get; set; } = DateTime.MinValue;
        public CoolerControlDataModel CoolerControl { get; set; }

        public void InserirLog(T_Code dispositivo, StatusModulo status, double saude, string mensagem, string id = null, string condicoes = null)
        {
            if (Logs == null)
                Logs = new List<OperacaoSensoriamentoLogErrosModel>();

            Logs.Add(new OperacaoSensoriamentoLogErrosModel()
            {
                Momento = DateTime.Now,
                Dispositivo = dispositivo,
                ID = id,
                Status = status,
                Saude = saude,
                Mensagem = mensagem,
                Condicoes = condicoes
            });
        }


        public void AtualizarDados()
        {
            Variaveis.OperacaoEmAndamento.AtualizarDadosContexto();
            Variaveis.OperacaoEmAndamento.DadosPerformance.AtualizarDadosPerformance();
            VisualWorkerService.AtualizarAnalise();
            WeedWorkerService.AtualizarAnalise();
            GPSService.AtualizaDadosRedis();
            LivoxManagerProcess.AtualizarLeitura();
            MovimentacaoMovimentoCompensadoModel.AtualizarDados();
            DalyBMSService.AtualizarDados();

            var _Trajetoria = Variaveis.OperacaoEmAndamento.Trajetoria;
            var _DispMvd = Variaveis.OperacaoEmAndamento.DispMvd;
            var _DispAtu = Variaveis.OperacaoEmAndamento.DispAtu;
            var _DispSen = Variaveis.OperacaoEmAndamento.DispSen;
            var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle; 
            var _Controle = Variaveis.OperacaoEmAndamento.Controle;
            var _Bateria = _DispSen?.Dados?.ContadorCarga;
            var _Reservatorio = _DispAtu?.Dados?.ContadorCarga;
            var _Cooler = _DispSen?.Dados?.CoolerControl;

            double tmp_max = Math.Max(Variaveis.OperacaoEmAndamento.DadosPerformance?.GPU_temp ?? 0, Variaveis.OperacaoEmAndamento.DadosPerformance?.CPU_temp ?? 0);
            _DispMvd?.Dados?.AtualizarDadosFreio();
            _DispSen?.Dados?.AtualizarStatusSinaleiros(Variaveis.OperacaoEmAndamento.Modo, Variaveis.OperacaoEmAndamento.StatusAtual);
            _DispAtu?.Dados?.AtualizaTempoAtuadoGeral();
            _Cooler?.Atualizar(tmp_max, DateTime.Now);
            _Bateria?.AtualizarConsumo(_DispMvd?.Dados?.DistanciaPercorridaTotal ?? 0);
            _Reservatorio?.AtualizarConsumo(_DispMvd?.Dados?.DistanciaPercorridaTotal ?? 0, Variaveis.OperacaoEmAndamento.TempoDecorridoSegs);
            _Trajetoria?.AtualizarDadosAutonomiaCorredor();

            //var sIMU = LivoxManagerProcess.DadosLeitura.imu;
            string imu = RedisService.Get(RedisService.ModKey(T_Code.Imu)) ?? "";
            var sIMU = JsonConvert.DeserializeObject<OAKImuModel>(imu);
            bool imu_iniciado = sIMU?.timestamp > 0 && HealthWorkerService.ModulosSaude.FirstOrDefault(x => x.modulo == T_Code.Imu)?.status != StatusModulo.Desconectado;
            var dadosIMU = sIMU != null ? new OperacaoSensoriamentoLogImuModel()
            {
                Iniciado = imu_iniciado, 
                InclinacaoLateral = imu_iniciado ? sIMU.pitch : 0,
                InclinacaoFrontal = imu_iniciado ? sIMU.roll : 0,
                Rotacao = imu_iniciado ? sIMU.yaw : 0,
                RotacaoCorrigida = imu_iniciado ? sIMU.yaw_fixed : 0,
                EmMovimento = imu_iniciado ? sIMU.em_movimento : false,
                IndiceMovimento = imu_iniciado ? sIMU.movimento_idx : 0,
                IndiceRugosidade = imu_iniciado ? sIMU.rugosidade_idx : 0,
                IndiceEstabilidade = imu_iniciado ? sIMU.estabilidade_idx : 0,
                IndiceImpacto = imu_iniciado ? sIMU.impacto_idx : 0,
            } : new OperacaoSensoriamentoLogImuModel();

            var bombaLinha = _DispAtu?.Dados?.BombasPressurizadoras?.FirstOrDefault(x => x.ID == "BMBLN");
            var dadosAtuador = _DispAtu != null ? new OperacaoSensoriamentoLogAtuModel()
            {
                QtdCamerasSolo = _DispSen.Dados.CamerasSolo.Count, 
                CapacidadeReservatorio = VariaveisEquipamento.CapacidadeReservatorio,
                HerbicidaConsumido = _DispAtu.Dados.VolumeVazadoML,
                PercentualErvasTerreno = _DispAtu.Dados.PercentualErvasTerreno,
                HerbicidaPorErva = _Reservatorio.HerbicidaPorAtuacao,
                ErvasNoRadar = WeedWorkerService.DadosLeitura?.Analise?.ervas_no_radar ?? false,
                PercentualErvasNoRadar = WeedWorkerService.DadosLeitura?.Analise?.estatisticas?.erva?.ema_global ?? 0,
                PercentualReservatorio = _Reservatorio.PercentualAtual,
                VolumeReservatorio = _Reservatorio.VolumeAtual_L,
                MassaReservatorio = _Reservatorio.MassaAtual_Kg,
                PressaoLinha = _DispAtu.Dados.PressaoLinha,
                PressaoLinhaCalc = _DispAtu.Dados.PressaoLinhaCalc, 
                VazaoInstantanea = _DispAtu.Dados.VazaoFluxoMLpSInstantanea,
                VazaoInstantaneaCalc = _DispAtu.Dados.VazaoFluxoMLpSInstantaneaCalc,
                VazaoMedia = _DispAtu.Dados.VazaoMediaMLs,
                TempoBombaAtuada = _DispAtu.Dados.TempoAtuado,
                ComandoBomba = bombaLinha.ComandoAtuar,
                LeituraComandoBomba = bombaLinha._EstadoLeitura == Estado.Ligado,
                LeituraPotenciaBomba = FuncoesMatematicas.Clamp(bombaLinha._Potencia, 0, 100),
                VolumeVazaoMl = _DispAtu.Dados.VolumeVazadoML,
                BombaCavitada = _DispAtu.Dados.Conectado && _DispAtu.Dados.PressaoLinha < pControle.AtuPressaoLinha && _DispAtu.Dados.PressaoLinha < VariaveisEquipamento.PressaoMinimaCavitacao && bombaLinha._EstadoLeitura == Estado.Ligado && bombaLinha._Potencia > 20,
                Iniciados = _DispAtu.Dados.Sensores.Select(s => new { s.ID, s.Inicializado }).Union(_DispAtu.Dados.BicosPulverizadores.Select(b => new { b.ID, b.Inicializado })).Union(_DispAtu.Dados.BombasPressurizadoras.Select(b => new { b.ID, b.Inicializado })).ToDictionary(x => x.ID, x => x.Inicializado),
                AnguloBarraEsquerda = _DispAtu.Dados.AnguloBarraEsquerda,
                AnguloBarraDireita = _DispAtu.Dados.AnguloBarraDireita,
                AnguloBarraAltura = _DispAtu.Dados.AnguloBarraAltura,
                UltimoComandoRespondido = _DispAtu.Dados.DadosLeitura?.UltimoComandoRespondido ?? DateTime.MinValue,
                LPorMetro = _Reservatorio.LPorMetro,
                LPorMinuto = _Reservatorio.LPorMinuto,
                TempoEstimadoRestanteMinutos = _Reservatorio.TempoEstimadoMinutosPulverizando,
                DistanciaEstimadaRestanteMetros = _Reservatorio.DistanciaEstimadaRestantePulverizando_m,
                Bicos = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BicosPulverizadores.Select(Bico => new AtuBicoSensoriamentoLogModel()
                {
                    ID = Bico.ID,
                    Inicializado = Bico.Inicializado,
                    Comandar = Bico.Comandar,
                    Atuado = Bico.ComandoAtuar,
                    MediaNivelFluxo = Bico.VazaoMediaMLs,
                    Posicao = Bico.Posicao,
                    StatusBico = Bico._EstadoLeitura == Estado.Ligado,
                    Atuacoes = Bico.Atuacoes,
                    TempoAtuado = Bico.TempoAtuado,
                    AnguloAbertura = Bico.AnguloAbertura,
                    AnguloControle = Bico.AnguloControle,
                }).ToList(),
            } : new OperacaoSensoriamentoLogAtuModel();

            var dadosMovimentacao = _DispMvd != null ? new OperacaoSensoriamentoLogMovModel()
            {
                VelocidadeMedia = _DispMvd.Dados.VelocidadeMedia,
                RPMMedio = _DispMvd.Dados.Modulos.Where(x => x.MovMotor.Inicializado).DefaultIfEmpty()?.Average(x => x?.MovMotor?.RPM_Roda ?? 0) ?? 0,
                TemperaturaMedia = _DispMvd.Dados.Modulos.Where(x => x.MovMotor.Inicializado).DefaultIfEmpty()?.Average(x => x?.MovMotor?.Temperatura ?? 0) ?? 0,
                TempoMovimentoSegs = _DispMvd.Dados.TempoEmAtividade,
                DistanciaPercorridaTotal = _DispMvd.Dados.DistanciaPercorridaTotal, 
                DistanciaPercorridaParcial = _DispMvd.Dados.DistanciaPercorridaParcial, 
                Esq_Status = _DispMvd.Dados.StatusModulosMOV(Direcao.Esquerda),
                Dir_Status = _DispMvd.Dados.StatusModulosMOV(Direcao.Direita),
                Dados = _DispMvd.Dados.Modulos.Select(x => new OperacaoSensoriamentoLogMovDadosModel()
                {
                    Mod_ID = x.MovMotor.Mod_ID,
                    ID = x.MovMotor._EnderecoCAN_Rx, 
                    Iniciado = x.MovMotor.Inicializado, 
                    Tensao = x.MovMotor.Tensao, 
                    Corrente_Barramento = x.MovMotor.Corrente_Barramento, 
                    Corrente_Motor = x.MovMotor.Corrente_Motor,
                    Potencia = x.MovMotor.Potencia, 
                    CicloTrabalho = x.MovMotor.CicloTrabalho, 
                    TemperaturaDriver = x.MovMotor.TemperaturaDriver, 
                    RPM_Motor = x.MovMotor.RPM_Motor,
                    RPM_Roda = x.MovMotor.RPM_Roda, 
                    VelocidadeInstantaneaMs = x.MovMotor.VelocidadeInstantanea,
                    UltimoComandoRespondido = x.MovMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
                }).ToList(),
            } : new OperacaoSensoriamentoLogMovModel();

            var dadosDirecional = _DispMvd != null ? new OperacaoSensoriamentoLogDirModel()
            {
                AnguloMedio = _DispMvd.Dados.Modulos.Where(x => x.DirMotor.Inicializado && x.DirMotor.Comandar).DefaultIfEmpty().Average(x => Math.Abs(x?.DirMotor?.AnguloLeitura ?? 0)),
                Status = _DispMvd.Dados.StatusModulosDIR(_Controle.TipoMovimento),
                Dados = _DispMvd.Dados.Modulos.Select(x => new DirSensoriamentoLogModel()
                {
                    Mod_ID = x.DirMotor.Mod_ID, 
                    ID = x.DirMotor._EnderecoCAN_Rx,
                    Iniciado = x.DirMotor.Inicializado, 
                    AnguloDriver = x.DirMotor.AnguloDriver,
                    AnguloReal = x.DirMotor.AnguloReal, 
                    Angulo_SP = x.DirMotor.Angulo_SP, 
                    Sentido = x.DirMotor.Sentido, 
                    Sentido_SP = x.DirMotor.Sentido_SP, 
                    SentidoReal = x.DirMotor.SentidoReal,
                    FolgaMecanica = x.DirMotor.FolgaMecanica,
                    AnguloFolgaCompensar = x.DirMotor.AnguloFolgaCompensar,
                    AnguloLeitura = x.DirMotor.AnguloLeitura, 
                    Controlar = x.DirMotor.Comandar, 
                    UltimoComandoRespondido = x.DirMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue, 
                    Velocidade = x.DirMotor.Velocidade,
                }).ToList()
            } : new OperacaoSensoriamentoLogDirModel();

            var dadosBateria = _Bateria != null ? new OperacaoSensoriamentoLogBateriaModel()
            {
                Iniciado = _Bateria.Iniciado,
                BmsLigado = _Bateria.BmsLigado,
                _dt = _Bateria._dt,
                PercentualBateria = _Bateria.PercentualBateria,
                PercentualBateriaConsumida = _Bateria.PercentualConsumido,
                TempoEstimadoRestanteMinutos = _Bateria.TempoEstimadoMinutos,
                CorrenteInstantanea = _Bateria.CorrenteInstantanea,
                TensaoInstantanea = _Bateria.TensaoInstantanea,
                PotenciaInstantanea = _Bateria.PotenciaInstantanea,
                EnergiaConsumida_Wh = _Bateria.EnergiaConsumida_Wh,
                WhPorMetro = _Bateria.WhPorMetro,
                DistanciaEstimadaRestanteMetros = _Bateria.DistanciaEstimadaRestante_m,
                Temperatura = _Bateria.Temperatura,
                Barramentos = _DispSen?.Dados?.Sensores?.Where(x => x.Componente == S_Code.sCOR)?.Select(x => new OperacaoSensoriamentoLogBateriaBarramentoModel()
                {
                    ID = x.ID,
                    Iniciado = x.Inicializado, 
                    Descricao = x.Descricao, 
                    Tensao = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Tensao)?.atual?.valor ?? -1,
                    Corrente = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Corrente)?.atual?.valor ?? -1,
                    Potencia = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Potencia)?.atual?.valor ?? -1,
                    Energia = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Energia)?.atual?.valor ?? -1,
                    Temperatura = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Temperatura)?.atual?.valor ?? -1,
                }).ToList()
            } : new OperacaoSensoriamentoLogBateriaModel();

            var dadosTrajetoria = new OperacaoSensoriamentoLogTrajetoriaModel()
            {
                StatusCarro = _Trajetoria?.StatusAtual ?? StatusCarroMapa.Parado,
                TrajetoriaConcluida = _Trajetoria?.TrajeotiraConcluida ?? false, 
                DistanciaDireita = _Trajetoria?.DistanciaDireita ?? 0,
                DistanciaEsquerda = _Trajetoria?.DistanciaEsquerda ?? 0,
                ProgressoTrajeto = FuncoesMatematicas.Clamp(_Trajetoria?.PercentualTrajetoria ?? 0, 0, 100),
                CorredorAtual = _Trajetoria?.CorredorAtual?.Clone(false) ?? new CorredorTrajetoriaModel(),
                DirecaoCaminho = _Trajetoria?.DirecaoCaminho ?? DirecaoCarroRua.Parado,
                AnguloCaminho = _Trajetoria?.AnguloCaminho ?? 0,
                AnguloMedioCorredor = _Trajetoria?.AnguloMedioCorredor ?? 0, 
                DistanciaTotal = _Trajetoria?.DistanciaTotal ?? 0,
                DistanciaPercorrida = _Trajetoria?.DistanciaPercorrida ?? 0, 
                DistanciaRestante = _Trajetoria?.DistanciaRestante ?? 0,
                NaMargemDoCorredor = _Trajetoria?.NaMargemDoCorredor ?? false,
                ManobrandoEntreRuas = _Trajetoria?.ManobrandoEntreRuas ?? false, 
                TempoEstimadoRestante = _Trajetoria?.TempoEstimadoRestante ?? "", 
                TempoEstimadoOperacao = _Trajetoria?.TempoEstimadoOperacao ?? "", 
                ProximoPonto = _Trajetoria?.ProximoPonto?.Clone() ?? new PontoTrajetoriaModel(TipoPontoRua.PosicaoRobo),
                PontoMaisProximo = _Trajetoria?.PontoMaisProximo?.Clone() ?? new PontoTrajetoriaModel(TipoPontoRua.PosicaoRobo),
                PontoAtual = _Trajetoria?.PontoAtual?.Clone() ?? new PontoTrajetoriaModel(TipoPontoRua.PosicaoRobo),
                ErroLateralAngular = _Trajetoria?.ErroLateralAngular ?? 0,
                ErroOrientacaoAngular = _Trajetoria?.ErroOrientacaoAngular ?? 0,
                ErroOrientacaoAngularCombinado = _Trajetoria?.ErroOrientacaoAngularCombinado ?? 0,
                ErroOrientacaoAngularCaminho = _Trajetoria?.ErroOrientacaoAngularCaminho ?? 0,
                ErroOrientacaoAngularProximoPonto = _Trajetoria?.ErroOrientacaoAngularProximoPonto ?? 0,
                PercentualOperacao = _Trajetoria?.PercentualTrajetoria ?? 0, 
                PercentualRuaAtual = _Trajetoria?.CorredorAtual?.Progresso ?? 0, 
                IdxRuaAtual = _Trajetoria?.CorredorAtual?.Idx ?? 0,
                QtdPontos = _Trajetoria?.TrajetoriaFixa?.Count ?? 0,
                DistanciaErroMapaCana = _Trajetoria?.DistanciaErroMapaPlantacao ?? 0,
                PrimeiroPontoDentroMapa = _Trajetoria?.PrimeiroPontoDentroMapa?.Clone() ?? new GPSModel(),
                PrimeiroPontoDentroCana = _Trajetoria?.PrimeiroPontoDentroCana?.Clone() ?? new GPSModel(),
                AutonomiaCooredor = _Trajetoria?.AutonomiaCorredor?.Clone(),
            };

            var dadosGps = GPSService.UltimaLeitura.Clone();

            var dadosControle = _Controle.Clone();

            var dadosPerformance = Variaveis.OperacaoEmAndamento.DadosPerformance.Clone();

            var dadosLora = new LraSensoriamentoLogModel()
            {
                Momento = DateTime.Now, 
                Conectado = _DispSen?.Dados?.loRaService?.Conectado ?? false, 
                Configurado = _DispSen?.Dados?.loRaService?.Configurado ?? false, 
                EnderecoCarro = _DispSen?.Dados?.loRaService?.ParametrosGet?.address ?? 0x00, 
                EnderecoBase = _DispSen?.Dados?.LoRaParametrosBase?.address ?? 0x00, 
                PosicaoBase = VariaveisOperacao.PosicaoBase.Clone(), 
                UltimoComandoRespondido = VariaveisOperacao.PosicaoBase.Momento, 
            };

            var dadosLivox = LivoxManagerProcess.DadosLeitura?.Clone();

            var dadosCooler = _Cooler?.GetResumo();

            OperacaoSensoriamentoLogModel dadosAtualizados = new OperacaoSensoriamentoLogModel()
            {
                Momento = DateTime.Now,
                Modo = Variaveis.OperacaoEmAndamento.Modo, 
                Status = Variaveis.OperacaoEmAndamento.Status,
                OperacaoLiberada = Variaveis.OperacaoEmAndamento.OperacaoLiberada,
                OperacaoIniciada = Variaveis.OperacaoEmAndamento.Iniciado,
                Emergencia = Variaveis.OperacaoEmAndamento.Emergencia, 
                Pausa = Variaveis.OperacaoEmAndamento.Pausa, 
                ErroOperacaoLiberada = Variaveis.OperacaoEmAndamento.ErroOperacaoLiberada,
                StatusOperacao = Variaveis.OperacaoEmAndamento.StatusAtual,
                DataInicio = Variaveis.OperacaoEmAndamento.DataInicio, 
                DataFim = Variaveis.OperacaoEmAndamento.DataFim, 
                TempoAguardandoSeg  = Variaveis.OperacaoEmAndamento.TempoAguardandoSegs,
                TempoDecorridoSeg = Variaveis.OperacaoEmAndamento.TempoDecorridoSegs, 
                CanSerialAtivado = CanManager.UseCanSerial, 
                IMU = dadosIMU, 
                Atuador = dadosAtuador,
                Movimentacao = dadosMovimentacao,
                Direcional = dadosDirecional, 
                Bateria = dadosBateria,
                Trajetoria = dadosTrajetoria,
                Gps = dadosGps,
                OperadorVisual = VisualWorkerService.DadosLeitura.Clone(),
                OperadorErvas = WeedWorkerService.DadosLeitura.Clone(),
                Controle = dadosControle,
                DadosPerformance = dadosPerformance,
                DadosLoRa = dadosLora, 
                LivoxLidar = dadosLivox, 
                ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>(Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios ?? new List<OperacaoModulosMandatoriosModel>()),
                ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>(Variaveis.OperacaoEmAndamento.Parametros.ParametrosMandatorios ?? new List<OperacaoParametrosMandatoriosModel>()),
                ModulosSaude = HealthWorkerService.ModulosSaude.ToList(), 
                DispositivosMapeados = new List<DispositivoDetalhesModel>(SerialService.DispositivosMapeados),
                ModsCalibragem = new Dictionary<T_Code, Dictionary<string, bool>>(Variaveis.OperacaoEmAndamento.ModsCalibragem),
                Logs = Logs != null ? Logs.Where(x => x.Momento >= UltimoRegistroLog).ToList() : new List<OperacaoSensoriamentoLogErrosModel>(),
                CoolerControl = dadosCooler
            };

            Variaveis.OperacaoEmAndamento.Sensoriamento = dadosAtualizados;
        }

        public OperacaoSensoriamentoLogModel Clone(bool comSonar = false)
        {
            var vw = OperadorVisual?.Clone();
            if (vw != null)
                vw.CameraFrames = new Dictionary<TipoFrameCamera, OAKCameraFrameModel>();
            var ww = OperadorErvas?.Clone();
            if (ww != null)
                ww.CameraFrames = new Dictionary<TipoFrameCamera, OAKCameraFrameModel>();

            return new OperacaoSensoriamentoLogModel()
            {
                Modo = Modo, 
                Status = Status,
                Momento = Momento,
                ErroOperacaoLiberada = ErroOperacaoLiberada,
                OperacaoLiberada = OperacaoLiberada, 
                OperacaoIniciada = OperacaoIniciada, 
                Emergencia = Emergencia, 
                Pausa = Pausa, 
                StatusOperacao = StatusOperacao,
                DataInicio = DataInicio, 
                DataFim = DataFim, 
                TempoAguardandoSeg = TempoAguardandoSeg, 
                TempoDecorridoSeg = TempoDecorridoSeg, 
                CanSerialAtivado = CanSerialAtivado,
                Atuador = Atuador?.Clone(),
                Movimentacao = Movimentacao?.Clone(), 
                Direcional = Direcional?.Clone(),
                Bateria = Bateria?.Clone(),
                Trajetoria = Trajetoria?.Clone(),
                Gps = Gps?.Clone(), 
                OperadorVisual = vw,
                OperadorErvas = ww,
                Controle = Controle?.Clone(),
                DadosPerformance = DadosPerformance?.Clone(),
                IMU = IMU?.Clone(),
                DadosLoRa = DadosLoRa?.Clone(),
                LivoxLidar = LivoxLidar?.Clone(),
                ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>(ModulosMandatorios),
                ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>(ParametrosMandatorios),
                ModulosSaude = new List<ManagerWorkerMessageResponseModulosPendentesModel>(ModulosSaude), 
                DispositivosMapeados = new List<DispositivoDetalhesModel>(DispositivosMapeados), 
                ModsCalibragem = new Dictionary<T_Code, Dictionary<string, bool>>(ModsCalibragem),
                Logs = new List<OperacaoSensoriamentoLogErrosModel>(Logs ?? new List<OperacaoSensoriamentoLogErrosModel>()),
                UltimoRegistroLog = UltimoRegistroLog,
                CoolerControl = CoolerControl?.Clone(),
            };
        }
    
    }

    public class OperacaoSensoriamentoLogImuModel
    {
        public bool Iniciado { get; set; }
        public double InclinacaoLateral { get; set; }
        public double InclinacaoFrontal { get; set; }
        public double Rotacao { get; set; }
        public double RotacaoCorrigida { get; set; }
        public bool EmMovimento { get; set; }
        public double IndiceMovimento { get; set; }
        public double IndiceRugosidade { get; set; }
        public double IndiceEstabilidade { get; set; }
        public double IndiceImpacto { get; set; }

        public OperacaoSensoriamentoLogImuModel Clone()
        {
            return new OperacaoSensoriamentoLogImuModel()
            {
                Iniciado = Iniciado, 
                InclinacaoLateral = InclinacaoLateral, 
                InclinacaoFrontal = InclinacaoFrontal, 
                Rotacao = Rotacao,
                RotacaoCorrigida = RotacaoCorrigida, 
                EmMovimento = EmMovimento,
                IndiceMovimento = IndiceMovimento,
                IndiceImpacto = IndiceImpacto,
                IndiceEstabilidade = IndiceEstabilidade,
                IndiceRugosidade = IndiceRugosidade,
            };
        }
    }

    public class OperacaoSensoriamentoLogAtuModel
    {
        public int QtdCamerasSolo { get; set; }
        public double CapacidadeReservatorio { get; set; }
        public double HerbicidaConsumido { get; set; }
        public double PercentualErvasTerreno { get; set; }
        public double HerbicidaPorErva { get; set; }
        public bool ErvasNoRadar { get; set; }
        public double PercentualErvasNoRadar { get; set; }
        public double PercentualReservatorio { get; set; }
        public double MassaReservatorio { get; set; }
        public double VolumeReservatorio { get; set; }
        public double PressaoLinha { get; set; }
        public double PressaoLinhaCalc { get; set; }
        public double VazaoInstantanea { get; set; }
        public double VazaoInstantaneaCalc { get; set; }
        public double VazaoMedia { get; set; }
        public double TempoBombaAtuada { get; set; }
        public bool ComandoBomba { get; set; }
        public bool LeituraComandoBomba { get; set; }
        public double LeituraPotenciaBomba { get; set; }
        public double VolumeVazaoMl { get; set; }
        public double AnguloBarraEsquerda { get; set; }
        public double AnguloBarraDireita { get; set; }
        public double AnguloBarraAltura { get; set; }
        public double LPorMetro { get; set; }
        public double LPorMinuto { get; set; }
        public double TempoEstimadoRestanteMinutos { get; set; }
        public double DistanciaEstimadaRestanteMetros { get; set; }
        public bool BombaCavitada { get; set; }
        public Dictionary<string, bool> Iniciados { get; set; }
        public List<AtuBicoSensoriamentoLogModel> Bicos { get; set; }
        public DateTime UltimoComandoRespondido { get; set; }

        public OperacaoSensoriamentoLogAtuModel Clone()
        {
            return new OperacaoSensoriamentoLogAtuModel()
            {
                QtdCamerasSolo = QtdCamerasSolo, 
                CapacidadeReservatorio = CapacidadeReservatorio,
                ErvasNoRadar = ErvasNoRadar, 
                PercentualErvasNoRadar = PercentualErvasNoRadar, 
                HerbicidaConsumido = HerbicidaConsumido, 
                HerbicidaPorErva = HerbicidaPorErva, 
                PercentualErvasTerreno = PercentualErvasTerreno,
                PercentualReservatorio = PercentualReservatorio,
                VolumeReservatorio = VolumeReservatorio,
                MassaReservatorio = MassaReservatorio,
                PressaoLinha = PressaoLinha,
                PressaoLinhaCalc = PressaoLinhaCalc,
                VazaoInstantanea = VazaoInstantanea, 
                VazaoInstantaneaCalc = VazaoInstantaneaCalc,
                VazaoMedia = VazaoMedia,
                TempoBombaAtuada = TempoBombaAtuada, 
                ComandoBomba = ComandoBomba,
                LeituraComandoBomba = LeituraComandoBomba,
                LeituraPotenciaBomba = LeituraPotenciaBomba,
                VolumeVazaoMl = VolumeVazaoMl,
                AnguloBarraEsquerda = AnguloBarraEsquerda,
                AnguloBarraDireita = AnguloBarraDireita,
                AnguloBarraAltura = AnguloBarraAltura,
                BombaCavitada = BombaCavitada,
                Iniciados = new Dictionary<string, bool>(Iniciados ?? new Dictionary<string, bool>()),
                UltimoComandoRespondido = UltimoComandoRespondido,
                LPorMetro = LPorMetro, 
                LPorMinuto = LPorMinuto, 
                TempoEstimadoRestanteMinutos = TempoEstimadoRestanteMinutos, 
                DistanciaEstimadaRestanteMetros = DistanciaEstimadaRestanteMetros,
                Bicos = new List<AtuBicoSensoriamentoLogModel>(Bicos ?? new List<AtuBicoSensoriamentoLogModel>())
            };
        }
    }

    public class OperacaoSensoriamentoLogMovModel
    {
        public double VelocidadeMedia { get; set; }
        public double RPMMedio { get; set; }
        public double TempoMovimentoSegs { get; set; }
        public double DistanciaPercorridaTotal { get; set; }
        public double DistanciaPercorridaParcial { get; set; }
        public double TemperaturaMedia { get; set; }
        public DateTime TempoMovimento
        {
            get
            {
                return new DateTime().AddSeconds(TempoMovimentoSegs);
            }
        }
        public (bool, List<string>) Esq_Status { get; set; }
        public (bool, List<string>) Dir_Status { get; set; }
        public List<OperacaoSensoriamentoLogMovDadosModel> Dados { get; set; }

        public OperacaoSensoriamentoLogMovModel Clone()
        {
            return new OperacaoSensoriamentoLogMovModel()
            {
                VelocidadeMedia = VelocidadeMedia, 
                RPMMedio = RPMMedio, 
                TempoMovimentoSegs = TempoMovimentoSegs, 
                TemperaturaMedia = TemperaturaMedia, 
                Dir_Status = Dir_Status, 
                Esq_Status = Esq_Status, 
                DistanciaPercorridaParcial = DistanciaPercorridaParcial, 
                DistanciaPercorridaTotal = DistanciaPercorridaTotal,
                Dados = new List<OperacaoSensoriamentoLogMovDadosModel>(Dados ?? new List<OperacaoSensoriamentoLogMovDadosModel>())
            };
        }
    }

    public class OperacaoSensoriamentoLogMovDadosModel
    {
        public string Mod_ID { get; set; }
        public byte ID { get; set; }
        public bool Iniciado { get; set; }
        public bool Controlar { get; set; }
        public double RPM_Roda { get; set; }
        public double TemperaturaDriver { get; set; }
        public double Tensao { get; set; }
        public double Corrente_Barramento { get; set; }
        public double Corrente_Motor { get; set; }
        public double Potencia { get; set; }
        public double CicloTrabalho { get; set; }
        public double RPM_Motor { get; set; }
        public double VelocidadeInstantaneaMs { get; set; }
        public DateTime UltimoComandoRespondido { get; set; }
    }

    public class OperacaoSensoriamentoLogDirModel
    {
        public double AnguloMedio { get; set; }
        public (bool, List<string>) Status { get; set; }
        public List<DirSensoriamentoLogModel> Dados { get; set; }

        public OperacaoSensoriamentoLogDirModel Clone()
        {
            return new OperacaoSensoriamentoLogDirModel()
            {
                AnguloMedio = AnguloMedio,
                Status = Status,
                Dados = new List<DirSensoriamentoLogModel>(Dados ?? new List<DirSensoriamentoLogModel>())
            };
        }
    }

    public class OperacaoSensoriamentoLogBateriaModel
    {
        public bool Iniciado { get; set; }
        public bool BmsLigado { get; set; }
        public double _dt { get; set; }
        public double PercentualBateria { get; set; }
        public double PercentualBateriaConsumida { get; set; }
        public double CorrenteInstantanea { get; set; }
        public double TensaoInstantanea { get; set; }
        public double PotenciaInstantanea { get; set; }
        public double EnergiaConsumida_Wh { get; set; }
        public double WhPorMetro { get; set; }
        public double TempoEstimadoRestanteMinutos { get; set; }
        public double DistanciaEstimadaRestanteMetros { get; set; }
        public double Temperatura { get; set; }
        public List<OperacaoSensoriamentoLogBateriaBarramentoModel> Barramentos { get; set; }

        public OperacaoSensoriamentoLogBateriaModel Clone()
        {
            return new OperacaoSensoriamentoLogBateriaModel()
            {
                Iniciado = Iniciado,
                BmsLigado = BmsLigado,
                _dt = _dt,
                PercentualBateriaConsumida = PercentualBateriaConsumida, 
                PercentualBateria = PercentualBateria,
                CorrenteInstantanea = CorrenteInstantanea,
                TensaoInstantanea = TensaoInstantanea,
                PotenciaInstantanea = PotenciaInstantanea, 
                EnergiaConsumida_Wh = EnergiaConsumida_Wh,
                WhPorMetro = WhPorMetro,
                TempoEstimadoRestanteMinutos = TempoEstimadoRestanteMinutos,
                DistanciaEstimadaRestanteMetros = DistanciaEstimadaRestanteMetros,
                Temperatura = Temperatura,
                Barramentos = new List<OperacaoSensoriamentoLogBateriaBarramentoModel>(Barramentos ?? new List<OperacaoSensoriamentoLogBateriaBarramentoModel>())
            };
        }
    }

    public class OperacaoSensoriamentoLogBateriaBarramentoModel
    {
        public string ID { get; set; }
        public bool Iniciado { get; set; }
        public string Descricao { get; set; }
        public double Tensao { get; set; }
        public double Corrente { get; set; }
        public double Potencia { get; set; }
        public double Energia { get; set; }
        public double Temperatura { get; set; }
    }

    public class OperacaoSensoriamentoLogTrajetoriaModel
    {
        public StatusCarroMapa StatusCarro { get; set; }
        public bool TrajetoriaConcluida { get; set; }
        public double ProgressoTrajeto { get; set; }
        public double AnguloCaminho { get; set; }
        public double AnguloMedioCorredor { get; set; }
        public DirecaoCarroRua DirecaoCaminho { get; set; }
        public CorredorTrajetoriaModel CorredorAtual { get; set; }
        public double DistanciaEsquerda { get; set; }
        public double DistanciaDireita { get; set; }
        public double DistanciaTotal { get; set; }
        public double DistanciaPercorrida { get; set; }
        public double DistanciaRestante { get; set; }
        public bool NaMargemDoCorredor { get; set; }
        public bool ManobrandoEntreRuas { get; set; }
        public string TempoEstimadoRestante { get; set; }
        public string TempoEstimadoOperacao { get; set; }
        public PontoTrajetoriaModel ProximoPonto { get; set; }
        public PontoTrajetoriaModel PontoAtual { get; set; }
        public PontoTrajetoriaModel PontoMaisProximo { get; set; }

        public double ErroOrientacaoAngular { get; set; }
        public double ErroOrientacaoAngularCombinado { get; set; }
        public double ErroOrientacaoAngularCaminho { get; set; }
        public double ErroOrientacaoAngularProximoPonto { get; set; }
        public double ErroLateralAngular { get; set; }

        public int IdxRuaAtual { get; set; }
        public double PercentualOperacao { get; set; }
        public double PercentualRuaAtual { get; set; }
        public int QtdPontos { get; set; }

        public GPSModel PrimeiroPontoDentroMapa { get; set; }
        public GPSModel PrimeiroPontoDentroCana { get; set; }
        public double DistanciaErroMapaCana { get; set; }

        public AutonomiaCorredorModel AutonomiaCooredor { get; set; }
        
        public OperacaoSensoriamentoLogTrajetoriaModel Clone()
        {
            return new OperacaoSensoriamentoLogTrajetoriaModel()
            {
                StatusCarro = StatusCarro,
                TrajetoriaConcluida = TrajetoriaConcluida,
                AnguloCaminho = AnguloCaminho,  
                AnguloMedioCorredor = AnguloMedioCorredor, 
                DirecaoCaminho = DirecaoCaminho, 
                DistanciaDireita = DistanciaDireita, 
                DistanciaEsquerda = DistanciaEsquerda, 
                CorredorAtual = CorredorAtual.Clone(false),
                ProgressoTrajeto = ProgressoTrajeto,
                DistanciaTotal = DistanciaTotal,
                DistanciaPercorrida = DistanciaPercorrida,
                DistanciaRestante = DistanciaRestante,
                NaMargemDoCorredor = NaMargemDoCorredor,
                ManobrandoEntreRuas = ManobrandoEntreRuas, 
                TempoEstimadoRestante = TempoEstimadoRestante, 
                TempoEstimadoOperacao = TempoEstimadoOperacao,
                ErroLateralAngular = ErroLateralAngular,
                ErroOrientacaoAngularCombinado = ErroOrientacaoAngularCombinado, 
                ErroOrientacaoAngular = ErroOrientacaoAngular,
                ErroOrientacaoAngularCaminho = ErroOrientacaoAngularCaminho, 
                ErroOrientacaoAngularProximoPonto = ErroOrientacaoAngularProximoPonto, 
                ProximoPonto = ProximoPonto.Clone(), 
                PontoAtual = PontoAtual.Clone(), 
                PontoMaisProximo = PontoMaisProximo.Clone(),
                IdxRuaAtual = IdxRuaAtual, 
                PercentualOperacao = PercentualOperacao, 
                PercentualRuaAtual = PercentualRuaAtual,
                QtdPontos = QtdPontos,
                PrimeiroPontoDentroCana = PrimeiroPontoDentroCana.Clone(), 
                PrimeiroPontoDentroMapa = PrimeiroPontoDentroMapa.Clone(),
                DistanciaErroMapaCana = DistanciaErroMapaCana,
                AutonomiaCooredor = AutonomiaCooredor.Clone()
            };
        }
    }

    public class DirSensoriamentoLogModel
    {
        public string Mod_ID { get; set; }
        public byte ID { get; set; }
        public bool Iniciado { get; set; }
        public bool Controlar { get; set; }
        public double Angulo_SP { get; set; }
        public double AnguloDriver { get; set; }
        public double AnguloReal { get; set; }
        public double AnguloLeitura { get; set; }
        public double AnguloFolgaCompensar { get; set; }
        public Sentido Sentido_SP { get; set; }
        public Sentido Sentido { get; set; }
        public Sentido SentidoReal { get; set; }
        public double Velocidade { get; set; }
        public double FolgaMecanica { get; set; }
        public DateTime UltimoComandoRespondido { get; set; }
    }

    public class MovSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public string Modulo_ID { get; set; }
        public bool Inicializado { get; set; }
        public double RPM_SP { get; set; }
        public double RPM_Motor { get; set; }
        public double RPM_Roda { get; set; }
        public double Velocidade { get; set; }
        public Sentido Sentido_SP { get; set; }
        public Sentido Sentido { get; set; }
        public double Temperatura { get; set; }
        public double TemperaturaDriver { get; set; }
        public double Corrente_Motor { get; set; }
        public double Corrente_Barramento { get; set; }
        public double Tensao { get; set; }
        public double Potencia { get; set; }
        public double CicloTrabalho { get; set; }
        public OidCodigoErro CodAlarme { get; set; }
        public bool AlarmeSensores { get; set; }
        public bool AlarmeComando { get; set; }
        public bool EmFreio { get; set; }
        public bool Ativado { get; set; }
        public DateTime UltimoComandoRespondido { get; set; }
    }

    public class AtuSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public bool Inicializado { get; set; }
        public int QualidadeWifi { get; set; }
        public int LatenciaLoop { get; set; }
        public double MassaReservatorio { get; set; }
        public double PressaoLinha_SP { get; set; }
        public double PressaoLinha { get; set; }
        public double VolumeReservatorio { get; set; }
        public double PercentualReservatorio { get; set; }
        public double PotenciaBomba { get; set; }
        public bool BombaLigada { get; set; }
        public double VazaoFluxoMLpSInstantanea { get; set; }
        public double VazaoFluxoMLpSMedia { get; set; }
        public double VolumeVazaoML { get; set; }
        public int QuantidadeBicos { get; set; }
        public double TempoPulverizadorAtuado { get; set; }
        public List<AtuBicoSensoriamentoLogModel> Bicos { get; set; }
        public DateTime UltimoComandoRespondido { get; set; }
    }

    public class AtuBicoSensoriamentoLogModel
    {
        public string ID { get; set; }
        public int Posicao { get; set; }
        public bool Atuado { get; set; }
        public bool Comandar { get; set; }
        public bool Inicializado { get; set; }
        public bool StatusBico { get; set; }
        public double MediaNivelFluxo { get; set; }
        public int Atuacoes { get; set; }
        public double TempoAtuado { get; set; }
        public double AnguloAbertura { get; set; }
        public double AnguloControle { get; set; }
    }

    public class CamSoloSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public CameraCoordenadasFrameModel Leitura { get; set; }
    }

    public class CamCaminhoSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public Dictionary<string, Color> ClassMap {  get; set; }
        public List<System.Drawing.Point> PontosExtremos { get; set; }
        public double Angulo { get; set; }
        public double AnguloEsquerdo { get; set; }
        public double AnguloDireito { get; set; }
        public CameraDeepLabV3PlusModel Leitura { get; set; }
        public bool Inicializado
        {
            get
            {
                return Leitura?.device_data?.Is_Pipeline_Running ?? false;
            }
        }
        public DateTime UltimaMensagemRecebida { get; set; }
    }

    public class LraSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public bool Conectado { get; set; }
        public bool Configurado { get; set; }
        public byte EnderecoCarro { get; set; }
        public byte EnderecoBase { get; set; }
        public DateTime UltimoComandoRespondido { get; set; }
        public GPSModel PosicaoBase { get; set; }

        public LraSensoriamentoLogModel Clone()
        {
            return new LraSensoriamentoLogModel()
            {
                Momento = Momento, 
                Conectado = Conectado,
                Configurado = Configurado, 
                EnderecoCarro = EnderecoCarro, 
                EnderecoBase = EnderecoBase,
                UltimoComandoRespondido = UltimoComandoRespondido, 
                PosicaoBase = PosicaoBase.Clone()
            };
        }
        
    }

    public class OperacaoSensoriamentoLogErrosModel
    {
        public DateTime Momento { get; set; }
        public T_Code Dispositivo { get; set; }
        public string ID { get; set; }
        public StatusModulo Status { get; set; }
        public double Saude { get; set; }
        public string Mensagem { get; set; }
        public string Condicoes { get; set; }
    }

}