using AgroBase.Comum;
using AgroBase.Forms;
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 System.Windows.Forms.DataVisualization.Charting;
using OpenHardwareMonitor.Hardware;
using CefSharp.WinForms;
using System.Diagnostics;
using System.Threading;

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, chartGraficos);
                tmrLeituras.Start();

                if (computer == null)
                {
                    computer = new Computer()
                    {
                        CPUEnabled = true,
                        GPUEnabled = true,
                        RAMEnabled = true,
                        HDDEnabled = true,
                    };

                    try
                    {
                        computer.Open();
                    }
                    catch (ArgumentOutOfRangeException ex)
                    {
                    }
                    catch (Exception ex)
                    {
                    }
                }
            }
        }

        

        public ModoOperacao Modo { get; set; }
        public string Descricao { get; set; }
        public OperacaoMapaGPSModel OpMapaGPS { get; set; } = new OperacaoMapaGPSModel();
        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 OperacaoSensoriamentoLogModel Sensoriamento { get; set; } = new OperacaoSensoriamentoLogModel();
        public Form frmOperacao { get; set; }
        private StatusOperacao _EtapaAtual;
        private StatusOperacao _EtapaAnteriorParada = StatusOperacao.Parado;
        public bool Emergencia { get; set; } = false;
        public StatusOperacao StatusAtual 
        {
            get
            {
                StatusOperacao etapaAtual = _EtapaAtual;

                // Se a operação não estiver iniciada
                if (!Variaveis.OperacaoEmAndamento.Iniciado)
                {
                    // Etapa atual não é Finalizado, então a etapa é Parametrizando
                    if (_EtapaAtual != StatusOperacao.Concluido)
                    {
                        etapaAtual = StatusOperacao.Parametrizando;
                    }
                    else
                    {
                        //etapaAtual = StatusOperacao.NaoIniciado;
                    }
                }
                // Operação em andamento
                else
                {
                    // Se a operacao atual for manual
                    if (Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.Manual)
                    {
                        etapaAtual = StatusOperacao.EmAndamento;
                    }
                    // Se o trajeto foi finalizado
                    else if (Variaveis.OperacaoEmAndamento.OpMapaGPS.Concluido && _EtapaAtual != StatusOperacao.Concluido)
                    {
                        etapaAtual = StatusOperacao.Concluido;
                    }
                    // Etapa atual é finalizada, então finaliza a operação
                    else if (_EtapaAtual == StatusOperacao.Concluido)
                    {
                        if (Variaveis.OperacaoEmAndamento.Iniciado && !Variaveis.OperacaoEmAndamento.Finalizando)
                        {
                            Variaveis.OperacaoEmAndamento.FinalizarOperacao();
                        }
                    }
                    // Se a operação tiver algum item mandatório interrompido
                    else if (!Variaveis.OperacaoEmAndamento.OperacaoLiberada)
                    {
                        // Da primeira vez, salva a etapa atual anterior à parada para possível retomada
                        if (etapaAtual != StatusOperacao.Parado)
                        {
                            _EtapaAnteriorParada = etapaAtual;
                        }
                        etapaAtual = StatusOperacao.Parado;
                    }
                    // Se a etapa atual for parado, mas a operação foi liberada, retoma de onde parou
                    else if (etapaAtual == StatusOperacao.Parado && Variaveis.OperacaoEmAndamento.OperacaoLiberada)
                    {
                        Variaveis.OperacaoEmAndamento.TempoAguardando = DateTime.Now;
                        etapaAtual = StatusOperacao.Aguardando;
                    }
                    // Contagem regressiva para iniciar a operação
                    else if (Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) > DateTime.Now)
                    {
                        etapaAtual = StatusOperacao.Aguardando;
                    }
                    else if (_EtapaAnteriorParada != StatusOperacao.Parado)
                    {
                        etapaAtual = _EtapaAnteriorParada;
                        _EtapaAnteriorParada = StatusOperacao.Parado;
                    }
                    else
                    {
                        etapaAtual = StatusOperacao.EmAndamento;
                    }
                }


                _EtapaAtual = etapaAtual;

                //_EtapaAtual = StatusOperacao.EmAndamento;
                Variaveis.OperacaoEmAndamento.Sensoriamento.StatusOperacao = _EtapaAtual;

                return _EtapaAtual;
            }
        }
        public (bool, List<T_Code>) ModulosConectados
        {
            get
            {
                Variaveis.OperacaoEmAndamento.ModulosMandatorios.ForEach(Modulo =>
                {
                    Modulo.Conectado = SerialService.DispositivosMapeados.Any(x => x.Dispositivo == Modulo.Dispositivo && x.Conectado);
                });

                bool _modulosConectados =
                    (Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Mandatorio) && Variaveis.OperacaoEmAndamento.ModulosMandatorios.Where(x => x.Mandatorio).All(x => x.Conectado)) ||
                    (Variaveis.OperacaoEmAndamento.ModulosMandatorios.All(x => !x.Mandatorio) && Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Conectado));

                List<T_Code> _modsComFalha = Variaveis.OperacaoEmAndamento.ModulosMandatorios.Where(x => x.Mandatorio && !x.Conectado).Select(x => x.Dispositivo).ToList();

                return (_modulosConectados, _modsComFalha);
            }
        }
        public bool DispositivosIndividuaisConectados
        {
            get
            {
                bool _dispositivosConectados = true;

                // Verificação dos motores BLDC
                if (Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Dispositivo == T_Code.Bld && x.Conectado))
                {
                    (bool _EsqOperante, List<string> _EsqModsInoperantes) = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosBLD(Direcao.Esquerda);
                    (bool _DirOperante, List<string> _DirModsInoperantes) = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosBLD(Direcao.Direita);

                    // Se qualquer lado estiver completamente inoperante, o robô não pode operar corretamente
                    if (!_EsqOperante || !_DirOperante)
                    {
                        _dispositivosConectados = false;
                    }
                }

                // Verificação dos motores MKS
                if (Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Dispositivo == T_Code.Mks && x.Conectado))
                {
                    (bool _MksOperante, List<string> _MksModsInoperantes) = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosMKS(Variaveis.OperacaoEmAndamento.Controle.TipoMovimento);

                    if (!_MksOperante)
                    {
                        _dispositivosConectados = false;
                    }
                }

                // Verificação dos componentes ATU
                if (Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Dispositivo == T_Code.Atu && x.Conectado))
                {
                    (bool _AtuOperante, List<string> _AtuModsInoperantes) = Variaveis.OperacaoEmAndamento.DispAtu.Dados.StatusModulosATU();

                    if (!_AtuOperante)
                    {
                        _dispositivosConectados = false;
                    }
                }

                // Verificação dos componentes SEN
                if (Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Dispositivo == T_Code.Sen && x.Conectado))
                {
                    (bool _SenOperante, List<string> _SenModsInoperantes) = Variaveis.OperacaoEmAndamento.DispSen.Dados.StatusModulosSEN();

                    if (!_SenOperante)
                    {
                        _dispositivosConectados = false;
                    }
                }

                return _dispositivosConectados;
            }
        }
        public bool OperacaoLiberada
        {
            get
            {
                (bool _modsConectados, List<T_Code> _modsComFalha) = Variaveis.OperacaoEmAndamento.ModulosConectados;

                bool _operacaoLiberada = _modsConectados;

                if (_operacaoLiberada && Variaveis.OperacaoEmAndamento.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo && x.Mandatorio) && Variaveis.OperacaoEmAndamento.CamerasSolo.Count(x => x.Iniciada) < Variaveis.OperacaoEmAndamento.QuantidadeCamerasSolo) _operacaoLiberada = false;
                if (_operacaoLiberada && Variaveis.OperacaoEmAndamento.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Kinect && x.Mandatorio) && (!KinectService.Iniciado || KinectService.Leitura == null)) _operacaoLiberada = false;
                if (_operacaoLiberada && Variaveis.OperacaoEmAndamento.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && x.Mandatorio) && !Variaveis.OperacaoEmAndamento.Mapa.mapaService.Carregado) _operacaoLiberada = false;
                if (_operacaoLiberada && Variaveis.OperacaoEmAndamento.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick && x.Mandatorio && GeneralJoystick.JoystickConectado == null)) _operacaoLiberada = false;
                if (_operacaoLiberada && !Variaveis.OperacaoEmAndamento.DispositivosIndividuaisConectados) _operacaoLiberada = false;

                if (frmInstancial.frmPrincipal.chbDebugMode.Checked) _operacaoLiberada = true;

                if (Variaveis.OperacaoEmAndamento.Emergencia) _operacaoLiberada = false;

                return _operacaoLiberada;
            }
        }
        public string ErroOperacaoLiberada
        {
            get
            {
                string MensagemErro = "Para iniciar a operação " + Enum.GetName(typeof(ModoOperacao), Modo) +
                            ", é necessário que todos os módulos mandatórios estejam devidamente conectados ao equipamento, ou pelo menos um dos módulos:\r\n";
                ModulosMandatorios.ForEach(Modulo =>
                {
                    MensagemErro += Enum.GetName(typeof(T_Code), Modulo.Dispositivo) + ": ( " + (Modulo.Conectado ? "OK" : "  ") + " ) - Mandatório: " + (Modulo.Mandatorio ? "Sim" : "Não") + "\r\n";
                });
                return MensagemErro;
            }
        }
        public bool Iniciado { get; set; }
        public bool Simulando { get; set; } = false;
        public bool Finalizando { get; set; } = false;
        public long TimestampInicio { get; set; }
        public long TimestampFim { get; set; }
        public TimeSpan Tempo 
        { 
            get
            {
                return TimeSpan.FromTicks(Variaveis.OperacaoEmAndamento.Iniciado ? ((Variaveis.OperacaoEmAndamento.TimestampFim > 0 ? Variaveis.OperacaoEmAndamento.TimestampFim : DateTime.Now.Ticks) - Variaveis.OperacaoEmAndamento.TimestampInicio) : 0);
            }
        }
        public DateTime TempoAguardando { get; set; }
        
        public List<OperacaoModulosMandatoriosModel> ModulosMandatorios { get; set; } = new List<OperacaoModulosMandatoriosModel>();
        public List<OperacaoParametrosMandatoriosModel> ParametrosMandatorios { get; set; } = new List<OperacaoParametrosMandatoriosModel>();
        public List<GPSModel> GPSTrajetoria { get; set; } = new List<GPSModel>();
        public List<List<GPSModel>> GPSTrajetoriaRua { get; set; } = new List<List<GPSModel>>();
        public double CapacidadeReservatorio { get; set; } = 30;
        public int QuantidadeCamerasSolo { get; set; } = 2;
        public List<CameraSoloModel> CamerasSolo { get; set; } = new List<CameraSoloModel>();
        public CameraCaminhoModel CameraCaminhoKinect { get; set; }
        public int TempoIniciarOperacao { get; set; } = 25;
        public string ID { get; set; }
        public double tmrLogsInterval
        {
            get
            {
                return tmrLogs.Interval;
            }
            set
            {
                tmrLogs.SetInterval((int)value);
            }
        }
        private static AsyncTaskTimerModel tmrLogs;
        private static AsyncTaskTimerModel tmrLeituras;
        public Chart chartGraficos = new Chart();
        private static Computer computer;
        public string PerformanceStr
        {
            get
            {
                return FuncoesGlobais.MontarStringPerformance(
                    Sensoriamento.GPU_load,
                    Sensoriamento.CPU_load,
                    Sensoriamento.RAM_usage,
                    Sensoriamento.GPU_temp,
                    Sensoriamento.CPU_temp
                );
            }
        }


        #region PARAMETRIZACAO

        public bool SalvarParametrizacaoOperacao(string descricao, string capacidade, string pressao, string duracao, string percentual, string angulo, string velocidadeMp, int velocidadeServasPercent, int velocidadeCervasPercent, UltrasonicA05Configuracoes ConfigUltrassom, bool sonarAtivado)
        {
            if (string.IsNullOrEmpty(descricao))
            {
                MessageBox.Show("Preencha a descrição para identificação da operação!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return false;
            }

            double.TryParse(capacidade, out double capacidadeReservatorio);
            double.TryParse(pressao, out double pressaoLinha);
            int.TryParse(duracao, out int duracaoAtuacao);
            int.TryParse(percentual, out int percentualAtuacao);
            int.TryParse(angulo, out int anguloMaximo);
            int.TryParse(velocidadeMp, out int velocidadeMovimento);

            OperacaoParametrosModel Parametros = new OperacaoParametrosModel()
            {
                Modo = Variaveis.OperacaoEmAndamento.Modo,
                Descricao = descricao,
                AtuCapacidadeReservatorio = capacidadeReservatorio,
                AtuDuracaoAtuacao = duracaoAtuacao,
                AtuPercentualDeteccaoVertical = percentualAtuacao,
                AtuPressaoLinha = pressaoLinha,
                DirAnguloMaximo = anguloMaximo,
                DirVelocidadeMovimento = velocidadeMovimento,
                MovVelocidadeCErvasPercent = velocidadeCervasPercent,
                MovVelocidadeSErvasPercent = velocidadeServasPercent,
                ModulosMandatorios = Variaveis.OperacaoEmAndamento.ModulosMandatorios,
                Mapa = Variaveis.OperacaoEmAndamento.Mapa, 
                ConfiguracaoUltrassom = ConfigUltrassom,
                SonarAtivado = sonarAtivado
            };
            Parametros.Mapa.lblMapa = null;
            Parametros.Mapa.pnlMapa = null;
            Parametros.Mapa.chromiumWebBrowser = null;
            Parametros.Mapa.mapaService.pythonProcess = null;

            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 filePath = !string.IsNullOrEmpty(opPath) ? opPath : openFileDialog.FileName;

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

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

                CarregarParametrosOperacaoPadrao(Parametros.Modo);

                OperacaoControleModel controle = new OperacaoControleModel()
                {
                    RPM_Max = (int)(VariaveisEquipamento.RPM_Max_Roda * (Parametros.MovVelocidadeSErvasPercent / 100.0)),
                    RPM_Min = (int)(VariaveisEquipamento.RPM_Max_Roda * (Parametros.MovVelocidadeCErvasPercent / 100.0)),
                    Angulo_Max = Parametros.DirAnguloMaximo,
                    Angulo_Min = Parametros.DirAnguloMaximo * -1,
                    VelocidadeMP = Parametros.DirVelocidadeMovimento,
                    TempoAtuacao = Parametros.AtuDuracaoAtuacao,
                    PercentualInicioPulverizacao = Parametros.AtuPercentualDeteccaoVertical / 100.0,
                    PressaoLinha = Parametros.AtuPressaoLinha,
                    Angulo = 0,
                    Direcao = Direcao.Parado,
                    PercentualVelocidadeSP = 0,
                    PIDdirecional = new PIDModel(),
                    TiposControle = Variaveis.OperacaoEmAndamento.Controle.TiposControle.ToList(), 
                    SonarAtivado = Parametros.SonarAtivado,
                };

                Variaveis.OperacaoEmAndamento.ModulosMandatorios = Parametros.ModulosMandatorios.ToList();
                Variaveis.OperacaoEmAndamento.CapacidadeReservatorio = Parametros.AtuCapacidadeReservatorio;
                Variaveis.OperacaoEmAndamento.Controle = controle;
                Variaveis.OperacaoEmAndamento.Descricao = Parametros.Descricao;
                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);
                }

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

        public string TempoEstimadoOperacao(double velocidadeSemErvas, double velocidadeComErvas)
        {
            double velocidadeDirecionamento = velocidadeSemErvas * 0.6;

            // Conversão de velocidades para m/s
            double velocidadeSemErvasMs = (velocidadeSemErvas * 1000) / 3600;
            double velocidadeComErvasMs = (velocidadeComErvas * 1000) / 3600;
            double velocidadeTrajetoriaMs = (velocidadeDirecionamento * 1000) / 3600;

            // Supondo que metade do percurso tem ervas e a outra metade não tem
            double distanciaSemErvas = Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal * VariaveisOperacao.PercentualSemErvas;
            double distanciaComErvas = Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal * VariaveisOperacao.PercentualComErvas;
            double distanciaTrajetoria = Variaveis.OperacaoEmAndamento.Mapa.DistanciaExtraTrajetoria;

            // Tempo em segundos para cada parte do percurso
            double tempoSemErvas = velocidadeSemErvasMs > 0 ? distanciaSemErvas / velocidadeSemErvasMs : 0;
            double tempoComErvas = velocidadeComErvasMs > 0 ? distanciaComErvas / velocidadeComErvasMs : 0;
            double tempoDirecionamento = velocidadeTrajetoriaMs > 0 ? distanciaTrajetoria / velocidadeTrajetoriaMs : 0;

            double tempoManobras = Variaveis.OperacaoEmAndamento.Mapa.RuasPercorrer.Count() * VariaveisOperacao.TempoManobra;

            // Tempo total em segundos
            double tempoTotalSegundos = tempoSemErvas + tempoComErvas + tempoDirecionamento + tempoManobras;

            // Conversão para horas, minutos e segundos
            TimeSpan tempoTotal = TimeSpan.FromSeconds(tempoTotalSegundos);

            return $"{tempoTotal.Hours:D2}:{tempoTotal.Minutes:D2}:{tempoTotal.Seconds:D2}";
        }

        public string TempoEstimadoRestante()
        {
            // Velocidades em RPM
            double velocidadeSemErvas = FuncoesMatematicas.CalculaVelocidadeRPM(Variaveis.OperacaoEmAndamento.Controle.RPM_Max);
            double velocidadeComErvas = FuncoesMatematicas.CalculaVelocidadeRPM(Variaveis.OperacaoEmAndamento.Controle.RPM_Min);
            double velocidadeDirecionamento = velocidadeSemErvas * 0.6;

            // Conversão de velocidades para m/s
            double velocidadeSemErvasMs = (velocidadeSemErvas * 1000) / 3600;
            double velocidadeComErvasMs = (velocidadeComErvas * 1000) / 3600;
            double velocidadeTrajetoriaMs = (velocidadeDirecionamento * 1000) / 3600;

            // Distâncias (em metros)
            double distanciaTotal = (Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal + Variaveis.OperacaoEmAndamento.Mapa.DistanciaExtraTrajetoria);
            double distanciaDirecionamento = Variaveis.OperacaoEmAndamento.Mapa.DistanciaExtraTrajetoria;
            double distanciaPercorrida = GPSService.DistanciaDoTrecho(Variaveis.OperacaoEmAndamento.GPSTrajetoria);
            double distanciaRestante = distanciaTotal - distanciaPercorrida;

            // Variáveis para armazenar o tempo restante para cada parte
            double tempoRestanteDirecionamento = 0;

            // Se o robô ainda estiver na fase de direcionamento
            if (distanciaPercorrida < distanciaDirecionamento)
            {
                // Calcula o tempo restante apenas para a fase de direcionamento
                double distanciaDirecionamentoRestante = distanciaDirecionamento - distanciaPercorrida;
                tempoRestanteDirecionamento = distanciaDirecionamentoRestante / velocidadeTrajetoriaMs;
                distanciaRestante = Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal;
            }

            // Calcular a distância restante sem ervas e com ervas
            double distanciaSemErvasRestante = distanciaRestante * VariaveisOperacao.PercentualSemErvas;

            double distanciaComErvasRestante = distanciaRestante * VariaveisOperacao.PercentualComErvas;

            // Calcular o tempo restante para as áreas sem ervas e com ervas
            double tempoRestanteSemErvas = distanciaSemErvasRestante / velocidadeSemErvasMs;
            double tempoRestanteComErvas = distanciaComErvasRestante / velocidadeComErvasMs;

            // Tempo restante para as manobras
            double tempoRestanteManobras = Variaveis.OperacaoEmAndamento.Mapa.TrajetoriaProjetada.Count() * VariaveisOperacao.TempoManobra;

            // Tempo total restante em segundos
            double tempoTotalRestanteSegundos = tempoRestanteDirecionamento + tempoRestanteSemErvas + tempoRestanteComErvas + tempoRestanteManobras;

            // Conversão para horas, minutos e segundos
            TimeSpan tempoTotalRestante = TimeSpan.FromSeconds(tempoTotalRestanteSegundos);

            return $"{tempoTotalRestante.Hours:D2}:{tempoTotalRestante.Minutes:D2}:{tempoTotalRestante.Seconds:D2}";
        }



        public static void CarregarParametrosOperacaoPadrao(ModoOperacao Modo)
        {
            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,
                TimestampInicio = 0,
                TimestampFim = 0,
                DispAtu = AtuConectado,
                DispSen = SenConectado, 
                DispMvd = MvdConectado,
                Sensoriamento = new OperacaoSensoriamentoLogModel(),
            };
            

            switch (Modo)
            {
                case ModoOperacao.Manual:
                    //OperacaoCarregar.frmOperacao = (Form)Activator.CreateInstance(Variaveis.OperacaoEmAndamento.OpManual.frmOperacao.GetType());
                    Variaveis.OperacaoEmAndamento.frmOperacao = new frmOperacaoManual();
                    Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
                    {
                        RPM_Max = 100,
                        RPM_Min = 15,
                        Angulo_Max = 25,
                        Angulo_Min = -25,
                        VelocidadeMP = 30,
                        TiposControle = new List<OperacaoControleTipoModel>()
                        {
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Mov,
                                DelayEnvioComando = 10,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Dir,
                                DelayEnvioComando = 10,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Atu, 
                                DelayEnvioComando = 10,
                                Comandos = new List<string>(), 
                                UltimoComando = DateTime.Now
                            },
                        },
                        SonarAtivado = false, 
                        SonarDesvioAutomatico = false,
                        SegmentacaoSemantica = false,
                        PulverizadorAutomatico = false,
                        TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
                    };
                    Variaveis.OperacaoEmAndamento.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
                    {
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Bld,
                            Mandatorio = false
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Mks, 
                            Mandatorio = false
                        }, 
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Atu, 
                            Mandatorio = false
                        }, 
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Knt, 
                            Mandatorio = false
                        }
                    };
                    Variaveis.OperacaoEmAndamento.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
                    {
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Joystick,
                            Mandatorio = false,
                        },
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Kinect, 
                            Mandatorio = false
                        }
                    };
                    //OperacaoCarregar.Sensoriamento.SonarFrontal_old = new SonarModel(FuncoesGlobais.FindControlRecursive<PictureBox>(OperacaoCarregar.frmOperacao, "picSonar"));
                    break;
                case ModoOperacao.MapaGPS:
                    //OperacaoCarregar.frmOperacao = (Form)Activator.CreateInstance(Variaveis.OperacaoEmAndamento.OpMapaGPS.frmOperacao.GetType());
                    Variaveis.OperacaoEmAndamento.frmOperacao = new frmOperacaoMapaGPS();
                    Variaveis.OperacaoEmAndamento.ControleAnterior = new OperacaoControleModel();
                    Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
                    {
                        RPM_Max = 100,
                        RPM_Min = 15,
                        Angulo_Max = 30,
                        Angulo_Min = -30,
                        VelocidadeMP = 40,
                        TiposControle = new List<OperacaoControleTipoModel>()
                        {
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Mov,
                                DelayEnvioComando = 500,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Dir,
                                DelayEnvioComando = 1000,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Atu,
                                DelayEnvioComando = 500,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                        },
                        SonarAtivado = true,
                        SonarDesvioAutomatico = true,
                        SegmentacaoSemantica = true,
                        PulverizadorAutomatico = true,
                        TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
                    };
                    Variaveis.OperacaoEmAndamento.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
                    {
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Bld,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Mks,
                            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,
                        }
                    };
                    Variaveis.OperacaoEmAndamento.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
                    {
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.CameraSolo, 
                            Mandatorio = true,
                        },
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Kinect, 
                            Mandatorio = true,
                        }, 
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Mapa, 
                            Mandatorio = true,
                        }
                    };
                    Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento = new OperacaoMapaGPSSensoriamentoModel();
                    break;
            }

            Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ReiniciarLeituras();

            Variaveis.OperacaoEmAndamento.AtualizaListaCameras(null, new List<Panel>(), false);

            if (Variaveis.OperacaoEmAndamento.DispSen != null)
            {
                if (Variaveis.OperacaoEmAndamento.DispSen.Dados.ConfiguracaoSensorUltrassom == null)
                {
                    Variaveis.OperacaoEmAndamento.DispSen.Dados.ConfiguracaoSensorUltrassom = UltrasonicA05Helper.CarregarConfiguracaoPadrao(ConfiguracaoSensorUltrassonico.NaoUtilizado);
                }

                if (Variaveis.OperacaoEmAndamento.DispSen.Dados.Conectado)
                {
                    Variaveis.OperacaoEmAndamento.DispSen.Dados.Sinaleiros.ForEach(x => x.Comportamento = VariaveisEquipamento.ComportamentoPorStatus(StatusOperacao.NaoIniciado));

                    Variaveis.OperacaoEmAndamento.DispSen.Dados.Sinaleiros.First(x => x.ID == (Modo == ModoOperacao.Manual ? "LEDMN" : "LEDAT")).Comportamento.statusLED = StatusLED.Aceso;
                    Variaveis.OperacaoEmAndamento.DispSen.Dados.Sinaleiros.First(x => x.ID == "LEDOP").Comportamento = VariaveisEquipamento.ComportamentoPorStatus();

                    //OperacaoCarregar.DispSen.Dados.Sinaleiros.ForEach(x => OperacaoCarregar.DispSen.AdicionarMensagemFila(OperacaoCarregar.DispSen.Dados.Modulo_ID, x.ProtocoloComando(), true, false));
                    foreach (var Sinaleiro in Variaveis.OperacaoEmAndamento.DispSen.Dados.Sinaleiros)
                    {
                        GeneralJoystick.EnviarComandoSensoriamento(S_Code.sLED, Sinaleiro.ID, Sinaleiro.Comportamento);
                    }
                }
            }

            Variaveis.OperacaoEmAndamento.Controle.Angulo = Variaveis.OperacaoEmAndamento.Controle.Angulo_Max;
            Variaveis.OperacaoEmAndamento.Controle.PercentualVelocidadeSP = Variaveis.OperacaoEmAndamento.Controle.PercentualVelocidadeMin;
        }

        public static void SalvarOperacaoPersonalizada(OperacaoModel Operacao)
        {
            if (Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.MapaGPS)
            {
                Operacao.OpMapaGPS.frmOperacaoNome = Operacao.OpMapaGPS.frmOperacao.Name;
                Form frm = Operacao.OpMapaGPS.frmOperacao;

                Operacao.OpMapaGPS.frmOperacao = null;

                //File.WriteAllText("operacao" + Enum.GetName(typeof(ModoOperacao), Operacao.Modo) + ".opr", JsonConvert.SerializeObject(Operacao));

                Operacao.OpMapaGPS.frmOperacao = frm;
            }
            
        }

        public static OperacaoModel CarregarOperacaoPersonalizada(string nomeArquivo)
        {
            string modoOpStr = nomeArquivo.Split('\\')[nomeArquivo.Split('\\').Length - 1].Replace("operacao", "").Split('.')[0];
            ModoOperacao modo = (ModoOperacao)Enum.Parse(typeof(ModoOperacao), modoOpStr);
            CarregarParametrosOperacaoPadrao(modo);
            return Variaveis.OperacaoEmAndamento;
            
            OperacaoModel Operacao = new OperacaoModel(modo);
            if (!File.Exists(nomeArquivo))
            {
                //Operacao = CarregarParametrosOperacaoPadrao(modo);
                SalvarOperacaoPersonalizada(Operacao);
            }

            var operacaoText = File.ReadAllText(nomeArquivo);
            Operacao = JsonConvert.DeserializeObject<OperacaoModel>(operacaoText);

            Type tipoDoForm = Type.GetType(Operacao.OpMapaGPS.frmOperacaoNome);
            if (tipoDoForm != null)
            {
                Operacao.OpMapaGPS.frmOperacao = (Form)Activator.CreateInstance(tipoDoForm);
            }

            return Operacao;
        }


        public async Task IniciarOperacao(OperacaoControleModel controle = null, bool DaIHM = true)
        {
            tmrLogs?.Start();

            Iniciado = true;
            Simulando = false;
            TimestampInicio = DateTime.Now.Ticks;
            TempoAguardando = DateTime.Now;
            TimestampFim = 0;
            Mapa.IdxRuaAtual = 0;

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

            if (Modo == ModoOperacao.MapaGPS)
            {
                Controle.PIDdirecional = new PIDModel()
                {
                    LimiteSaida = Controle.Angulo_Max,
                    SetPoint = 0,
                    Kp = 1.5, // 0.7
                    Ki = 0.08, // 0.5
                    Kd = 0.03 // 0.1
                };
                if (controle != null)
                {
                    Controle = controle;
                }
            }

            GPSTrajetoria = new List<GPSModel>();
            ID = (new DateTime(TimestampInicio)).ToString("dd_MM_yyyy_HH_mm_ss");
            idxLog = 0;

            Directory.CreateDirectory(Variaveis.CaminhoOperacoes + ID + "/");

            await RealizarCalibragemInicialAsync();

            Mapa.ReiniciarTrajetoriaDinamica();
            Mapa.GerarTrajetoriaDinamica();
        }

        public void FinalizarOperacao()
        {
            Variaveis.OperacaoEmAndamento.Finalizando = true;

            // Desliga as cameras apenas no fechamento do form, e nao na finalizacao da operacao
            if (Variaveis.OperacaoEmAndamento.Iniciado && false)
            {
                DesligarCameras();
            }

            PararCarroOperacaoInterrompida(true);

            var Bomba = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombaPressurizadora;
            if (Bomba.Inicializado)
            {
                GeneralJoystick.EnviarComandoAtuador(S_Code.sBMB, false, Bomba.ID);
            }

            Variaveis.OperacaoEmAndamento.Iniciado = false;
            Variaveis.OperacaoEmAndamento.TimestampFim = DateTime.Now.Ticks;

            if (!Variaveis.OperacaoEmAndamento.Simulando)
            {
                SalvarLogs(false);
            }

            Variaveis.OperacaoEmAndamento.Finalizando = false;

            tmrLogs?.Stop();
        }

        public async Task RealizarCalibragemInicialAsync()
        {
            var DispAtu = Variaveis.OperacaoEmAndamento.DispAtu;
            if (DispAtu != null)
            {
                // Ligar bomba
                var Bomba = DispAtu.Dados.BombaPressurizadora;
                if (Bomba.Inicializado)
                {
                    GeneralJoystick.EnviarComandoAtuador(S_Code.sBMB, true, Bomba.ID);

                    await Task.Delay(5000);
                }

                // Testar os bicos
                for (int i = 0; i < DispAtu.Dados.QuantidadeBicos; i++)
                {
                    var Bico = DispAtu.Dados.BicosPulverizadores[i];
                    if (Bico.Inicializado)
                    {
                        GeneralJoystick.EnviarComandoAtuador(S_Code.sBIC, true, Bico.ID);

                        await Task.Delay(200);

                        GeneralJoystick.EnviarComandoAtuador(S_Code.sBIC, false, Bico.ID);
                    }
                }

                await Task.Delay(1000);
            }

            var DispMvd = Variaveis.OperacaoEmAndamento.DispMvd;
            if (DispMvd != null)
            {
                // Referenciar motores de passo
                if (DispMvd.Dados.Modulos.Any(x => x.DirMotor.MKS_Inicializado))
                {
                    GeneralJoystick.EnviaComandoMotor(Keys.R);
                }
            }

            if (KinectService.Iniciado)
            {
                KinectService.RecalibrarSubdivisoes();
            }
        }


        public void IniciarSimulacao()
        {
            Iniciado = true;
            Simulando = true;
            TimestampInicio = DateTime.Now.Ticks;
            TempoAguardando = DateTime.Now;
            TimestampFim = 0;
            Mapa.IdxRuaAtual = 0;

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

            Sensoriamento.ReiniciarLeituras();
            OpMapaGPS.Sensoriamento.ReiniciarLeituras();

            if (Modo == ModoOperacao.MapaGPS)
            {
                Controle.PIDdirecional = new PIDModel()
                {
                    LimiteSaida = Controle.Angulo_Max,
                    SetPoint = 0,
                    Kp = 1.5,
                    Ki = 0.08,
                    Kd = 0.03
                };
            }

            GPSTrajetoria = new List<GPSModel>();
            
            Mapa.ReiniciarTrajetoriaDinamica();
            Mapa.GerarTrajetoriaDinamica();
        }

        public void ReiniciarSimulacao()
        {
            Variaveis.OperacaoEmAndamento._EtapaAtual = StatusOperacao.Parametrizando;
            Variaveis.OperacaoEmAndamento.Iniciado = false;
        }


        #endregion

        #region CAMERAS

        public void AtualizaListaCameras(Panel pnlCameraCaminho, List<Panel> pnlCameraSolo, bool Iniciar)
        {
            if (DispSen == null)
            {
                return;
            }

            var listaCameras = CameraService.ObterListaCameras().Values.ToArray();

            CamerasSolo.Clear();
            for (int i = 0; i < QuantidadeCamerasSolo; i++)
            {
                string CamNome = "Cam_Solo_" + i.ToString();
                CameraSoloModel CameraSolo = new CameraSoloModel()
                {
                    ID = "S" + i.ToString(),
                    Nome = CamNome,
                    Posicao = CamerasSolo.Count(),
                    ArquivoLeitura = "ervas_" + CamNome + ".json",
                    browser = null,
                    camera = new CameraService(),
                    CameraSelecionada = DispSen.Dados.CameraID_Solo.Count > i ? DispSen.Dados.CameraID_Solo[i] : null,
                    combo = new ComboBox(),
                    MaxLeituras = 1,
                    VideoPorta = (VariaveisPortas.CameraSolo + CamerasSolo.Count()).ToString(),
                    VideoUrl = "green_objects_" + CamNome,
                    MqttTopico = "green_objects_" + CamNome,
                };
                CamerasSolo.Add(CameraSolo);
                CameraSolo.camera.selectedCamera = listaCameras.ToList().IndexOf(CameraSolo.CameraSelecionada);
                if (CameraSolo.camera.selectedCamera > 0 && Iniciar)
                {
                    CameraSolo.panel = pnlCameraSolo[i];
                    IniciarCameraSolo(CameraSolo);
                }
            }

            var cameraCaminho = new CameraCaminhoModel()
            {
                ID = "C",
                Nome = "Cam_Caminho",
                ArquivoLeitura = "leitura_ruas.json",
                browser = null,
                camera = new CameraService(),
                MaxLeituras = 1,
                Angulo = 0,
                AnguloDireito = 0,
                AnguloEsquerdo = 0,
                Leitura = new CameraDeepLabV3PlusModel(),
                PontosExtremos = new List<System.Drawing.Point>()
            };
            CameraCaminhoKinect = cameraCaminho;
            CameraCaminhoKinect.camera.selectedCamera = KinectService.Iniciado ? 1 : 0;
            if (CameraCaminhoKinect.camera.selectedCamera > 0 && Iniciar && Variaveis.OperacaoEmAndamento.Controle.SegmentacaoSemantica)
            {
                CameraCaminhoKinect.panel = pnlCameraCaminho;
                IniciarCameraCaminho(CameraCaminhoKinect);
            }
        }

        public void IniciarCameraSolo(CameraSoloModel CameraSolo)
        {
            DesligarCameraSolo(CameraSolo);

            if (CameraSolo.camera.selectedCamera > 0)
            {
                VersaoArquivoModel ArquivoVersao = VersionamentoService.ArquivoModeloWeedDetector;

                //CameraSolo.IniciarRotinaProcesso();

                CameraSolo.camera.IniciarCamera(
                    Variaveis.OperacaoEmAndamento.DispAtu.Dados.ScriptDeteccaoErvas,
                    new string[] {
                        CameraSolo.MaxLeituras.ToString(),
                        CameraSolo.VideoPorta,
                        CameraSolo.VideoUrl,
                        CameraSolo.ArquivoLeitura,
                        "0",
                        CameraSolo.MqttTopico,
                        ArquivoVersao.Diretorio,
                        ArquivoVersao.Versao,
                    },
                    CameraSolo.VideoPorta,
                    CameraSolo.VideoUrl,
                    CameraSolo.MqttTopico,
                    async (Mensagem) =>
                    {
                        if (Mensagem.Momento > CameraSolo.camera.IniciadoEm && Mensagem.Mensagem == "OK")
                        {
                            CameraSolo.camera.ProntoEm = Mensagem.Momento;

                            if (CameraSolo.browser == null)
                            {
                                CameraSolo.Iniciada = true;
                                CameraSolo.browser = new ChromiumWebBrowser(CameraSolo.camera.URLcamera);
                                CameraSolo.browser.Dock = DockStyle.Fill;

                                CameraSolo.panel.Invoke(new Action(() =>
                                {
                                    CameraSolo.panel.Controls.Add(CameraSolo.browser);
                                    CameraSolo.panel.Refresh();
                                }));
                            }
                        }
                    }
                );
            }
            else
            {
                Console.Write("Camera " + CameraSolo.Nome + " não foi configurada!");
            }
        }

        public void DesligarCameraSolo(CameraSoloModel CameraSolo)
        {
            CameraSolo.DesligarCamera();
        }
        
        public void IniciarCameraCaminho(CameraCaminhoModel cameraCaminho)
        {
            DesligarCameraCaminho(cameraCaminho);

            if (cameraCaminho.camera.selectedCamera > 0)
            {
                cameraCaminho.InicializarCamera();

                VersaoArquivoModel ArquivoVersao = VersionamentoService.ArquivoModeloStreetDetector;

                cameraCaminho.camera.IniciarCamera(
                    PythonService.ScriptStreetDetector,
                    new string[] {
                        CamerasVaraiveisModel.TopicoRecebimentoBitmap, 
                        CamerasVaraiveisModel.TopicoEnvioBitmap, 
                        ArquivoVersao.Diretorio, 
                        ArquivoVersao.Versao, 
                    },
                    cameraCaminho.VideoPorta,
                    cameraCaminho.VideoUrl,
                    CamerasVaraiveisModel.TopicoRecebimentoBitmap,
                    async (Mensagem) =>
                    {
                        if (Mensagem.Momento > cameraCaminho.camera.IniciadoEm && Mensagem.Mensagem == "OK")
                        {
                            cameraCaminho.camera.ProntoEm = Mensagem.Momento;

                            if (cameraCaminho.browser == null)
                            {
                                cameraCaminho.Iniciada = true;
                                if (cameraCaminho.panel != null)
                                {
                                    cameraCaminho.panel.GetType().GetMethod("SetStyle", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(cameraCaminho.panel, new object[] { ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true });
                                    cameraCaminho.panel.BackgroundImageLayout = ImageLayout.Zoom;
                                }
                            }
                        }
                        else if (Mensagem.Mensagem != "OK")
                        {
                            try
                            {
                                Bitmap bitmap = Variaveis.OperacaoEmAndamento.CameraCaminhoKinect.ExtraiImagemDaMensagem(Mensagem.Mensagem);
                                await Variaveis.OperacaoEmAndamento.CameraCaminhoKinect.AtualizarBitmapTela(bitmap);
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine($"Erro ao processar a mensagem MQTT: {ex.Message}");
                            }
                        }
                    }
                );
            }
        }

        public void DesligarCameraCaminho(CameraCaminhoModel cameraCaminho)
        {
            cameraCaminho.DesligarCamera();
        }
        
        public void DesligarCameras()
        {
            Variaveis.OperacaoEmAndamento.CamerasSolo.ForEach(Camera =>
            {
                Camera.DesligarCamera();
            });
            Variaveis.OperacaoEmAndamento.CameraCaminhoKinect.DesligarCamera();
        }

        #endregion


        
        #region CONTROLE DA OPERACAO

        public void AtualizarDadosControle(bool ForcarEnvio)
        {
            DateTime Agora = DateTime.Now;

            var _Controle = Variaveis.OperacaoEmAndamento.Controle;
            var _ControleAnterior = Variaveis.OperacaoEmAndamento.ControleAnterior;

            OperacaoControleTipoModel ControleMov = _Controle.TiposControle != null ? _Controle.TiposControle.FirstOrDefault(x => x.Tipo == T_Code.Mov) : null;
            OperacaoControleTipoModel ControleDir = _Controle.TiposControle != null ? _Controle.TiposControle.FirstOrDefault(x => x.Tipo == T_Code.Dir) : null;

            if (ControleMov != null && _Controle.RPM_SP != _ControleAnterior.RPM_SP && (Agora - ControleMov.UltimoComando).TotalMilliseconds > ControleMov.DelayEnvioComando)
            {
                // Enviar comando MOV
                var Protocolos = EnviarProtocoloComando(Variaveis.OperacaoEmAndamento.DispMvd, T_Code.Mov, ForcarEnvio);
                ControleMov.UltimoComando = Agora;
                ControleMov.Comandos.AddRange(Protocolos);

                _ControleAnterior.PercentualVelocidadeSP = _Controle.PercentualVelocidadeSP;
            }
            if (ControleDir != null && Convert.ToInt32(_Controle.Angulo) != Convert.ToInt32(_ControleAnterior.Angulo) && (Agora - ControleDir.UltimoComando).TotalMilliseconds > ControleDir.DelayEnvioComando)
            {
                // Enviar comando DIR
                var Protocolos = EnviarProtocoloComando(Variaveis.OperacaoEmAndamento.DispMvd, T_Code.Dir, ForcarEnvio);
                ControleDir.UltimoComando = Agora;
                ControleDir.Comandos.AddRange(Protocolos);

                _ControleAnterior.Angulo = _Controle.Angulo;
            }

            AtualizarDadosOperacao();
        }

        public void AtualizarDadosControlePulverizador(bool ForcarEnvio)
        {
            if (Variaveis.OperacaoEmAndamento.Controle.PulverizadorAutomatico)
            {
                Variaveis.OperacaoEmAndamento.AtualizarControleAtuadores();
                DateTime Agora = DateTime.Now;

                var _Controle = Variaveis.OperacaoEmAndamento.Controle;

                OperacaoControleTipoModel ControleAtu = _Controle.TiposControle != null ? _Controle.TiposControle.FirstOrDefault(x => x.Tipo == T_Code.Atu) : null;
                if (ControleAtu != null && (Agora - ControleAtu.UltimoComando).TotalMilliseconds > ControleAtu.DelayEnvioComando)
                {
                    // Enviar comando ATU
                    var Protocolos = EnviarProtocoloComando(Variaveis.OperacaoEmAndamento.DispAtu, T_Code.Atu, ForcarEnvio);
                    ControleAtu.UltimoComando = Agora;
                    ControleAtu.Comandos.AddRange(Protocolos);
                }
            }
        }

        public List<string> EnviarProtocoloComando(IDispositivosService Dispositivo, T_Code Tipo, bool ForcarEnvio)
        {
            if (Dispositivo == null || !Iniciado)
            {
                return new List<string>();
            }

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

            var _Controle = Variaveis.OperacaoEmAndamento.Controle;
            var _ControleAnterior = Variaveis.OperacaoEmAndamento.ControleAnterior;

            // Comando dos motores
            if (Tipo == T_Code.Mov || Tipo == T_Code.Dir)
            {
                if (Tipo == T_Code.Mov)
                {
                    if (_Controle.RPM_SP == 0)
                    {
                        _Controle.Direcao = Direcao.Parado;
                    }
                    else
                    {
                        if (_Controle.RPM_SP < 0)
                        {
                            _Controle.PercentualVelocidadeSP *= -1;
                            _Controle.Direcao = Direcao.Tras;
                        }
                        else
                        {
                            _Controle.Direcao = Direcao.Frente;
                        }
                    }
                }
                else if (Tipo == T_Code.Dir)
                {
                    if (_Controle.Angulo < 0)
                    {
                        if (_ControleAnterior.Angulo < _Controle.Angulo)
                        {
                            _Controle.Direcao = Direcao.Parado;
                        }
                        else
                        {
                            _Controle.Direcao = Direcao.Esquerda;
                        }
                    }
                    else
                    {
                        if (_ControleAnterior.Angulo > _Controle.Angulo)
                        {
                            _Controle.Direcao = Direcao.Parado;
                        }
                        else
                        {
                            _Controle.Direcao = Direcao.Direita;
                        }
                    }
                }

                GeneralJoystick.EnviaComandoMotor(
                    _Controle.Direcao == Direcao.Frente ? Keys.Up :
                    _Controle.Direcao == Direcao.Tras ? Keys.Down :
                    _Controle.Direcao == Direcao.Esquerda ? Keys.Left :
                    _Controle.Direcao == Direcao.Direita ? Keys.Right :
                    Keys.Escape, Tipo, ForcarEnvio);

                Protocolos = new List<string>()
                {
                    Tipo.ToString() + ";" + _Controle.Direcao.ToString() + ";" + _Controle.RPM_SP.ToString() + ";" + _Controle.Angulo.ToString()
                };

            }
            // Comando dos atuadores
            else if (Tipo == T_Code.Atu)
            {
                if (_ControleAnterior.BicosAtuados.Count() >= _Controle.BicosAtuados.Count())
                {
                    for (int i = 0; i < _Controle.BicosAtuados.Count; i++)
                    {
                        if (_Controle.BicosAtuados[i].ComandoAtuar != _ControleAnterior.BicosAtuados[i].ComandoAtuar)
                        {
                            GeneralJoystick.EnviarComandoAtuador(S_Code.sBIC, _Controle.BicosAtuados[i].ComandoAtuar, _Controle.BicosAtuados[i].ID);
                        }
                    }
                }

                _ControleAnterior.BicosAtuados = _Controle.BicosAtuados.Select(x => x.Clone()).ToList();

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

            return Protocolos;
        }

        private void AtualizarDadosOperacao()
        {
            var Mapa = Variaveis.OperacaoEmAndamento.Mapa;
            DirecaoCarroRua direcaoCarro = OpMapaGPS.ReferencialRuaGPS.Direcao;
            try
            {
                if (!Mapa.mapaService.Carregado || Mapa.DistanciaTotal == 0)
                {
                    Sensoriamento.ProgressoTrajeto = 0;
                }
                else
                {
                    Sensoriamento.ProgressoTrajeto = Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaPercorrida.Sum() / Mapa.DistanciaTotal * 100;
                }

                if (!Mapa.mapaService.Carregado || Mapa.IdxRuaAtual >= Mapa.TrajetoriaProjetada.Count() || (direcaoCarro != DirecaoCarroRua.Ida && direcaoCarro != DirecaoCarroRua.Volta))
                {
                    Sensoriamento.ProgressoRua = 0;
                }
                else if (direcaoCarro == DirecaoCarroRua.Ida)
                {
                    Sensoriamento.ProgressoRua = (
                        (double)Mapa.IdxPontoAproximadoRua /
                        (double)(Mapa.TrajetoriaProjetada[0].Count() - 1)
                    ) * 100;
                }
                else if (direcaoCarro == DirecaoCarroRua.Volta)
                {
                    Sensoriamento.ProgressoRua = (
                        (double)(Mapa.TrajetoriaProjetada[0].Count() - 1 - Mapa.IdxPontoAproximadoRua) /
                        (double)(Mapa.TrajetoriaProjetada[0].Count() - 1)
                    ) * 100;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erro ao definir progresso do trajeto: " + ex.Message);
            }
        }

        public void AtualizarControleAtuadores()
        {
            Variaveis.OperacaoEmAndamento.Controle.BicosAtuados = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BicosPulverizadores.Select(x => x.Clone()).ToList();
        }

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

            AtualizarDadosPerformance();

            if (!Variaveis.OperacaoEmAndamento.OperacaoLiberada && Variaveis.OperacaoEmAndamento.Iniciado)
            {
                PararCarroOperacaoInterrompida(false);
                return;
            }

            if (Variaveis.OperacaoEmAndamento.Iniciado)
            {
                foreach (var CameraSolo in Variaveis.OperacaoEmAndamento.CamerasSolo.Where(x => x.Iniciada))
                {
                    try
                    {
                        AtualizaLeituraCameraSolo(CameraSolo);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Erro ao ler dados da câmera do solo (" + CameraSolo.Nome + "): " + ex.Message);
                    }
                }
                
                Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ErvasNoRadar = Variaveis.OperacaoEmAndamento.CamerasSolo.Sum(x => x.ErvasNoRadar);

                try
                {
                    AtualizaLeituraCameraCaminho();
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Erro ao ler dados da câmera do caminho: " + ex.Message);
                }
            }
            else
            {
                Variaveis.OperacaoEmAndamento.OpMapaGPS.AtualizarRuasSelecionadas();
            }

            try
            {
                AtualizarGrafico();
            }
            catch (Exception ex)
            {

            }

            if (!Variaveis.OperacaoEmAndamento.Simulando || true)
            {
                AtualizaInformacoesControleOperacao();
            }
        }

        private void AtualizaLeituraCameraSolo(CameraSoloModel CameraSolo)
        {

            if (CameraSolo.camera._mqttTopico?.Mensagens?.Any(x => x.Momento > CameraSolo.camera.IniciadoEm && x.Mensagem != "OK") ?? false)
            {
                try
                {
                    var Mensagem = CameraSolo.camera._mqttTopico.Mensagens.LastOrDefault(x => x.Momento > CameraSolo.camera.IniciadoEm);
                    if (Mensagem != null)
                    {
                        CameraSolo.Leitura = JsonConvert.DeserializeObject<CameraCoordenadasFrameModel>(Mensagem.Mensagem);
                    }
                }
                catch
                {

                }

                var Atuador = Variaveis.OperacaoEmAndamento.DispAtu;

                int BicosPorCamera = Atuador.Dados.QuantidadeBicos / Variaveis.OperacaoEmAndamento.CamerasSolo.Count();
                var Verdes = CameraSolo.Leitura.objetos.ToList();
                int intervaloPorBico = Convert.ToInt32(CameraSolo.Leitura.x_max) / BicosPorCamera;
                int inicioBarraPulverizadora = Convert.ToInt32(CameraSolo.Leitura.y_max * (1 - Variaveis.OperacaoEmAndamento.Controle.PercentualInicioPulverizacao));

                List<string> BicosJaAtuados = Atuador.Dados.BicosPulverizadores.Where(x => x.ComandoAtuar).Select(x => x.ID).ToList();

                for (int i = 0; i < BicosPorCamera; i++)
                {
                    int iBico = i + (CameraSolo.Posicao * BicosPorCamera);
                    bool atuarBico = false;

                    foreach (var verde in Verdes)
                    {
                        // Calcule a posição final (y + altura) do objeto verde
                        int posicaoFinalVerdeY = verde.y + verde.altura;
                        if (posicaoFinalVerdeY > inicioBarraPulverizadora)
                        {
                            // Calcule a posição final (x + largura) do objeto verde
                            int posicaoFinalVerdeX = verde.x + verde.largura;

                            // Determina o intervalo no eixo x para o bico atual
                            int limiteInferior = intervaloPorBico * i;
                            int limiteSuperior = limiteInferior + intervaloPorBico;

                            // Verifica se o objeto 'verde' está dentro do intervalo deste bico
                            // A condição foi ajustada para verificar se qualquer parte do objeto verde cruza com o intervalo do bico
                            bool ervaNoRange = verde.x < limiteSuperior && posicaoFinalVerdeX > limiteInferior;
                            if (ervaNoRange && Variaveis.OperacaoEmAndamento.Sensoriamento.StatusOperacao == StatusOperacao.EmAndamento)
                            {
                                atuarBico = true;
                            }
                        }
                    }

                    Atuador.Dados.BicosPulverizadores[iBico].ComandoAtuar = atuarBico;
                }

                CameraSolo.ErvasNoRadar = Verdes.Count();

                // Registra as atuações dos bicos para cada erva detectada
                for (int i = 0; i < BicosPorCamera; i++)
                {
                    int iBico = i + (CameraSolo.Posicao * BicosPorCamera);
                    var Bico = Atuador.Dados.BicosPulverizadores[iBico];
                    if (Bico.ComandoAtuar && !BicosJaAtuados.Contains(Bico.ID))
                    {
                        var atuacao = Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AtuacoesPorBico[iBico];

                        // Registra ervas associadas apenas aos bicos que realmente atuaram
                        foreach (var erva in CameraSolo.Leitura.objetos)
                        {
                            if (!atuacao.ContainsKey(erva.descricao))
                            {
                                atuacao[erva.descricao] = 1;
                            }
                            else
                            {
                                atuacao[erva.descricao]++;
                            }
                            Bico.Atuacoes = atuacao.Sum(x => x.Value);
                        }
                    }
                }

                Variaveis.OperacaoEmAndamento.AtualizarDadosControlePulverizador(false);
            }
        }

       


        private void AtualizaLeituraCameraCaminho()
        {
            try
            {
                var cameraCaminho = Variaveis.OperacaoEmAndamento.CameraCaminhoKinect;

                if (cameraCaminho == null || !cameraCaminho.Iniciada)
                {
                    return;
                }

                var MqttTopico = cameraCaminho.camera._mqttTopico;
                if (MqttTopico != null && MqttTopico.Mensagens.Any(x => x.Momento > cameraCaminho.camera.IniciadoEm))
                {
                    try
                    {
                        var Mensagem = MqttTopico.Mensagens.LastOrDefault(x => x.Momento > cameraCaminho.camera.IniciadoEm);
                        if (Mensagem != null)
                        {
                            cameraCaminho.Leitura = JsonConvert.DeserializeObject<CameraDeepLabV3PlusModel>(Mensagem.Mensagem);
                        }
                    }
                    catch
                    {

                    }
                }
                // Atualizar representação gráfica do resultado da leitura do caminho
                //pnlCaminho.Invalidate();

                if (cameraCaminho.PontosExtremos.Any())
                {
                    double esq_CA = cameraCaminho.PontosExtremos[2].X - cameraCaminho.PontosExtremos[1].X;
                    double esq_CO = cameraCaminho.PontosExtremos[1].Y - cameraCaminho.PontosExtremos[2].Y;
                    double esq_AG = Math.Atan(esq_CO / esq_CA) * (180 / Math.PI);

                    double dir_CA = cameraCaminho.PontosExtremos[4].X - cameraCaminho.PontosExtremos[3].X;
                    double dir_CO = cameraCaminho.PontosExtremos[4].Y - cameraCaminho.PontosExtremos[3].Y;
                    double dir_AG = Math.Atan(dir_CO / dir_CA) * (180 / Math.PI);

                    cameraCaminho.Angulo = dir_AG - esq_AG;
                    cameraCaminho.AnguloDireito = dir_AG;
                    cameraCaminho.AnguloEsquerdo = esq_AG;
                }
                else
                {
                    cameraCaminho.Angulo = 0;
                    cameraCaminho.AnguloDireito = 0;
                    cameraCaminho.AnguloEsquerdo = 0;
                }

                Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AnguloRuaCamera = cameraCaminho.Angulo;

                // Atualizar angulo de inclinação calculado através do modelo de IA para reconhecimento do caminho
                //pnlAnguloCamera.Invalidate();

                AtualizaInformacoesControleOperacao();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erro ao receber dados da Camera Caminho: " + ex.Message);
            }
        }

        private void AtualizaInformacoesControleOperacao()
        {
            if (Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.Manual)
            {
                VerificarDesvioPorObstaculos();
            }
            else
            {
                Variaveis.OperacaoEmAndamento.OpMapaGPS.CalculaDadosMovimentacaoAutonoma();
                Variaveis.OperacaoEmAndamento.AtualizarDadosControle(false);
            }
        }

        bool atualizandoGrafico = false;
        private void AtualizarGrafico()
        {
            if (atualizandoGrafico)
            {
                return;
            }

            atualizandoGrafico = true;

            Chart chart = Variaveis.OperacaoEmAndamento.chartGraficos;

            if (Variaveis.OperacaoEmAndamento.DispMvd == null || chart == null || chart.IsDisposed)
            {
                return;
            }

            MvdMotorMOVSensorimanetoGrafico Log = null;

            // Primeiro, coletar todos os logs alinhados por índice em uma lista de tuplas (index, moduloLog)
            var Logs = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos
                .Where(x => x.MovMotor.BLD_Inicializado)
                .SelectMany(m => m.MovMotor.LogGrafico.Select((log, index) => new { Index = index, Log = log }))
                .GroupBy(x => x.Index) // Agrupa por índice
                .OrderBy(g => g.Key)    // Ordena pelos índices (opcional, mas ajuda na leitura)
                .Select(g => new MvdMotorMOVSensorimanetoGrafico()
                {
                    // Calcula a média de cada propriedade no grupo
                    Momento = new DateTime((long)g.Average(x => x.Log.Momento.Ticks)),
                    Velocidade = g.Average(x => x.Log.Velocidade),
                    RPM_Motor = Convert.ToInt32(g.Average(x => x.Log.RPM_Motor)),
                    RPM_Roda = Convert.ToInt32(g.Average(x => x.Log.RPM_Roda)),
                    RPM_SP = Convert.ToInt32(g.Average(x => x.Log.RPM_SP)),
                    Temperatura = g.Average(x => x.Log.Temperatura),
                    Tensao = g.Average(x => x.Log.Tensao),
                })
                .ToList();

            if (Logs.Count > 0)
            {
                Log = Logs.Last();
            }

            double Minimo = 0;
            double Maximo = 0;

            FuncoesGlobais.ExecutarMetodoComVerificacaoCrossThread(chart, () =>
            {
                try
                {
                    chart.Titles.Clear();
                    chart.Titles.Add("Acompanhamento");
                    //var Logs = (Motor.LogGrafico.Count > MovimentacaoModel.LogsManter ? Motor.LogGrafico.Skip(Math.Max(0, Motor.LogGrafico.Count - MovimentacaoModel.LogsManter)).Take(MovimentacaoModel.LogsManter).ToList() : Motor.LogGrafico).Where(log => log.Modulo_ID == Modulo.Modulo_ID).ToList();
                    chart.Series.Clear();
                    List<string> Momentos = Logs.Select(x => x.Momento.ToString("mm:ss:fff")).ToList();

                    var serieVelocidade = new Series("Velocidade: " + (Log != null ? Log.Velocidade : 0));
                    serieVelocidade.Points.DataBindXY(Momentos, Logs.Select(x => x.Velocidade).ToList());
                    serieVelocidade.ChartType = SeriesChartType.Line;
                    chart.Series.Add(serieVelocidade);
                    Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.Velocidade) < Minimo ? Logs.Min(x => x.Velocidade) : Minimo;
                    Maximo = !Logs.Any() ? 0 : Logs.Min(x => x.Velocidade) > Maximo ? Logs.Min(x => x.Velocidade) : Maximo;

                    var serieRPMsp = new Series("RPM SP: " + (Log != null ? Log.RPM_SP : 0));
                    serieRPMsp.Points.DataBindXY(Momentos, Logs.Select(x => x.RPM_SP).ToList());
                    serieRPMsp.ChartType = SeriesChartType.Spline;
                    chart.Series.Add(serieRPMsp);
                    Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.RPM_SP) < Minimo ? Logs.Min(x => x.RPM_SP) : Minimo;
                    Maximo = !Logs.Any() ? 0 : Logs.Max(x => x.RPM_SP) > Maximo ? Logs.Max(x => x.RPM_SP) : Maximo;

                    var serieRPM = new Series("RPM Roda: " + (Log != null ? Log.RPM_Roda : 0));
                    serieRPM.Points.DataBindXY(Momentos, Logs.Select(x => x.RPM_Roda).ToList());
                    serieRPM.ChartType = SeriesChartType.Spline;
                    chart.Series.Add(serieRPM);
                    Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.RPM_Roda) < Minimo ? Logs.Min(x => x.RPM_Roda) : Minimo;
                    Maximo = !Logs.Any() ? 0 : Logs.Max(x => x.RPM_Roda) > Maximo ? Logs.Max(x => x.RPM_Roda) : Maximo;

                    var serieMotor = new Series("RPM Motor: " + (Log != null ? Log.RPM_Motor : 0));
                    serieMotor.Points.DataBindXY(Momentos, Logs.Select(x => x.RPM_Motor).ToList());
                    serieMotor.ChartType = SeriesChartType.Spline;
                    chart.Series.Add(serieMotor);
                    Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.RPM_Motor) < Minimo ? Logs.Min(x => x.RPM_Motor) : Minimo;
                    Maximo = !Logs.Any() ? 0 : Logs.Max(x => x.RPM_Motor) > Maximo ? Logs.Max(x => x.RPM_Motor) : Maximo;

                    var serieTemperatura = new Series("Temperatura: " + (Log != null ? Log.Temperatura : 0));
                    serieTemperatura.Points.DataBindXY(Momentos, Logs.Select(x => x.Temperatura).ToList());
                    serieTemperatura.ChartType = SeriesChartType.Line;
                    chart.Series.Add(serieTemperatura);
                    Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.Temperatura) < Minimo ? Logs.Min(x => x.Temperatura) : Minimo;
                    Maximo = !Logs.Any() ? 0 : Logs.Max(x => x.Temperatura) > Maximo ? Logs.Max(x => x.Temperatura) : Maximo;

                    foreach (var legend in chart.Legends)
                    {
                        legend.Docking = Docking.Bottom;
                    }

                    if (chart.ChartAreas.Any())
                    {
                        chart.ChartAreas[0].AxisY.Minimum = Minimo - 5;
                        chart.ChartAreas[0].AxisY.Maximum = Maximo + 5;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Erro ao atualizar gráficos da operação: " + ex.Message);
                }

                return true;
            });

            atualizandoGrafico = false;
        }

        public void ExecutaComandoDaBase(OperacaoControleBaseModel controleBase)
        {
            Emergencia = controleBase.Emergencia;

            if (Emergencia)
            {
                return;
            }

            // Salvar estado anterior
            double oldPercentualVelocidade = Controle.PercentualVelocidadeSP;
            double oldAngulo = Controle.Angulo;
            double oldVelocidadeMP = Controle.VelocidadeMP;
            TipoMovimentoDirecional oldTipoMovimento = Controle.TipoMovimento;

            // Atualizar estado atual com os valores do controleBase
            Controle.PercentualVelocidadeSP = controleBase.PercentualVelocidadeSP;
            Controle.Angulo = controleBase.AnguloMP;
            Controle.VelocidadeMP = controleBase.VelocidadeMP;
            Controle.TipoMovimento = controleBase.TipoMovimento;

            // Enviar comando
            GeneralJoystick.EnviaComandoMotor(controleBase.Tecla, controleBase.Dispositivo, true);

            // Restaurar estado anterior
            Controle.PercentualVelocidadeSP = oldPercentualVelocidade;
            Controle.Angulo = oldAngulo;
            Controle.VelocidadeMP = oldVelocidadeMP;
            Controle.TipoMovimento = oldTipoMovimento;
        }

        private void PararCarroOperacaoInterrompida(bool finalizar)
        {
            Variaveis.OperacaoEmAndamento.Controle.PercentualVelocidadeSP = 0; // Velocidade Zero (parado)
            if (finalizar)
            {
                Variaveis.OperacaoEmAndamento.Controle.Angulo = 0; // Angulo Zero (direcional reto)
            }
            AtualizarDadosControle(true);

            Variaveis.OperacaoEmAndamento.Controle.BicosAtuados.ForEach(x => x.ComandoAtuar = false); // Bicos desatuados
            AtualizarDadosControlePulverizador(true);

            Variaveis.OperacaoEmAndamento.Controle.TiposControle.ForEach(x => x.UltimaDirecao = Direcao.Parado);
        }

        private void VerificarDesvioPorObstaculos()
        {
            var Sonar = Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_Kinect;
            if (Variaveis.OperacaoEmAndamento.Controle.SonarAtivado && (Sonar?.Iniciado ?? false) && (Sonar?.DesvioNecessario ?? false))
            {
                Keys TeclaComando =
                    Sonar.DirecaoDesvio == Direcao.Esquerda ? Keys.Left :
                    Sonar.DirecaoDesvio == Direcao.Direita ? Keys.Right :
                    Keys.Escape;

                if (Variaveis.OperacaoEmAndamento.Controle.SonarDesvioAutomatico)
                {
                    Variaveis.OperacaoEmAndamento.Controle.Angulo = Sonar.AnguloDesvio;
                    GeneralJoystick.EnviaComandoMotor(TeclaComando, T_Code.Dir);
                }
                if (Sonar.DirecaoDesvio == Direcao.Parado)
                {
                    GeneralJoystick.EnviaComandoMotor(Keys.Escape, T_Code.Mov);
                }
            }

            if (UltrasonicA05Service.Iniciado)
            {
                if (UltrasonicA05Service.DadosLeitura.Configuracao.ParadaNecessaria)
                {
                    GeneralJoystick.EnviaComandoMotor(Keys.Escape, T_Code.Mov);
                }
                else if (Variaveis.OperacaoEmAndamento.Controle.SonarDesvioAutomatico && UltrasonicA05Service.DadosLeitura.Configuracao.DesvioNecessario)
                {
                    if (UltrasonicA05Service.DadosLeitura.Configuracao.DirecaoDesvio == Direcao.Direita)
                    {
                        GeneralJoystick.EnviaComandoMotor(Keys.Right, T_Code.Dir);
                    }
                    else if (UltrasonicA05Service.DadosLeitura.Configuracao.DirecaoDesvio == Direcao.Esquerda)
                    {
                        GeneralJoystick.EnviaComandoMotor(Keys.Left, T_Code.Dir);
                    }
                }
            }
        }

        #endregion

        #region CALCULAR PERFORMANCE

        DateTime UltimaLeituraPerformance = DateTime.Now;

        public void AtualizarDadosPerformance()
        {
            if (computer == null || computer.Hardware == null)
            {
                return;
            }

            if (DateTime.Now > UltimaLeituraPerformance.AddSeconds(1))
            {
                UltimaLeituraPerformance = DateTime.Now;

                float? cpuLoad = null;
                float? gpuLoad = null;
                float? hddLoad = null;
                float? ramUsage = null;
                float? cpuTemp = null;
                float? gpuTemp = null;

                foreach (var hardwareItem in computer.Hardware)
                {
                    hardwareItem.Update();

                    if (hardwareItem.HardwareType == HardwareType.CPU)
                    {
                        foreach (var sensor in hardwareItem.Sensors)
                        {
                            if (sensor.SensorType == SensorType.Load && sensor.Name == "CPU Total")
                            {
                                cpuLoad = sensor.Value;
                            }
                            if (sensor.SensorType == SensorType.Temperature && sensor.Name == "CPU Package")
                            {
                                cpuTemp = sensor.Value;
                            }
                        }
                    }

                    if (hardwareItem.HardwareType == HardwareType.GpuNvidia || hardwareItem.HardwareType == HardwareType.GpuAti)
                    {
                        foreach (var sensor in hardwareItem.Sensors)
                        {
                            if (sensor.SensorType == SensorType.Load && sensor.Name == "GPU Core")
                            {
                                gpuLoad = sensor.Value;
                            }
                            if (sensor.SensorType == SensorType.Temperature && sensor.Name == "GPU Core")
                            {
                                gpuTemp = sensor.Value;
                            }
                        }
                    }

                    if (hardwareItem.HardwareType == HardwareType.RAM)
                    {
                        foreach (var sensor in hardwareItem.Sensors)
                        {
                            if (sensor.SensorType == SensorType.Load && sensor.Name == "Memory")
                            {
                                ramUsage = sensor.Value;
                            }
                        }
                    }

                    if (hardwareItem.HardwareType == HardwareType.HDD)
                    {
                        foreach (var sensor in hardwareItem.Sensors)
                        {
                            if (sensor.SensorType == SensorType.Load && sensor.Name == "Used Space")
                            {
                                hddLoad = sensor.Value;
                            }
                        }
                    }
                }

                int activeThreads = Process.GetCurrentProcess().Threads.Count;
                ThreadPool.GetAvailableThreads(out int workerThreads, out int completionPortThreads);
                ThreadPool.GetMaxThreads(out int maxWorkerThreads, out int maxCompletionPortThreads);

                if (Variaveis.OperacaoEmAndamento.Sensoriamento != null)
                {
                    Variaveis.OperacaoEmAndamento.Sensoriamento.CPU_load = cpuLoad;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.GPU_load = gpuLoad;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.HDD_load = hddLoad;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.RAM_usage = ramUsage;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.CPU_temp = cpuTemp;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.GPU_temp = gpuTemp;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.ActiveThreads = activeThreads;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.WorkerThreads = workerThreads;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.MaxWorkerThreads = maxWorkerThreads;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.CompletionPortThreads = completionPortThreads;
                    Variaveis.OperacaoEmAndamento.Sensoriamento.MaxCompletionPortThreads = maxCompletionPortThreads;
                }
            }
        }


        #endregion

        #region REGISTRO DE LOGS

        private int idxLog = 0;

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

            //IniciarCameraCaminho(Variaveis.OperacaoEmAndamento.CameraCaminhoKinect);
        }

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

                OperacaoSensoriamentoLogModel logGeral = new OperacaoSensoriamentoLogModel()
                {
                    Momento = Agora,
                    CodigoFalha = Variaveis.OperacaoEmAndamento.RetornaCodigoFalha(),
                    VelocidadeMedia = Variaveis.OperacaoEmAndamento.Sensoriamento.VelocidadeMedia,
                    PorcentagemBateria = Variaveis.OperacaoEmAndamento.Sensoriamento.PorcentagemBateria,
                    BateriaConsumida = Variaveis.OperacaoEmAndamento.Sensoriamento.BateriaConsumida,
                    DistanciaDireita = Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaDireita,
                    DistanciaEsquerda = Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaEsquerda,
                    DistanciaPercorrida = new List<double>(Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaPercorrida),
                    AnguloCarroGPS = Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloCarroGPS,
                    DistAnguloCarroGPS = Variaveis.OperacaoEmAndamento.Sensoriamento.DistAnguloCarroGPS, 
                    AnguloCarroBussola = Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloCarroBussola,
                    AnguloCarro = Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloCarro,
                    SonarFrontal_Kinect = Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_Kinect,
                    StatusOperacao = Variaveis.OperacaoEmAndamento.Sensoriamento.StatusOperacao,
                    TempoMovimento = Variaveis.OperacaoEmAndamento.DispMvd.Dados.TempoEmAtividade,
                    StatusCarro = Variaveis.OperacaoEmAndamento.OpMapaGPS.ReferencialRuaGPS.StatusAtual,
                    ErvasNoRadar = Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ErvasNoRadar,
                    ErvasIdentificadas = new List<Dictionary<string, int>>(Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AtuacoesPorBico),
                    HerbicidaConsumido = Variaveis.OperacaoEmAndamento.Sensoriamento.HerbicidaConsumido,
                    HerbicidaPorErva = Variaveis.OperacaoEmAndamento.Sensoriamento.HerbicidaPorErva,
                    ProgressoTrajeto = Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoTrajeto,
                    ProgressoRua = Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoRua,
                    Direcao = Variaveis.OperacaoEmAndamento.OpMapaGPS.ReferencialRuaGPS.Direcao,
                    AnguloRua = Variaveis.OperacaoEmAndamento.Mapa.AnguloCaminho,
                    DentroDaRua = Variaveis.OperacaoEmAndamento.Mapa.DentroDaRua,
                    IdxPontoAproximadoRua = Variaveis.OperacaoEmAndamento.Mapa.IdxPontoAproximadoRua,
                    IdxRuaAtual = Variaveis.OperacaoEmAndamento.Mapa.IdxRuaAtual,
                    AnguloDif = Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloDif,
                    TipoMovimento = Variaveis.OperacaoEmAndamento.Controle.TipoMovimento,
                    Temperatura = Variaveis.OperacaoEmAndamento.Sensoriamento.Temperatura,
                    Altitude = Variaveis.OperacaoEmAndamento.Sensoriamento.Altitude,
                    InclinacaoX = Variaveis.OperacaoEmAndamento.Sensoriamento.InclinacaoX,
                    InclinacaoY = Variaveis.OperacaoEmAndamento.Sensoriamento.InclinacaoY,
                    InclinacaoZ = Variaveis.OperacaoEmAndamento.Sensoriamento.InclinacaoZ,
                    Pressao = Variaveis.OperacaoEmAndamento.Sensoriamento.Pressao,
                    AnguloRuaCamera = Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloRuaCamera,
                    CPU_load = Variaveis.OperacaoEmAndamento.Sensoriamento.CPU_load,
                    GPU_load = Variaveis.OperacaoEmAndamento.Sensoriamento.GPU_load,
                    HDD_load = Variaveis.OperacaoEmAndamento.Sensoriamento.HDD_load,
                    RAM_usage = Variaveis.OperacaoEmAndamento.Sensoriamento.RAM_usage,
                    CPU_temp = Variaveis.OperacaoEmAndamento.Sensoriamento.CPU_temp,
                    GPU_temp = Variaveis.OperacaoEmAndamento.Sensoriamento.GPU_temp,
                    ActiveThreads = Variaveis.OperacaoEmAndamento.Sensoriamento.ActiveThreads, 
                    WorkerThreads = Variaveis.OperacaoEmAndamento.Sensoriamento.WorkerThreads, 
                    MaxWorkerThreads = Variaveis.OperacaoEmAndamento.Sensoriamento.MaxWorkerThreads, 
                    CompletionPortThreads = Variaveis.OperacaoEmAndamento.Sensoriamento.CompletionPortThreads, 
                    MaxCompletionPortThreads = Variaveis.OperacaoEmAndamento.Sensoriamento.MaxCompletionPortThreads, 
                    OperacaoLiberada = Variaveis.OperacaoEmAndamento.OperacaoLiberada,
                    Dir_Status = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosMKS(Variaveis.OperacaoEmAndamento.Controle.TipoMovimento),
                    MovEsq_Status = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosBLD(Direcao.Esquerda),
                    MovDir_Status = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosBLD(Direcao.Direita),
                    PercentualErvasTerreno = Variaveis.OperacaoEmAndamento.Sensoriamento.PercentualErvasTerreno,
                    SonarFrontal_old = null,
                    Controle = Variaveis.OperacaoEmAndamento.Controle,
                };
                SalvarLog("operacao", logGeral, Fim);

                GPSModel logGps = new GPSModel()
                {
                    Momento = Agora, 
                    Inicializado = GPSService.Iniciado, 
                    DataHora = GPSService.UltimaLeitura.DataHora, 
                    Altitude = GPSService.UltimaLeitura.Altitude, 
                    DirecaoTrecho = GPSService.UltimaLeitura.DirecaoTrecho, 
                    idxRua = GPSService.UltimaLeitura.idxRua, 
                    Latitude = GPSService.UltimaLeitura.Latitude, 
                    Longitude = GPSService.UltimaLeitura.Longitude, 
                    NumeroSatelites = GPSService.UltimaLeitura.NumeroSatelites, 
                    Orientacao = GPSService.UltimaLeitura.Orientacao, 
                    PrecisaoHorizontal = GPSService.UltimaLeitura.PrecisaoHorizontal, 
                    Velocidade = GPSService.UltimaLeitura.Velocidade
                };
                SalvarLog(T_Code.Gps.ToString(), logGps, Fim);

                Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.ForEach(Modulo =>
                {
                    MovSensoriamentoLogModel logMov = new MovSensoriamentoLogModel()
                    {
                        Momento = Agora,
                        Modulo_ID = Modulo.Modulo_ID,
                        Inicializado = Modulo.MovMotor.BLD_Inicializado, 
                        RPM_SP = Modulo.MovMotor.RPM_SP,
                        RPM_Motor = Modulo.MovMotor.RPM_Motor,
                        RPM_Roda = Modulo.MovMotor.RPM_Roda,
                        Corrente = Modulo.MovMotor.Corrente,
                        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,
                        EmFreio = Modulo.MovMotor.ConfigFreio.Leitura,
                        Ativado = Modulo.MovMotor.LeituraLigado,
                        UltimoComandoRespondido = Modulo.MovMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
                    };
                    SalvarLog(T_Code.Mov.ToString(), logMov, false);

                    DirSensoriamentoLogModel logDir = new DirSensoriamentoLogModel()
                    {
                        Momento = Agora,
                        Modulo_ID = Modulo.Modulo_ID,
                        Inicializado = Modulo.DirMotor.MKS_Inicializado, 
                        Angulo = Modulo.DirMotor.Angulo, 
                        Angulo_SP = Modulo.DirMotor.Angulo_SP, 
                        Controlar = Modulo.DirMotor.Comandar, 
                        Sentido_SP = Modulo.DirMotor.Sentido_SP,
                        Sentido = Modulo.DirMotor.Sentido,
                        Velocidade = Modulo.DirMotor.Velocidade,
                        UltimoComandoRespondido = Modulo.DirMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
                    };
                    SalvarLog(T_Code.Dir.ToString(), logDir, false);
                });

                AtuSensoriamentoLogModel logAtu = new AtuSensoriamentoLogModel()
                {
                    Momento = Agora,
                    Inicializado = Variaveis.OperacaoEmAndamento.DispAtu.Dados.Conectado, 
                    QualidadeWifi = Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.QualidadeWifi, 
                    LatenciaLoop = Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.LatenciaLoop, 
                    MassaReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.MassaReservatorio, 
                    PercentualReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.PercentualReservatorio, 
                    VolumeReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VolumeReservatorio,
                    PressaoLinha_SP = Variaveis.OperacaoEmAndamento.Controle.PressaoLinha, 
                    PressaoLinha = Variaveis.OperacaoEmAndamento.DispAtu.Dados.PressaoLinha, 
                    PotenciaBomba = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombaPressurizadora.LeituraPotencia, 
                    BombaLigada = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombaPressurizadora.ComandoAtuar, 
                    VazaoFluxoMLpSInstantanea = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VazaoFluxoMLpSInstantanea, 
                    VazaoFluxoMLpSMedia = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VazaoFluxoMLpSMedia, 
                    VolumeVazaoML = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VolumeVazaoML, 
                    QuantidadeBicos = Variaveis.OperacaoEmAndamento.DispAtu.Dados.QuantidadeBicos,
                    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.MediaNivelFluxo,
                        Posicao = Bico.Posicao,
                        StatusBico = Bico.LeituraStatusBico, 
                        Atuacoes = Bico.Atuacoes,
                        TempoAtuado = Bico.TempoAtuado,
                    }).ToList()
                };
                SalvarLog(T_Code.Atu.ToString(), logAtu, false);

                var senLeitura = Variaveis.OperacaoEmAndamento.DispSen.Dados.DadosLeitura;
                SensoriamentoMensagemJsonModel logSen = new SensoriamentoMensagemJsonModel()
                {
                    Momento = Agora, 
                    Conectado = senLeitura.Conectado, 
                    LatenciaLoop = senLeitura.LatenciaLoop, 
                    QualidadeWifi = senLeitura.QualidadeWifi,
                    Mod_ID = senLeitura.Mod_ID, 
                    Reles = new List<FirmwareRele>(senLeitura.Reles),
                    SensoresCorrente = new List<FirmwareSensorCorrente>(senLeitura.SensoresCorrente), 
                    SensoresTemperatura = new List<FirmwareSensorTemperatura>(senLeitura.SensoresTemperatura), 
                    ServoFreios = new List<FirmwareServoFreio>(senLeitura.ServoFreios), 
                    Sinaleiros = new List<FirmwareSinaleiro>(senLeitura.Sinaleiros),
                };
                SalvarLog(T_Code.Sen.ToString(), logSen, false);

                PzmSensoriamentoLogModel logPzm = new PzmSensoriamentoLogModel()
                {
                    Momento = Agora,
                    Inicializado = PZEMService.Iniciado, 
                    DataHora = PZEMService.UltimaLeitura.DataHora, 
                    Tensao = PZEMService.UltimaLeitura.Tensao, 
                    Corrente = PZEMService.UltimaLeitura.Corrente, 
                    Potencia = PZEMService.UltimaLeitura.Potencia, 
                    Energia = PZEMService.UltimaLeitura.Energia, 
                    AlarmeTensaoMin = PZEMService.UltimaLeitura.AlarmeTensaoMin, 
                    AlarmeTensaoMax = PZEMService.UltimaLeitura.AlarmeTensaoMax
                };
                SalvarLog(T_Code.Pzm.ToString(), logPzm, Fim);

                WitSensoriamentoLogModel logWit = new WitSensoriamentoLogModel()
                {
                    Momento = Agora,
                    Inicializado = WT901CService.Iniciado, 
                    DataHora = WT901CService.DadosLeitura.DataHora,
                    AccM = WT901CService.DadosLeitura.AccM, 
                    Altitude = WT901CService.DadosLeitura.Altitude, 
                    AngleX = WT901CService.DadosLeitura.AngleX, 
                    AngleY = WT901CService.DadosLeitura.AngleY, 
                    AngleZ = WT901CService.DadosLeitura.AngleZ, 
                    AsM = WT901CService.DadosLeitura.AsM, 
                    HM = WT901CService.DadosLeitura.HM, 
                    Pressao = WT901CService.DadosLeitura.Pressao, 
                    Temperatura = WT901CService.DadosLeitura.Temperatura
                };
                SalvarLog(T_Code.Wit.ToString(), logWit, Fim);

                UltrasonicA05Model logA05 = new UltrasonicA05Model()
                {
                    Momento = Agora,
                    Endereco = UltrasonicA05Service.slaveAddress,
                    Conectado = UltrasonicA05Service.Iniciado, 
                    U1 = UltrasonicA05Service.DadosLeitura.U1, 
                    U2 = UltrasonicA05Service.DadosLeitura.U2, 
                    U3 = UltrasonicA05Service.DadosLeitura.U3, 
                    U4 = UltrasonicA05Service.DadosLeitura.U4, 
                    Configuracao = UltrasonicA05Service.DadosLeitura.Configuracao ?? Variaveis.OperacaoEmAndamento.DispSen.Dados.ConfiguracaoSensorUltrassom,
                };
                SalvarLog(T_Code.A05.ToString(), logA05, Fim);

                SalvarLogKinect(Agora);

                Task.Run(async () => await SalvarLogCameras(Agora));

                string ArquivoOp = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/data.lgop";
                if (!File.Exists(ArquivoOp))
                {
                    var data = new OperacaoDadosModel()
                    {
                        id = Variaveis.OperacaoEmAndamento.ID,
                        operacao = "operacao",
                        gps = T_Code.Gps.ToString(),
                        dir = T_Code.Dir.ToString(),
                        mov = T_Code.Mov.ToString(),
                        atu = T_Code.Atu.ToString(),
                        sen = T_Code.Sen.ToString(),
                        pzm = T_Code.Pzm.ToString(),
                        wit = T_Code.Wit.ToString(),
                        a05 = T_Code.A05.ToString(),
                        knt = T_Code.Knt.ToString(),
                        caminho = Variaveis.OperacaoEmAndamento.CameraCaminhoKinect.Nome,
                        soloE = Variaveis.OperacaoEmAndamento.CamerasSolo[0].Nome,
                        soloD = Variaveis.OperacaoEmAndamento.CamerasSolo[1].Nome
                    };
                    File.WriteAllText(ArquivoOp, JsonConvert.SerializeObject(data));
                }

                Variaveis.OperacaoEmAndamento.idxLog++;


                if (Variaveis.OperacaoEmAndamento.idxLog % 2 == 0)
                {
                    LoRaService.EnviarDadosParaBase();
                }

            }
        }

        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 async Task SalvarLogCameras(DateTime Agora)
        {
            var cameraCaminho = Variaveis.OperacaoEmAndamento.CameraCaminhoKinect;

            var Cameras = Variaveis.OperacaoEmAndamento.CamerasSolo.Select(x => new
            {
                tipo = typeof(CamSoloSensoriamentoLogModel),
                nome = x.Nome,
                browser = x.browser,
            })
            .Union(new[] {
                new {
                    tipo = typeof(CamCaminhoSensoriamentoLogModel),
                    nome = cameraCaminho.Nome,
                    browser = cameraCaminho.browser,
                }
            })
            .ToList();


            foreach (var Camera in Cameras)
            {
                string Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/" + Camera.nome;
                if (!Directory.Exists(Caminho))
                {
                    Directory.CreateDirectory(Caminho);
                }

                Caminho += "/" + Variaveis.OperacaoEmAndamento.idxLog + ".jpg";
                Bitmap frame = null;

                if (Camera.tipo == typeof(CamSoloSensoriamentoLogModel))
                {
                    var leitura = Variaveis.OperacaoEmAndamento.CamerasSolo.First(x => x.Nome == Camera.nome).Leitura;
                    CamSoloSensoriamentoLogModel logCam = new CamSoloSensoriamentoLogModel()
                    {
                        Momento = Agora, 
                        Leitura = new CameraCoordenadasFrameModel()
                        {
                            timestamp = leitura.timestamp, 
                            x_max = leitura.x_max, 
                            y_max = leitura.y_max,
                            objetos = leitura.objetos.ToArray(),
                        }
                    };
                    SalvarLog(Camera.nome, logCam, false);

                    frame = await FuncoesGlobais.GetBrowserImage(Camera.browser);
                    FuncoesGlobais.SalvarImagemComprimida(frame, Caminho, 100L, 512, 512);
                }
                else if (Camera.tipo == typeof(CamCaminhoSensoriamentoLogModel))
                {
                    var leitura = cameraCaminho.Leitura;
                    CamCaminhoSensoriamentoLogModel logCam = new CamCaminhoSensoriamentoLogModel()
                    {
                        Momento = Agora,
                        ClassMap = new Dictionary<string, Color>(cameraCaminho.ClassMap),
                        PontosExtremos = new List<System.Drawing.Point>(cameraCaminho.PontosExtremos), 
                        Angulo = cameraCaminho.Angulo, 
                        AnguloDireito = cameraCaminho.AnguloDireito, 
                        AnguloEsquerdo = cameraCaminho.AnguloEsquerdo, 
                        Leitura = new CameraDeepLabV3PlusModel()
                        {
                            timestamp = leitura.timestamp,
                            Classes = leitura.Classes.Select(x => new CameraDeepLabV3PlusClasseModel()
                            {
                                Classe = x.Classe, 
                                Contornos = x.Contornos.ToArray(),
                            })
                            .ToList()
                        }
                    };
                    SalvarLog(Camera.nome, logCam, false);

                    if (cameraCaminho.camera._mqttTopico != null && cameraCaminho.camera._mqttTopico.Mensagens.Any())
                    {
                        string message = cameraCaminho.camera._mqttTopico.Mensagens[cameraCaminho.camera._mqttTopico.Mensagens.Count() - 1].Mensagem;
                        frame = cameraCaminho.ExtraiImagemDaMensagem(message);
                        FuncoesGlobais.SalvarImagemComprimida(frame, Caminho, 30L);
                    }
                }
            }
        }

        private void SalvarLogKinect(DateTime Agora)
        {
            KinectModel logKnt = new KinectModel()
            {
                Momento = Agora,
                AccW = KinectService.Leitura.AccW,
                AccX = KinectService.Leitura.AccX,
                AccY = KinectService.Leitura.AccY,
                AccZ = KinectService.Leitura.AccZ,
                AnguloElevacao = KinectService.Leitura.AnguloElevacao,
                Colisao = KinectService.Leitura.Colisao,
                DistanciaDaDireita = KinectService.Leitura.DistanciaDaDireita,
                DistanciaDaEsquerda = KinectService.Leitura.DistanciaDaEsquerda,
                Obstaculos = new List<Obstaculo>(KinectService.Leitura.Obstaculos),
                Subdivisoes = new List<Subdivisao>(KinectService.Parametros.Subdivisoes),
                Pitch = KinectService.Leitura.Pitch,
                Roll = KinectService.Leitura.Roll,
                VelX = KinectService.Leitura.VelX,
                VelY = KinectService.Leitura.VelY,
                VelZ = KinectService.Leitura.VelZ,
                Yaw = KinectService.Leitura.Yaw,
                UltimoCalculo = KinectService.Leitura.UltimoCalculo
            };
            SalvarLog(T_Code.Knt.ToString(), logKnt, false);

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

            string rgb = Caminho + "/rgb_" + Variaveis.OperacaoEmAndamento.idxLog + ".jpg";
            string heat = Caminho + "/heat_" + Variaveis.OperacaoEmAndamento.idxLog + ".jpg";

            lock (KinectService._lockBitmapRGB)
            {
                FuncoesGlobais.SalvarImagemComprimida(KinectService.bitmapRGB, rgb, 75L, 512, 512);
            }
            lock (KinectService._lockBitmapHeat)
            {
                FuncoesGlobais.SalvarImagemComprimida(KinectService.bitmapHeat, heat, 30L);
            }
        }

        
        #endregion


        public void AbrirForm()
        {
            if (Variaveis.OperacaoEmAndamento.OperacaoLiberada)
            {
                /*frmOperacao = (Form)Activator.CreateInstance((
                    Modo == ModoOperacao.Manual ? Variaveis.OperacaoEmAndamento.OpManual.frmOperacao :
                    Modo == ModoOperacao.MapaGPS ? Variaveis.OperacaoEmAndamento.OpMapaGPS.frmOperacao :
                    new Form()
                ).GetType());*/
                frmOperacao =
                    Modo == ModoOperacao.Manual ? new frmOperacaoManual() :
                    Modo == ModoOperacao.MapaGPS ? new frmOperacaoMapaGPS() :
                    new Form();
                //Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old = new SonarModel(FuncoesGlobais.FindControlRecursive<PictureBox>(frmOperacao, "picSonar"));
                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
            {
                return "Operação " + ModoNome;
            }
        }

        #region CODIGOS DE FALHAS

        public ulong RetornaCodigoFalha()
        {
            ulong Cod = 0x00;

            var _modsMandatorios = Variaveis.OperacaoEmAndamento.ModulosMandatorios.Where(x => x.Mandatorio).ToList();
            var _parametrosMandatorios = Variaveis.OperacaoEmAndamento.ParametrosMandatorios;
            var _sensoriamento = Variaveis.OperacaoEmAndamento.Sensoriamento;
            var _dispMVD = Variaveis.OperacaoEmAndamento.DispMvd;
            var _dispATU = Variaveis.OperacaoEmAndamento.DispAtu;
            var _dispSEN = Variaveis.OperacaoEmAndamento.DispSen;

            bool _emergencia = Variaveis.OperacaoEmAndamento.Emergencia;
            bool _operacaoIniciada = Variaveis.OperacaoEmAndamento.Iniciado;
            bool _operacaoLiberada = Variaveis.OperacaoEmAndamento.OperacaoLiberada;
            (bool _modulosConectados, List<T_Code> modsComFalha) = Variaveis.OperacaoEmAndamento.ModulosConectados;

            bool _camerasSoloConectadas =
                !_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo) ||
                _parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo && !x.Mandatorio) ||
                (_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo && x.Mandatorio) &&
                Variaveis.OperacaoEmAndamento.CamerasSolo.Count(y => y.Iniciada) == Variaveis.OperacaoEmAndamento.QuantidadeCamerasSolo);

            bool _kinectConectado =
                !_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Kinect) ||
                _parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Kinect && !x.Mandatorio) ||
                (_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Kinect && x.Mandatorio) &&
                (_sensoriamento.SonarFrontal_Kinect != null && _sensoriamento.SonarFrontal_Kinect.Iniciado));

            bool _mapaIniciado =
                !_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa) ||
                _parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && !x.Mandatorio) ||
                (_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && x.Mandatorio) &&
                Variaveis.OperacaoEmAndamento.Mapa.mapaService.Carregado);

            bool _joystickConectado =
                !_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick) ||
                _parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick && !x.Mandatorio) ||
                (_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick && x.Mandatorio) &&
                GeneralJoystick.JoystickConectado != null);

            (bool _atuOperante, List<string> atuModsFalha) = _dispATU == null ? (false, new List<string>()) : _dispATU.Dados.StatusModulosATU();
            (bool _senOperante, List<string> senModsFalha) = _dispSEN == null ? (false, new List<string>()) : _dispSEN.Dados.StatusModulosSEN();
            (bool _dirOperante, List<string> dirModsFalha) = _dispMVD == null ? (false, new List<string>()) : _dispMVD.Dados.StatusModulosMKS(Variaveis.OperacaoEmAndamento.Controle.TipoMovimento);
            (bool _movEsqOperante, List<string> movEsqModsFalha) = _dispMVD == null ? (false, new List<string>()) : _dispMVD.Dados.StatusModulosBLD(Direcao.Esquerda);
            (bool _movDirOperante, List<string> movDirModsFalha) = _dispMVD == null ? (false, new List<string>()) : _dispMVD.Dados.StatusModulosBLD(Direcao.Direita);

            bool _nivelBateriaEstavel =
                !_modsMandatorios.Any(x => x.Dispositivo == T_Code.Pzm) ||
                (_modsMandatorios.Any(x => x.Dispositivo == T_Code.Pzm) &&
                    !modsComFalha.Any(x => x == T_Code.Pzm) &&
                    _sensoriamento.PorcentagemBateria > VariaveisEquipamento.PercentualTensaoBateriaMin);

            var _sensorMassa = _dispATU == null ? null : _dispATU.Dados.Sensores.FirstOrDefault(x => x.Componente == S_Code.sMAS);
            bool _nivelReservatorioEstavel =
                !_modsMandatorios.Any(x => x.Dispositivo == T_Code.Atu) ||
                (_modsMandatorios.Any(x => x.Dispositivo == T_Code.Atu) &&
                    _sensorMassa != null && 
                    !modsComFalha.Any(x => x == T_Code.Atu) &&
                    !atuModsFalha.Contains(_sensorMassa.ID) &&
                    _dispATU.Dados.PercentualReservatorio > VariaveisEquipamento.PercentualReservatorioMin);

            var _sensorPressao = _dispATU == null ? null : _dispATU.Dados.Sensores.FirstOrDefault(x => x.Componente == S_Code.sPRS);
            bool _pressaoLinhaEstavel =
                !_modsMandatorios.Any(x => x.Dispositivo == T_Code.Atu) ||
                (_modsMandatorios.Any(x => x.Dispositivo == T_Code.Atu) &&
                    _sensorPressao != null && 
                    !modsComFalha.Any(x => x == T_Code.Atu) &&
                    !atuModsFalha.Contains(_sensorPressao.ID) &&
                    _dispATU.Dados.PressaoLinha >= (Variaveis.OperacaoEmAndamento.Controle.PressaoLinha *
                    VariaveisEquipamento.PercentualToleranciaPressaoLinha) &&
                    _dispATU.Dados.PressaoLinha <= (Variaveis.OperacaoEmAndamento.Controle.PressaoLinha *
                    (1 + VariaveisEquipamento.PercentualToleranciaPressaoLinha)));

            // Verificação de condições operacionais
            if (_emergencia)
                Cod |= 0x01; // Bit 0: Emergência ativada
            if (!_operacaoIniciada)
                Cod |= 0x02; // Bit 1: Operação não iniciada
            if (!_operacaoLiberada)
                Cod |= 0x04; // Bit 2: Operação não liberada

            // Verificação de conexões dos módulos principais
            if (!_modulosConectados)
                Cod |= 0x08; // Bit 3: Módulos desconectados
            if (!_camerasSoloConectadas)
                Cod |= 0x10; // Bit 4: Câmeras de solo não conectadas
            if (!_kinectConectado)
                Cod |= 0x20; // Bit 5: Kinect não conectado
            if (!_mapaIniciado)
                Cod |= 0x40; // Bit 6: Mapa não iniciado
            if (!_joystickConectado)
                Cod |= 0x80; // Bit 7: Joystick não conectado

            // Verificação de estado operacional de módulos principais
            if (!_atuOperante)
                Cod |= 0x100; // Bit 8: Atuador inoperante
            if (!_senOperante)
                Cod |= 0x200; // Bit 9: Sensoriamento inoperante
            if (!_dirOperante)
                Cod |= 0x400; // Bit 10: Direcional inoperante
            if (!_movEsqOperante)
                Cod |= 0x800; // Bit 11: Movimentação Esquerda inoperante
            if (!_movDirOperante)
                Cod |= 0x1000; // Bit 12: Movimentação Direita inoperante

            // Verificação de falhas específicas em `modsComFalha`
            foreach (var modFalha in modsComFalha)
            {
                switch (modFalha)
                {
                    case T_Code.Mov:
                        Cod |= 0x2000; // Bit 13: Falha no Módulo de Movimento
                        break;
                    case T_Code.Dir:
                        Cod |= 0x4000; // Bit 14: Falha no Módulo de Direção
                        break;
                    case T_Code.Sen:
                        Cod |= 0x8000; // Bit 15: Falha no Módulo de Sensores
                        break;
                    case T_Code.Atu:
                        Cod |= 0x10000; // Bit 16: Falha no Módulo ATU
                        break;
                    case T_Code.Gps:
                        Cod |= 0x20000; // Bit 17: Falha no Módulo GPS
                        break;
                    case T_Code.Pzm:
                        Cod |= 0x40000; // Bit 18: Falha no Módulo PZM
                        break;
                    case T_Code.Lra:
                        Cod |= 0x80000; // Bit 19: Falha no Módulo LRA
                        break;
                    case T_Code.Wit:
                        Cod |= 0x100000; // Bit 20: Falha no Módulo WIT
                        break;
                    case T_Code.Bld:
                        Cod |= 0x200000; // Bit 21: Falha no Módulo BLDC
                        break;
                    case T_Code.Mvd:
                        Cod |= 0x400000; // Bit 22: Falha no Módulo MVD
                        break;
                    case T_Code.Mbs:
                        Cod |= 0x800000; // Bit 23: Falha no Módulo MBS
                        break;
                    case T_Code.Mks:
                        Cod |= 0x1000000; // Bit 24: Falha no Módulo MKS
                        break;
                    case T_Code.Cam:
                        Cod |= 0x2000000; // Bit 25: Falha no Módulo de Câmera
                        break;
                    case T_Code.Knt:
                        Cod |= 0x4000000; // Bit 26: Falha no Módulo Kinect
                        break;
                    case T_Code.A05:
                        Cod |= 0x8000000; // Bit 27: Falha no Módulo A05
                        break;
                }
            }

            // Verificação de `atuModsFalha`
            foreach (var falha in atuModsFalha)
            {
                switch (falha)
                {
                    case "B01":
                        Cod |= 0x10000000; // Bit 28: Falha no atuador B01
                        break;
                    case "B02":
                        Cod |= 0x20000000; // Bit 29: Falha no atuador B02
                        break;
                    case "B03":
                        Cod |= 0x40000000; // Bit 30: Falha no atuador B03
                        break;
                    case "B04":
                        Cod |= 0x80000000; // Bit 31: Falha no atuador B04
                        break;
                    case "BOMBA":
                        Cod |= 0x100000000; // Bit 32: Falha na BOMBA
                        break;
                    case "FLXLN":
                        Cod |= 0x200000000; // Bit 33: Falha no atuador FLXLN
                        break;
                    case "MASRS":
                        Cod |= 0x400000000; // Bit 34: Falha no atuador MASRS
                        break;
                    case "PRSLN":
                        Cod |= 0x800000000; // Bit 35: Falha no atuador PRSLN
                        break;
                }
            }

            // Verificação de `senModsFalha`
            foreach (var falha in senModsFalha)
            {
                switch (falha)
                {
                    case "LEDMN":
                        Cod |= 0x1000000000; // Bit 36: Falha no LED MN
                        break;
                    case "LEDAT":
                        Cod |= 0x2000000000; // Bit 37: Falha no LED AT
                        break;
                    case "LEDOP":
                        Cod |= 0x4000000000; // Bit 38: Falha no LED OP
                        break;
                    case "TMVET":
                        Cod |= 0x8000000000; // Bit 39: Falha no TMV Esquerda Traseira
                        break;
                    case "TMVEF":
                        Cod |= 0x10000000000; // Bit 40: Falha no TMV Esquerda Frontal
                        break;
                    case "TMVDT":
                        Cod |= 0x20000000000; // Bit 41: Falha no TMV Direita Traseira
                        break;
                    case "TMVDF":
                        Cod |= 0x40000000000; // Bit 42: Falha no TMV Direita Frontal
                        break;
                    case "AB5V":
                        Cod |= 0x80000000000; // Bit 43: Falha no sensor AB 5V
                        break;
                    case "AB12V":
                        Cod |= 0x100000000000; // Bit 44: Falha no sensor AB 12V
                        break;
                    case "TBAT":
                        Cod |= 0x200000000000; // Bit 45: Falha na Temperatura da Bateria
                        break;
                    case "RLLRA":
                        Cod |= 0x400000000000; // Bit 46: Falha no sensor RLLRA
                        break;
                    case "FRO_ET":
                        Cod |= 0x800000000000; // Bit 47: Falha no sensor FRO Esquerda Traseira
                        break;
                    case "FRO_EF":
                        Cod |= 0x1000000000000; // Bit 48: Falha no sensor FRO Esquerda Frontal
                        break;
                    case "FRO_DT":
                        Cod |= 0x2000000000000; // Bit 49: Falha no sensor FRO Direita Traseira
                        break;
                    case "FRO_DF":
                        Cod |= 0x4000000000000; // Bit 50: Falha no sensor FRO Direita Frontal
                        break;
                }
            }

            // Verificação de `dirModsFalha`
            foreach (var falha in dirModsFalha)
            {
                switch (falha)
                {
                    case "ET":
                        Cod |= 0x8000000000000; // Bit 51: Falha na direção Esquerda Traseira
                        break;
                    case "EF":
                        Cod |= 0x10000000000000; // Bit 52: Falha na direção Esquerda Frontal
                        break;
                    case "DT":
                        Cod |= 0x20000000000000; // Bit 53: Falha na direção Direita Traseira
                        break;
                    case "DF":
                        Cod |= 0x40000000000000; // Bit 54: Falha na direção Direita Frontal
                        break;
                }
            }

            // Verificação de `movEsqModsFalha`
            foreach (var falha in movEsqModsFalha)
            {
                switch (falha)
                {
                    case "ET":
                        Cod |= 0x80000000000000; // Bit 55: Falha no motor Esquerda Traseira
                        break;
                    case "EF":
                        Cod |= 0x100000000000000; // Bit 56: Falha no motor Esquerda Frontal
                        break;
                }
            }

            // Verificação de `movDirModsFalha`
            foreach (var falha in movDirModsFalha)
            {
                switch (falha)
                {
                    case "DT":
                        Cod |= 0x200000000000000; // Bit 57: Falha no motor Direita Traseira
                        break;
                    case "DF":
                        Cod |= 0x400000000000000; // Bit 58: Falha no motor Direita Frontal
                        break;
                }
            }

            // Verificação de condições de bateria e reservatório
            if (!_nivelBateriaEstavel)
                Cod |= 0x800000000000000; // Bit 59: Nível da bateria abaixo do mínimo
            if (!_nivelReservatorioEstavel)
                Cod |= 0x1000000000000000; // Bit 60: Nível do reservatório abaixo do mínimo
            if (!_pressaoLinhaEstavel)
                Cod |= 0x2000000000000000; // Bit 61: Pressão da linha fora dos parâmetros

            return Cod;
        }

        public static string DescricaoCodigoFalha(ulong codigo)
        {
            Dictionary<string, List<string>> erros = new Dictionary<string, List<string>>()
            {
                { "Equipamento", new List<string>() },
                { "Parâmetros", new List<string>() },
                { "Módulos", new List<string>() },
                { "Atuador", new List<string>() },
                { "Direcional", new List<string>() },
                { "Movimentação", new List<string>() },
                { "Sensoriamento", new List<string>() },
                { "Operação", new List<string>() },
            };

            // Verificação de condições operacionais
            if ((codigo & 0x01) != 0)
                erros["Equipamento"].Add("Emergência ativado.");
            if ((codigo & 0x02) != 0)
                erros["Operação"].Add("Operação não iniciada.");
            if ((codigo & 0x04) != 0)
                erros["Operação"].Add("Operação não liberada.");

            // Verificação de conexões dos módulos principais
            if ((codigo & 0x08) != 0)
                erros["Módulos"].Add("Um ou mais módulos principais desconectados.");
            if ((codigo & 0x10) != 0)
                erros["Parâmetros"].Add("Uma ou mais câmeras de solo não conectadas.");
            if ((codigo & 0x20) != 0)
                erros["Parâmetros"].Add("Sonar Frontal não conectado.");
            if ((codigo & 0x40) != 0)
                erros["Parâmetros"].Add("Mapa da operação não caregado.");
            if ((codigo & 0x80) != 0)
                erros["Parâmetros"].Add("Joystick não conectado.");

            // Verificação de estado operacional de módulos principais
            if ((codigo & 0x100) != 0)
                erros["Módulos"].Add("Atuador inoperante.");
            if ((codigo & 0x200) != 0)
                erros["Módulos"].Add("Sensoriamento inoperante.");
            if ((codigo & 0x400) != 0)
                erros["Módulos"].Add("Direcional inoperante.");
            if ((codigo & 0x800) != 0)
                erros["Módulos"].Add("Movimentação Esquerdo inoperante.");
            if ((codigo & 0x1000) != 0)
                erros["Módulos"].Add("Movimentação Direito inoperante.");

            // Verificação de falhas específicas em `modsComFalha`
            if ((codigo & 0x2000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Movimentação.");
            if ((codigo & 0x4000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Direcional.");
            if ((codigo & 0x8000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Sensoriamento.");
            if ((codigo & 0x10000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Atuador.");
            if ((codigo & 0x20000) != 0)
                erros["Módulos"].Add("Falha no Módulo de GPS.");
            if ((codigo & 0x40000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Monitoramento de Bateria.");
            if ((codigo & 0x80000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Comunicação.");
            if ((codigo & 0x100000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Orientação.");
            if ((codigo & 0x200000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Movimentação BLD.");
            if ((codigo & 0x400000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Movimentação Unificada.");
            if ((codigo & 0x800000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Modbus.");
            if ((codigo & 0x1000000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Direcional MKS.");
            if ((codigo & 0x2000000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Câmeras.");
            if ((codigo & 0x4000000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Sonar Frontal.");
            if ((codigo & 0x8000000) != 0)
                erros["Módulos"].Add("Falha no Módulo de Ultrassom.");

            // Verificação de `atuModsFalha`
            if ((codigo & 0x10000000) != 0)
                erros["Atuador"].Add("Falha no atuador Bico Pulverizador B01.");
            if ((codigo & 0x20000000) != 0)
                erros["Atuador"].Add("Falha no atuador Bico Pulverizador B02.");
            if ((codigo & 0x40000000) != 0)
                erros["Atuador"].Add("Falha no atuador Bico Pulverizador B03.");
            if ((codigo & 0x80000000) != 0)
                erros["Atuador"].Add("Falha no atuador Bico Pulverizador B04.");
            if ((codigo & 0x100000000) != 0)
                erros["Atuador"].Add("Falha na Bomba Pressurizadora.");
            if ((codigo & 0x200000000) != 0)
                erros["Atuador"].Add("Falha no sensor de Fluxo/Vazão.");
            if ((codigo & 0x400000000) != 0)
                erros["Atuador"].Add("Falha no sensor de Massa/Volume.");
            if ((codigo & 0x800000000) != 0)
                erros["Atuador"].Add("Falha no sensor de Pressão da linha.");

            // Verificação de `senModsFalha`
            if ((codigo & 0x1000000000) != 0)
                erros["Sensoriamento"].Add("Falha no Sinaleiro Modo Manual.");
            if ((codigo & 0x2000000000) != 0)
                erros["Sensoriamento"].Add("Falha no Sinaleiro Modo Automático.");
            if ((codigo & 0x4000000000) != 0)
                erros["Sensoriamento"].Add("Falha no Sinaleiro Status da Operação.");
            if ((codigo & 0x8000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sensor de Temperatura Motor Esquerdo Traseira.");
            if ((codigo & 0x10000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sensor de Temperatura Motor Esquerdo Frontal.");
            if ((codigo & 0x20000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sensor de Temperatura Motor Direito Traseira.");
            if ((codigo & 0x40000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sensor de Temperatura Motor Direito Frontal.");
            if ((codigo & 0x80000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sensor de Tensão e Corrente no barramento 5V.");
            if ((codigo & 0x100000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sensor de Tensão e Corrente no barramento 12V.");
            if ((codigo & 0x200000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sensor de Temperatura da Bateria.");
            if ((codigo & 0x400000000000) != 0)
                erros["Sensoriamento"].Add("Falha no Relé controlador do módulo de Comunicação.");
            if ((codigo & 0x800000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sistema de freio Esquerdo Traseira.");
            if ((codigo & 0x1000000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sistema de freio Esquerdo Frontal.");
            if ((codigo & 0x2000000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sistema de freio Direito Traseira.");
            if ((codigo & 0x4000000000000) != 0)
                erros["Sensoriamento"].Add("Falha no sistema de freio Direito Frontal.");

            // Verificação de `dirModsFalha`
            if ((codigo & 0x8000000000000) != 0)
                erros["Direcional"].Add("Falha no Motor Direcional Esquerdo Traseira.");
            if ((codigo & 0x10000000000000) != 0)
                erros["Direcional"].Add("Falha no Motor Direcional Esquerdo Frontal.");
            if ((codigo & 0x20000000000000) != 0)
                erros["Direcional"].Add("Falha no Motor Direcional Direito Traseira.");
            if ((codigo & 0x40000000000000) != 0)
                erros["Direcional"].Add("Falha no Motor Direcional Direito Frontal.");

            // Verificação de `movEsqModsFalha`
            if ((codigo & 0x80000000000000) != 0)
                erros["Movimentação"].Add("Falha no Motor Movimentação Esquerdo Traseira.");
            if ((codigo & 0x100000000000000) != 0)
                erros["Movimentação"].Add("Falha no Motor Movimentação Esquerdo Frontal.");

            // Verificação de `movDirModsFalha`
            if ((codigo & 0x200000000000000) != 0)
                erros["Movimentação"].Add("Falha no Motor Movimentação Direito Traseira.");
            if ((codigo & 0x400000000000000) != 0)
                erros["Movimentação"].Add("Falha no Motor Movimentação Direito Frontal.");

            // Verificação de condições de bateria e reservatório
            if ((codigo & 0x800000000000000) != 0)
                erros["Operação"].Add("Nível da bateria abaixo do mínimo.");
            if ((codigo & 0x1000000000000000) != 0)
                erros["Operação"].Add("Nível do reservatório abaixo do mínimo.");
            if ((codigo & 0x2000000000000000) != 0)
                erros["Operação"].Add("Pressão da linha fora dos parâmetros.");

            // Retorna a lista de erros como uma string única
            var resultado = new StringBuilder();
            foreach (var categoria in erros)
            {
                if (categoria.Value.Count > 0)
                {
                    resultado.AppendLine($"{categoria.Key}:");
                    resultado.AppendLine(string.Join(", ", categoria.Value));
                }
            }

            return resultado.Length > 0 ? resultado.ToString() : "Nenhuma falha detectada.";
        }

        public static void PopularTreeView(TreeView treeView, ulong codigoFalhas)
        {
            // Limpar o TreeView antes de adicionar novos nós
            treeView.Nodes.Clear();

            // Obtenha a descrição das falhas com base no código atual
            string descricao = DescricaoCodigoFalha(codigoFalhas);

            // Quebra a descrição em linhas, separando os tópicos e subitens
            string[] linhas = descricao.Split(new[] { Environment.NewLine }, StringSplitOptions.None);

            TreeNode topicoAtual = null;

            // Iterar sobre as linhas geradas pela descrição
            foreach (string linha in linhas)
            {
                // Identificar se é um novo tópico (assumimos que tem dois pontos ':' no fim)
                if (linha.EndsWith(":"))
                {
                    // Criar um novo nó principal para o tópico
                    topicoAtual = new TreeNode(linha.TrimEnd(':'));
                    treeView.Nodes.Add(topicoAtual);
                }
                else if (topicoAtual != null && !string.IsNullOrWhiteSpace(linha))
                {
                    // Adicionar sub-nós (falhas específicas) ao tópico atual
                    string[] topicos = linha.Split(new[] { ',' }, StringSplitOptions.None);
                    topicoAtual.Nodes.AddRange(topicos.Select(x => new TreeNode(x.Trim())).ToArray());
                }
            }

            // Expandir todos os nós para melhor visualização
            treeView.ExpandAll();
        }


        #endregion

    }


    public class OperacaoControleModel
    {
        public int RPM_Max { get; set; } = 100;
        public int RPM_Min { get; set; } = 15;
        public double Angulo_Max { get; set; } = 30;
        public double Angulo_Min { get; set; } = -30;
        public double VelocidadeMP { get; set; } = 50;

        public double Angulo { get; set; } = 0;
        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);
            }
        }
        public double PercentualVelocidadeSP { get; set; } = 0.0;
        public double PercentualVelocidadeMin
        {
            get
            {
                return FuncoesMatematicas.Map(RPM_Min, 0, VariaveisEquipamento.RPM_Max_Roda, 0, 100);
            }
        }
        public double PercentualVelocidadeMax
        {
            get
            {
                return FuncoesMatematicas.Map(RPM_Max, 0, VariaveisEquipamento.RPM_Max_Roda, 0, 100);
            }
        }
        public Direcao Direcao { get; set; } = Direcao.Parado;
        private TipoMovimentoDirecional _tipoMovimento;
        public TipoMovimentoDirecional TipoMovimento 
        { 
            get
            {
                return _tipoMovimento;
            }
            set
            {
                var DispMvd = Variaveis.OperacaoEmAndamento.DispMvd;
                if (DispMvd != null)
                {
                    switch (value)
                    {
                        case TipoMovimentoDirecional.RodasDianteiras:
                            DispMvd.Dados.Modulos.ForEach(x =>
                            {
                                x.MovMotor.Comandar = true;
                                x.DirMotor.Comandar = x.Modulo_ID.Contains("F");
                            });
                            break;
                        case TipoMovimentoDirecional.RodasTraseiras:
                            DispMvd.Dados.Modulos.ForEach(x =>
                            {
                                x.MovMotor.Comandar = true;
                                x.DirMotor.Comandar = x.Modulo_ID.Contains("T");
                            });
                            break;
                        default:
                            DispMvd.Dados.Modulos.ForEach(x =>
                            {
                                x.MovMotor.Comandar = true;
                                x.DirMotor.Comandar = true;
                            });
                            break;
                    }
                }
                _tipoMovimento = value;
            }
        }

        public double PercentualInicioPulverizacao { get; set; } = 0.3;
        public List<AtuadorBicoModel> BicosAtuados { get; set; } = new List<AtuadorBicoModel>();
        public int TempoAtuacao { get; set; } = 200;
        public double PressaoLinha { get; set; } = 85;

        public List<OperacaoControleTipoModel> TiposControle { get; set; }
        public PIDModel PIDdirecional { get; set; } = new PIDModel();
        public bool PulverizadorAutomatico { get; set; } = true;
        public bool SegmentacaoSemantica { get; set; } = false;
        public bool SonarAtivado { get; set; } = false;
        public bool SonarDesvioAutomatico { get; set; } = false;
    }

    public class OperacaoControleTipoModel
    {
        public T_Code Tipo { get; set; }
        public int DelayEnvioComando { get; set; }
        public DateTime UltimoComando { get; set; }
        public List<string> Comandos { get; set; }
        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 class OperacaoParametrosMandatoriosModel
    {
        public ParametrosOperacao Parametro { get; set; }
        public bool Mandatorio { get; set; }
        public bool Utilizar { get; set; }
        public bool Pronto { get; set; }
    }

    public class OperacaoControleBaseModel
    {
        public DateTime Momento { get; set; }
        public Keys Tecla { get; set; }
        public T_Code Dispositivo { get; set; }
        public double PercentualVelocidadeSP { get; set; }
        public double AnguloMP { get; set; }
        public double VelocidadeMP { get; set; }
        public bool Emergencia { get; set; }
        public TipoMovimentoDirecional TipoMovimento { get; set; }
    }


    public class OperacaoDadosModel
    {
        public string id { get; set; }
        public string operacao { get; set; }
        public string gps { get; set; }
        public string dir { get; set; }
        public string mov { get; set; }
        public string atu { get; set; }
        public string sen { get; set; }
        public string pzm { get; set; }
        public string wit { get; set; }
        public string knt { get; set; }
        public string a05 { get; set; }
        public string caminho { get; set; }
        public string soloE { get; set; }
        public string soloD { get; set; }
    }

    public class OperacaoSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public ulong CodigoFalha { get; set; }
        public double VelocidadeMedia { get; set; } = 0.0;
        public double PorcentagemBateria { get; set; } = 0.0;
        public double BateriaConsumida { get; set; } = 0;
        public List<double> DistanciaPercorrida { get; set; } = new List<double>();
        public double DistanciaEsquerda { get; set; } = 0;
        public double DistanciaDireita { get; set; } = 0;
        public double AnguloCarroGPS { get; set; } = 0.0;
        public double DistAnguloCarroGPS { get; set; } = 0.0;
        public double AnguloCarroBussola { get; set; } = 0;
        public double AnguloCarro { get; set; } = 0.0;
        public KinectModel SonarFrontal_Kinect { get; set; } = null;
        public SonarModel SonarFrontal_old { get; set; }
        public double TempoMovimento { get;set; }
        public StatusOperacao StatusOperacao { get; set; } = StatusOperacao.Parado;
        public StatusCarroMapa StatusCarro { get; set; }
        public int ErvasNoRadar { get; set; } = 0;
        public double HerbicidaConsumido { get; set; } = 0;
        public double HerbicidaPorErva { get; set; } = 0;
        public List<Dictionary<string, int>> ErvasIdentificadas { get; set; } = new List<Dictionary<string, int>>();
        public double ProgressoTrajeto { get; set; } = 0;
        public double ProgressoRua { get; set; } = 0;
        public double AnguloRua { get; set; } = 0;
        public double AnguloRuaCamera { get; set; } = 0;
        public double AnguloDif { get; set; } = 0;
        public DirecaoCarroRua Direcao { get; set; } = DirecaoCarroRua.Parado;
        public bool DentroDaRua { get; set; } = false;
        public int IdxPontoAproximadoRua { get; set; } = 0;
        public int IdxRuaAtual { get; set; } = 0;
        public double InclinacaoX { get; set; } = 0;
        public double InclinacaoY { get; set; } = 0;
        public double InclinacaoZ { get; set; } = 0;
        public double Temperatura { get; set; } = 0;
        public double Pressao { get; set; } = 0;
        public double Altitude { get; set; } = 0;
        public TipoMovimentoDirecional TipoMovimento { get; set; }
        public float? CPU_load { get; set; }
        public float? GPU_load { get; set; }
        public float? HDD_load { get; set; }
        public float? RAM_usage { get; set; }
        public float? CPU_temp { get; set; }
        public float? GPU_temp { get; set; }
        public int ActiveThreads { get; set; }
        public int WorkerThreads { get; set; }
        public int CompletionPortThreads { get; set; }
        public int MaxWorkerThreads { get; set; }
        public int MaxCompletionPortThreads { get; set; }
        public bool OperacaoLiberada { get; set; }
        public (bool, List<string>) MovEsq_Status { get; set; }
        public (bool, List<string>) MovDir_Status { get; set; }
        public (bool, List<string>) Dir_Status { get; set; }
        public double PercentualErvasTerreno { get; set; }
        public OperacaoControleModel Controle { get; set; }

        public void ReiniciarLeituras()
        {
            Momento = DateTime.Now;
            CodigoFalha = 0;
            VelocidadeMedia = 0.0;
            PorcentagemBateria = 0.0;
            BateriaConsumida = 0;
            DistanciaPercorrida = new List<double>();
            DistanciaEsquerda = 0;
            DistanciaDireita = 0;
            AnguloCarroGPS = 0.0;
            AnguloCarroBussola = 0;
            AnguloCarro = 0.0;
            SonarFrontal_Kinect = null;
            SonarFrontal_old = null;
            TempoMovimento = 0;
            StatusOperacao = StatusOperacao.NaoIniciado;
            StatusCarro = StatusCarroMapa.Parado;
            ErvasNoRadar = 0;
            HerbicidaConsumido = 0;
            HerbicidaPorErva = 0;
            ErvasIdentificadas = new List<Dictionary<string, int>>();
            ProgressoTrajeto = 0;
            ProgressoRua = 0;
            AnguloRua = 0;
            AnguloRuaCamera = 0;
            AnguloDif = 0;
            Direcao = DirecaoCarroRua.Parado;
            DentroDaRua = false;
            IdxPontoAproximadoRua = 0;
            IdxRuaAtual = 0;
            InclinacaoX = 0;
            InclinacaoY = 0;
            InclinacaoZ = 0;
            Temperatura = 0;
            Pressao = 0;
            Altitude = 0;
            CPU_load = null;
            GPU_load = null;
            HDD_load = null;
            RAM_usage = null;
            CPU_temp = null;
            GPU_temp = null;
            OperacaoLiberada = false;
            MovEsq_Status = (false, new List<string>());
            MovDir_Status = (false, new List<string>());
            Dir_Status = (false, new List<string>());
            PercentualErvasTerreno = 0;
        }
    }

    public class PzmSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public DateTime DataHora { get; set; }
        public bool Inicializado { get; set; }
        public double Tensao { get; set; }
        public double Corrente { get; set; }
        public double Potencia { get; set; }
        public double Energia { get; set; }
        public bool AlarmeTensaoMax { get; set; }
        public bool AlarmeTensaoMin { get; set; }
    }

    public class WitSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public DateTime DataHora { get; set; }
        public bool Inicializado { get; set; }
        public double AccM { get; set; }
        public double AsM { get; set; }
        public double AngleX { get; set; }
        public double AngleY { get; set; }
        public double AngleZ { get; set; }
        public double HM { get; set; }
        public double Temperatura { get; set; }
        public double Pressao { get; set; }
        public double Altitude { get; set; }
    }

    public class DirSensoriamentoLogModel
    {
        public DateTime Momento { get; set; }
        public string Modulo_ID { get; set; }
        public bool Inicializado { get; set; }
        public bool Controlar { get; set; }
        public double Angulo_SP { get; set; }
        public double Angulo { get; set; }
        public Sentido Sentido_SP { get; set; }
        public Sentido Sentido { get; set; }
        public double Velocidade { 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 { get; set; }
        public double Tensao { get; set; }
        public int CodAlarme { 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 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 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; }
    }

}