755 lines
29 KiB
C#
755 lines
29 KiB
C#
using System.ComponentModel;
|
|
using System.Windows.Input;
|
|
using OperationControl.Views;
|
|
using OperationControl.Helpers;
|
|
using System.Windows;
|
|
using OperationControl.Models;
|
|
using OperationControl.Views.Operacao;
|
|
using AgroBase.Models.Operacoes;
|
|
using Newtonsoft.Json.Linq;
|
|
using OperationControl.ViewModels.Views.Operacao;
|
|
|
|
namespace OperationControl.ViewModels
|
|
{
|
|
public class DockWindowViewModel : INotifyPropertyChanged
|
|
{
|
|
private readonly ConfigConexaoView _viewConfig;
|
|
|
|
private readonly PreparacaoMapaView _viewPreparacaoMapa;
|
|
public readonly PreparacaoMapaTopView _viewPreparacaoMapaTop;
|
|
private readonly PreparacaoMapaBottomView _viewPreparacaoMapaBottom;
|
|
|
|
private readonly OperacaoTopView _viewOperacaoTop;
|
|
private readonly OperacaoCenterView _viewOperacaoCenter;
|
|
public readonly OperacaoLeftView _viewOperacaoLeft;
|
|
public readonly OperacaoRightView _viewOperacaoRight;
|
|
public readonly OperacaoBottomView _viewOperacaoBottom;
|
|
|
|
private DockStep _currentStep;
|
|
|
|
public DockWindowViewModel()
|
|
{
|
|
// Views
|
|
_viewConfig = new ConfigConexaoView();
|
|
_viewConfig._vm.TudoOkChanged += OnTudoOkChanged;
|
|
|
|
_viewPreparacaoMapa = new PreparacaoMapaView();
|
|
|
|
_viewPreparacaoMapaTop = new PreparacaoMapaTopView();
|
|
|
|
_viewPreparacaoMapaBottom = new PreparacaoMapaBottomView();
|
|
_viewPreparacaoMapaBottom._vm.CarregarMapaSolicitado += OnCarregarMapaSolicitado;
|
|
_viewPreparacaoMapaBottom._vm.FixarBaseSolicitado += OnFixarBaseSolicitado;
|
|
|
|
_viewOperacaoTop = new OperacaoTopView();
|
|
|
|
_viewOperacaoCenter = new OperacaoCenterView();
|
|
_viewOperacaoCenter._vm.RoverSelecionadoChanged += OnRoverSelecionadoChanged;
|
|
|
|
_viewOperacaoLeft = new OperacaoLeftView();
|
|
|
|
_viewOperacaoRight = new OperacaoRightView();
|
|
_viewOperacaoRight._vm.PropertyChanged += OperacaoRightVm_PropertyChanged;
|
|
_viewOperacaoRight._vm.RoverSelecionadoChanged += OnRoverSelecionadoChanged;
|
|
_viewOperacaoRight._vm.SecaoSelecionadaChanged += OnSecaoSelecionadaChanged;
|
|
_viewOperacaoRight._vm.LerParametrosSolicitado += OnLerParametrosSolicitado;
|
|
_viewOperacaoRight._vm.SalvarParametrosSolicitado += OnSalvarParametrosSolicitado;
|
|
|
|
_viewOperacaoBottom = new OperacaoBottomView();
|
|
_viewOperacaoBottom._vm.AlertaSelecionadoChanged += OnAlertaSelecionadoChanged;
|
|
|
|
// Commands
|
|
BackCommand = new RelayCommand(_ => GoBack(), _ => CanGoBack);
|
|
NextCommand = new RelayCommand(_ => GoNext(), _ => CanGoNext);
|
|
|
|
// Estado inicial
|
|
ConfigConexaoOk = _viewConfig._vm.TudoOk;
|
|
CurrentStep = DockStep.ConfigConexao;
|
|
}
|
|
|
|
private void OnTudoOkChanged(bool ok)
|
|
{
|
|
ConfigConexaoOk = ok;
|
|
|
|
OnPropertyChanged(nameof(CanGoNext));
|
|
CommandManager.InvalidateRequerySuggested();
|
|
}
|
|
|
|
// ====== ETAPA ATUAL ======
|
|
public ModoOperacao ModoOperacaoAtual => _viewConfig._vm.TipoOperacaoSelecionado;
|
|
|
|
public DockStep CurrentStep
|
|
{
|
|
get => _currentStep;
|
|
set
|
|
{
|
|
if (_currentStep != value)
|
|
{
|
|
_currentStep = value;
|
|
OnPropertyChanged(nameof(CurrentStep));
|
|
OnPropertyChanged(nameof(CanGoBack));
|
|
OnPropertyChanged(nameof(CanGoNext));
|
|
OnPropertyChanged(nameof(MostrarPainelEsquerdo));
|
|
OnPropertyChanged(nameof(MostrarBotaoVoltarEsquerda));
|
|
OnPropertyChanged(nameof(RightPanelWidth));
|
|
OnPropertyChanged(nameof(LeftPanelWidth));
|
|
|
|
AtualizarConteudo();
|
|
CommandManager.InvalidateRequerySuggested();
|
|
}
|
|
}
|
|
}
|
|
|
|
// ====== ESTADO ======
|
|
private bool _configConexaoOk;
|
|
public bool ConfigConexaoOk
|
|
{
|
|
get => _configConexaoOk;
|
|
set
|
|
{
|
|
if (_configConexaoOk != value)
|
|
{
|
|
_configConexaoOk = value;
|
|
OnPropertyChanged(nameof(ConfigConexaoOk));
|
|
OnPropertyChanged(nameof(CanGoNext));
|
|
CommandManager.InvalidateRequerySuggested();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _mapaCarregado;
|
|
public bool MapaCarregado
|
|
{
|
|
get => _mapaCarregado;
|
|
set
|
|
{
|
|
if (_mapaCarregado != value)
|
|
{
|
|
_mapaCarregado = value;
|
|
OnPropertyChanged(nameof(MapaCarregado));
|
|
OnPropertyChanged(nameof(CanGoNext));
|
|
CommandManager.InvalidateRequerySuggested();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _baseFixada;
|
|
public bool BaseFixada
|
|
{
|
|
get => _baseFixada;
|
|
set
|
|
{
|
|
if (_baseFixada != value)
|
|
{
|
|
_baseFixada = value;
|
|
OnPropertyChanged(nameof(BaseFixada));
|
|
OnPropertyChanged(nameof(CanGoNext));
|
|
CommandManager.InvalidateRequerySuggested();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool CanGoBack => CurrentStep != DockStep.ConfigConexao;
|
|
|
|
public bool CanGoNext
|
|
{
|
|
get
|
|
{
|
|
return CurrentStep switch
|
|
{
|
|
DockStep.ConfigConexao => PodeAvancarConfigConexao(),
|
|
DockStep.PreparacaoMapa => MapaCarregado && BaseFixada,
|
|
_ => false
|
|
};
|
|
}
|
|
}
|
|
private bool PodeAvancarConfigConexao()
|
|
{
|
|
return ModoOperacaoAtual switch
|
|
{
|
|
ModoOperacao.Automatico => _viewConfig._vm.RedeOk && _viewConfig._vm.GnssOk,
|
|
ModoOperacao.Manual => _viewConfig._vm.RedeOk,
|
|
_ => false
|
|
};
|
|
}
|
|
|
|
|
|
public bool MostrarPainelEsquerdo => CurrentStep == DockStep.ParametrizacaoRover;
|
|
public bool MostrarBotaoVoltarEsquerda => CurrentStep != DockStep.ParametrizacaoRover;
|
|
|
|
public GridLength LeftPanelWidth
|
|
{
|
|
get
|
|
{
|
|
return CurrentStep switch
|
|
{
|
|
DockStep.ParametrizacaoRover => new GridLength(280),
|
|
_ => new GridLength(60)
|
|
};
|
|
}
|
|
}
|
|
public GridLength RightPanelWidth
|
|
{
|
|
get
|
|
{
|
|
return CurrentStep switch
|
|
{
|
|
DockStep.ParametrizacaoRover => (_viewOperacaoRight?.DataContext as OperacaoRightViewModel)?.IsCollapsed == true
|
|
? new GridLength(44)
|
|
: new GridLength(320),
|
|
|
|
_ => new GridLength(60)
|
|
};
|
|
}
|
|
}
|
|
private void OperacaoRightVm_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
if (e.PropertyName == nameof(OperacaoRightViewModel.IsCollapsed))
|
|
{
|
|
OnPropertyChanged(nameof(RightPanelWidth));
|
|
}
|
|
}
|
|
|
|
// ====== CONTEÚDOS ======
|
|
private object _centerContent;
|
|
public object CenterContent
|
|
{
|
|
get => _centerContent;
|
|
set
|
|
{
|
|
_centerContent = value;
|
|
OnPropertyChanged(nameof(CenterContent));
|
|
}
|
|
}
|
|
|
|
private object _topContent;
|
|
public object TopContent
|
|
{
|
|
get => _topContent;
|
|
set
|
|
{
|
|
_topContent = value;
|
|
OnPropertyChanged(nameof(TopContent));
|
|
}
|
|
}
|
|
|
|
private object _bottomContent;
|
|
public object BottomContent
|
|
{
|
|
get => _bottomContent;
|
|
set
|
|
{
|
|
_bottomContent = value;
|
|
OnPropertyChanged(nameof(BottomContent));
|
|
}
|
|
}
|
|
private object _leftContent;
|
|
public object LeftContent
|
|
{
|
|
get => _leftContent;
|
|
set
|
|
{
|
|
_leftContent = value;
|
|
OnPropertyChanged(nameof(LeftContent));
|
|
}
|
|
}
|
|
private object _rightContent;
|
|
public object RightContent
|
|
{
|
|
get => _rightContent;
|
|
set
|
|
{
|
|
_rightContent = value;
|
|
OnPropertyChanged(nameof(RightContent));
|
|
}
|
|
}
|
|
|
|
// ====== COMMANDS ======
|
|
public ICommand BackCommand { get; }
|
|
public ICommand NextCommand { get; }
|
|
|
|
private void GoBack()
|
|
{
|
|
switch (CurrentStep)
|
|
{
|
|
case DockStep.PreparacaoMapa:
|
|
CurrentStep = DockStep.ConfigConexao;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void GoNext()
|
|
{
|
|
if (!CanGoNext) return;
|
|
|
|
switch (CurrentStep)
|
|
{
|
|
case DockStep.ConfigConexao:
|
|
if (ModoOperacaoAtual == ModoOperacao.Manual)
|
|
CurrentStep = DockStep.ParametrizacaoRover;
|
|
else
|
|
CurrentStep = DockStep.PreparacaoMapa;
|
|
break;
|
|
|
|
case DockStep.PreparacaoMapa:
|
|
CurrentStep = DockStep.ParametrizacaoRover;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private FrameworkElement CriarBotaoNextSimples()
|
|
{
|
|
return new System.Windows.Controls.Button
|
|
{
|
|
Content = "⮞",
|
|
FontSize = 24,
|
|
Width = 40,
|
|
Height = 40,
|
|
HorizontalAlignment = System.Windows.HorizontalAlignment.Center,
|
|
VerticalAlignment = VerticalAlignment.Center,
|
|
Command = NextCommand
|
|
};
|
|
}
|
|
|
|
private void AtualizarConteudo()
|
|
{
|
|
TopContent = null;
|
|
BottomContent = null;
|
|
LeftContent = null;
|
|
RightContent = null;
|
|
CenterContent = null;
|
|
|
|
switch (CurrentStep)
|
|
{
|
|
case DockStep.ConfigConexao:
|
|
CenterContent = _viewConfig;
|
|
RightContent = CriarBotaoNextSimples();
|
|
break;
|
|
|
|
case DockStep.PreparacaoMapa:
|
|
TopContent = _viewPreparacaoMapaTop;
|
|
CenterContent = _viewPreparacaoMapa;
|
|
BottomContent = _viewPreparacaoMapaBottom;
|
|
RightContent = CriarBotaoNextSimples();
|
|
break;
|
|
|
|
case DockStep.ParametrizacaoRover:
|
|
TopContent = _viewOperacaoTop;
|
|
LeftContent = _viewOperacaoLeft;
|
|
CenterContent = _viewOperacaoCenter;
|
|
RightContent = _viewOperacaoRight;
|
|
BottomContent = _viewOperacaoBottom;
|
|
|
|
if (!string.IsNullOrWhiteSpace(_ultimoMapaCarregado))
|
|
_viewOperacaoCenter?.MapaOperacao?.LoadMapFile(_ultimoMapaCarregado);
|
|
break;
|
|
}
|
|
|
|
OnPropertyChanged(nameof(MostrarPainelEsquerdo));
|
|
OnPropertyChanged(nameof(MostrarBotaoVoltarEsquerda));
|
|
}
|
|
|
|
// ====== INotifyPropertyChanged ======
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
private void OnPropertyChanged(string nome)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nome));
|
|
}
|
|
|
|
|
|
public void AtualizarDadosGnss(AgroBase.Models.GPSModel dados)
|
|
{
|
|
var bf = Variaveis.GpsService.BaseFix;
|
|
if (bf.CorrecaoEmAndamento)
|
|
{
|
|
AtualizarProgressoFixacaoBase(bf.Progresso, bf.ProgressoStr);
|
|
if (bf.Progresso >= 100) FinalizarFixacaoBase(true, bf.ProgressoStr);
|
|
}
|
|
switch (CurrentStep)
|
|
{
|
|
case DockStep.PreparacaoMapa:
|
|
System.Windows.Application.Current.Dispatcher.Invoke(() =>
|
|
{
|
|
_viewPreparacaoMapaTop?._vm?.AtualizarDados(dados);
|
|
_viewPreparacaoMapa?.MapaPreparacao?.markers?.UpdateMarkerPosition(VariaveisControleOperacao.BaseMarkerID, lat: dados?.Latitude, lon: dados?.Longitude, heading: dados?.OrientacaoReal);
|
|
});
|
|
break;
|
|
|
|
case DockStep.ParametrizacaoRover:
|
|
_viewOperacaoCenter?.MapaOperacao?.markers?.UpdateMarkerPosition(VariaveisControleOperacao.BaseMarkerID, lat: dados?.Latitude, lon: dados?.Longitude, heading: dados?.OrientacaoReal);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void AtualizarDadosMapa(OperacaoParametrosModel dados)
|
|
{
|
|
_viewOperacaoCenter?.MapaOperacao?.CarregarDadosMapa(dados?.Mapa, dados?.RuasPercorrer);
|
|
}
|
|
|
|
#region TELA 2
|
|
|
|
private string? _ultimoMapaCarregado;
|
|
|
|
private void OnCarregarMapaSolicitado(string caminhoArquivo)
|
|
{
|
|
try
|
|
{
|
|
_ultimoMapaCarregado = caminhoArquivo;
|
|
_viewPreparacaoMapa?.MapControl?.LoadMapFile(caminhoArquivo);
|
|
MapaCarregado = true;
|
|
_viewPreparacaoMapaBottom?._vm.AtualizarProgresso(0, $"Mapa carregado: {System.IO.Path.GetFileName(caminhoArquivo)}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MapaCarregado = false;
|
|
_viewPreparacaoMapaBottom?._vm.AtualizarProgresso(0, $"Erro ao carregar mapa: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
private async void OnFixarBaseSolicitado()
|
|
{
|
|
try
|
|
{
|
|
if (!Variaveis.GpsService.BaseFix.FixLiberado)
|
|
{
|
|
bool fixar = false;
|
|
|
|
if (Variaveis.GpsService.BaseFix.PosicaoBaseFixada)
|
|
{
|
|
var res = System.Windows.MessageBox.Show(
|
|
"Mudar posição da base?",
|
|
"Tem certeza que deseja fixar a posição da base novamente?",
|
|
MessageBoxButton.YesNo,
|
|
MessageBoxImage.Question);
|
|
|
|
if (res == MessageBoxResult.Yes)
|
|
fixar = true;
|
|
}
|
|
else
|
|
{
|
|
fixar = true;
|
|
}
|
|
|
|
if (fixar)
|
|
{
|
|
_viewPreparacaoMapaBottom?._vm.IniciarFixacao();
|
|
await Task.Run(async () => await Variaveis.GpsService.ConfigurarModulo(true));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Variaveis.GpsService.BaseFix.ReiniciarFix();
|
|
BaseFixada = false;
|
|
_viewPreparacaoMapaBottom?._vm.CancelarFixacao("Fixação da base interrompida pelo operador.");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_viewPreparacaoMapaBottom?._vm.FinalizarFixacao(false, $"Erro na fixação da base: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
public void AtualizarProgressoFixacaoBase(double progresso, string status)
|
|
{
|
|
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
_viewPreparacaoMapaBottom?._vm.AtualizarProgresso(progresso, status);
|
|
}));
|
|
}
|
|
|
|
public void FinalizarFixacaoBase(bool sucesso, string mensagem)
|
|
{
|
|
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
BaseFixada = sucesso;
|
|
_viewPreparacaoMapaBottom?._vm.FinalizarFixacao(sucesso, mensagem);
|
|
}));
|
|
}
|
|
|
|
public void CancelarFixacaoBase(string mensagem)
|
|
{
|
|
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
BaseFixada = false;
|
|
_viewPreparacaoMapaBottom?._vm.CancelarFixacao(mensagem);
|
|
}));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TELA 3
|
|
|
|
public void AtualizarTopOperacaoBase()
|
|
{
|
|
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
_viewOperacaoTop?._vm.DefinirStatusNormal("BASE", "Base selecionada. Sistema pronto.");
|
|
}));
|
|
}
|
|
|
|
public void AtualizarTopOperacaoRover(string nomeRover, bool modoManual)
|
|
{
|
|
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
if (modoManual)
|
|
_viewOperacaoTop?._vm.DefinirStatusManual($"{nomeRover}", "Rover em modo manual. Comandos locais liberados.");
|
|
else
|
|
_viewOperacaoTop?._vm.DefinirStatusNormal($"{nomeRover}", "Rover selecionado. Operação pronta.");
|
|
}));
|
|
}
|
|
|
|
public void AtualizarTopOperacaoAlerta(string contexto, string mensagem)
|
|
{
|
|
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
_viewOperacaoTop?._vm.DefinirStatusAtencao(contexto, mensagem);
|
|
}));
|
|
}
|
|
|
|
public void AtualizarTopOperacaoCritico(string contexto, string mensagem)
|
|
{
|
|
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
_viewOperacaoTop?._vm.DefinirStatusCritico(contexto, mensagem);
|
|
}));
|
|
}
|
|
|
|
|
|
private void OnAlertaSelecionadoChanged(AlertaModel alerta)
|
|
{
|
|
if (alerta == null) return;
|
|
|
|
AtualizarTopOperacaoAlerta(
|
|
$"ALERTA {alerta.Rover_ID}",
|
|
$"{alerta.Titulo}: {alerta.Mensagem}"
|
|
);
|
|
|
|
// depois você pode navegar para diagnostico, abrir popup, focar modulo, etc
|
|
}
|
|
|
|
public void AdicionarAlerta(string roverId, AgroBase.Models.Enums.T_Code modulo, SeveridadeAlerta severidade, string mensagem, string modId = null)
|
|
{
|
|
(_viewOperacaoBottom.DataContext as OperacaoBottomViewModel)?.AdicionarAlerta(roverId, modulo, severidade, mensagem, modId);
|
|
}
|
|
|
|
public void RemoverAlerta(string roverId, AgroBase.Models.Enums.T_Code modulo, SeveridadeAlerta? severidade = null, string modId = null)
|
|
{
|
|
(_viewOperacaoBottom.DataContext as OperacaoBottomViewModel)?.RemoverAlerta(roverId, modulo, severidade, modId);
|
|
}
|
|
|
|
|
|
public void AtualizarListaRovers(List<OperacaoParametrosModel> rovers_atual)
|
|
{
|
|
var cards = rovers_atual.Select(x => new RoverCardModel()
|
|
{
|
|
EquipamentoId = x.IP,
|
|
NumeroSerie = x.RoverId,
|
|
Status = x.DadosLeitura?.StatusRover ?? AgroBase.Models.Enums.StatusModulo.Desconectado
|
|
}).ToArray();
|
|
|
|
_viewOperacaoRight?._vm?.AtualizarListaRovers(cards);
|
|
|
|
foreach (var rover in cards)
|
|
{
|
|
if (!_viewOperacaoCenter?.MapaOperacao?.markers?.Added(rover.NumeroSerie) ?? false)
|
|
{
|
|
if (rover.NumeroSerie == VariaveisControleOperacao.BaseMarkerID)
|
|
{
|
|
_viewOperacaoCenter?.MapaOperacao?.markers?.AddMarker(
|
|
rover.NumeroSerie,
|
|
true,
|
|
lat: Variaveis.GpsService?.UltimaLeitura?.Latitude ?? 0,
|
|
lon: Variaveis.GpsService?.UltimaLeitura?.Longitude ?? 0,
|
|
heading: Variaveis.GpsService?.UltimaLeitura?.OrientacaoReal ?? 0,
|
|
label: "Base"
|
|
);
|
|
}
|
|
else
|
|
{
|
|
var roverDados = VariaveisControleOperacao.RoversNaRede.FirstOrDefault(x => x.RoverId == rover.NumeroSerie);
|
|
if (roverDados != null)
|
|
{
|
|
_viewOperacaoCenter?.MapaOperacao?.markers?.AddMarker(
|
|
rover.NumeroSerie,
|
|
false,
|
|
lat: roverDados.DadosLeitura?.Gnss?.Latitude ?? 0,
|
|
lon: roverDados.DadosLeitura?.Gnss?.Longitude ?? 0,
|
|
heading: roverDados.DadosLeitura?.Gnss?.OrientacaoReal ?? 0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void AtualizarDadosTela(OperacaoParametrosModel rover)
|
|
{
|
|
if (rover == null) return;
|
|
var obj = rover.DadosLeitura;
|
|
if (obj == null) return;
|
|
|
|
var simulacao = obj.Controle?.SimulacaoMPC?.Select(x => new double[] { x.longitude, x.latitude })?.ToList();
|
|
_viewOperacaoCenter?.MapaOperacao?.markers.UpdateMarkerPosition(rover.RoverId, lat: obj.Gnss?.Latitude, lon: obj.Gnss?.Longitude, heading: obj.Gnss?.OrientacaoReal, predict: simulacao);
|
|
_viewOperacaoCenter?.MapaOperacao?.markers.UpdateMarkerInfo(rover.RoverId, status: obj.Operacao?.Status ?? AgroBase.Models.Enums.StatusOperacao.NaoIniciado);
|
|
|
|
_viewOperacaoBottom?._vm?.AtualizarListaAlertasRoverSelecionado(rover.RoverId);
|
|
|
|
if (rover.RoverId == VariaveisControleOperacao.SelectedRoverId)
|
|
{
|
|
var conexao = obj.ModulosSaude?.FirstOrDefault(x => x.modulo == AgroBase.Models.Enums.T_Code.Ipb);
|
|
double c = conexao?.saude ?? 0;
|
|
double conexao_latencia = conexao?.detalhes?["avg_rtt"]?.Value<double>() ?? 0.0;
|
|
double conexao_perda = conexao?.detalhes?["loss_pct"]?.Value<double>() ?? 0.0;
|
|
double bwTot = conexao?.detalhes?["bw_total_mbps"]?.Value<double>() ?? 0;
|
|
string comunicacao = $"{conexao_latencia:0.00} ms {bwTot:0.00} Mbps";
|
|
string comunicacao_extended = $"{conexao_latencia:0.00} ms {conexao_perda:F2}% {bwTot:0.00} Mbps";
|
|
|
|
_viewOperacaoLeft?._vm?.AtualizarRover(
|
|
rover?.Descricao ?? "",
|
|
obj.Controle?.PercentualVelocidadeSPKmh ?? 0,
|
|
obj.Controle?.Angulo ?? 0,
|
|
obj.Controle?.TipoMovimento ?? AgroBase.Models.Enums.TipoMovimentoDirecional.Diagnostico,
|
|
obj.Refrigeracao?.Temperatura ?? 0,
|
|
obj.Bateria?.PercentualBateria ?? 0,
|
|
obj.Atuador?.PercentualReservatorio ?? 0,
|
|
$"{c}%",
|
|
$"{obj.Gnss?.QualidadeFix ?? AgroBase.Models.Enums.TiposCorrecaoGPS.SemCorrecao} {obj.Gnss?.PrecisaoCm:F2} cm"
|
|
);
|
|
|
|
_viewOperacaoRight?._vm?.AtualizarResumo(r =>
|
|
{
|
|
r.Operacao = (obj.Operacao?.Liberada ?? false) ? "🔓 Liberada" : "🔒 Bloqueada";
|
|
r.Modo = obj.Operacao == null ? "-" : obj.Operacao.Modo.ToString();
|
|
r.Status = obj.Operacao == null ? "-" : $"{obj.Operacao.Status}" + (obj.Operacao.Status == AgroBase.Models.Enums.StatusOperacao.Aguardando ? $" ({obj.Operacao.TempoAguardandoSegs:0}s)" : "");
|
|
r.Carro = obj.Trajetoria == null ? "-" : obj.Trajetoria.StatusCarro.ToString();
|
|
r.Temperatura = $"{(obj.PerformanceNcp?.CPU_temp ?? 0):0.00} °C";
|
|
r.RuaAtual = obj.Trajetoria == null ? "-" : $"{obj.Trajetoria.CorredorAtualDistanciaPercorrida:0.00} m / " + $"{obj.Trajetoria.CorredorAtualDistanciaTotal:0.00} m " + $"({obj.Trajetoria.CorredorAtualIdx + 1})";
|
|
r.AreaTotal = obj.Trajetoria == null ? "-" : $"{obj.Trajetoria.DistanciaPercorrida:0.00} m / " + $"{obj.Trajetoria.DistanciaTotal:0.00} m";
|
|
r.Bateria = obj.Bateria == null ? "-" : $"{obj.Bateria.TensaoInstantanea:0.00} V " + $"({TimeSpan.FromMinutes(obj.Bateria.TempoEstimadoRestanteMinutos):dd\\.hh\\:mm\\:ss} " + $"{obj.Bateria.DistanciaEstimadaRestanteMetros:0.00} m)";
|
|
r.Herbicida = obj.Atuador == null ? "-" : $"{obj.Atuador.VolumeReservatorioL:0.00} L " + $"({TimeSpan.FromMinutes(obj.Atuador.TempoEstimadoRestanteMinutos):hh\\:mm\\:ss} " + $"{obj.Atuador.DistanciaEstimadaRestanteMetros:0.00} m)";
|
|
r.Infestacao = obj.Atuador == null ? "-" : $"{obj.Atuador.HerbicidaPorAtuacaoMl:0.00} mL/atuação";
|
|
r.Conexao = comunicacao == null ? "-" : $"{comunicacao}";
|
|
r.Duracao = obj.Operacao == null ? "00:00:00 / 00:00:00" : $"{TimeSpan.FromSeconds(obj.Operacao.TempoDecorridoSegs):hh\\:mm\\:ss} / " + $"{(string.IsNullOrWhiteSpace(obj.Trajetoria?.TempoEstimadoOperacao) ? "00:00:00" : obj.Trajetoria.TempoEstimadoOperacao)}";
|
|
|
|
// Opcionais para progress bars, caso queira evoluir o resumo
|
|
r.RuaAtualPercentual = obj.Trajetoria?.PercentualRuaAtual ?? 0;
|
|
r.AreaTotalPercentual = obj.Trajetoria?.PercentualOperacao ?? 0;
|
|
r.BateriaPercentual = obj.Bateria?.PercentualBateria ?? 0;
|
|
r.HerbicidaPercentual = obj.Atuador?.PercentualReservatorio ?? 0;
|
|
r.InfestacaoPercentual = obj.Atuador?.PercentualErvasTerreno ?? 0;
|
|
});
|
|
|
|
_viewOperacaoCenter?._vm?.DiagnosticoVM?.AtualizarDados(rover);
|
|
_viewOperacaoCenter?.AtualizarGraficoDiagnostico(_viewOperacaoCenter?._vm?.DiagnosticoVM);
|
|
}
|
|
}
|
|
|
|
private void OnRoverSelecionadoChanged(string roverId)
|
|
{
|
|
_viewOperacaoRight?._vm?.DestacarRoverNoMapa(roverId);
|
|
}
|
|
|
|
private void OnRoverSelecionadoChanged(RoverCardModel rover)
|
|
{
|
|
bool dados_base = rover == null;
|
|
if (dados_base)
|
|
{
|
|
if (!VariaveisControleOperacao.BaseEmFoco)
|
|
{
|
|
_viewOperacaoCenter?.PararStreamCameraFrontal();
|
|
_viewOperacaoCenter?.PararStreamCameraErvas();
|
|
VariaveisControleOperacao.EnviarComandoIniciarUDP(VariaveisControleOperacao.RoverEmFoco?.IP, false);
|
|
}
|
|
VariaveisControleOperacao.RoverEmFoco?.RuasPercorrer?.Clear();
|
|
AtualizarDadosMapa(VariaveisControleOperacao.RoverEmFoco);
|
|
VariaveisControleOperacao.SelectedRoverId = VariaveisControleOperacao.BaseMarkerID;
|
|
_viewOperacaoCenter?.MapaOperacao?.markers?.SetMarkerFocused(VariaveisControleOperacao.SelectedRoverId, true);
|
|
|
|
_viewOperacaoCenter?._vm?.SelecionarRoverLista(rover);
|
|
|
|
AtualizarTopOperacaoRover(VariaveisControleOperacao.SelectedRoverId, true);
|
|
_viewOperacaoLeft?._vm?.DefinirSemRover();
|
|
}
|
|
else
|
|
{
|
|
VariaveisControleOperacao.SelectedRoverId = rover.NumeroSerie.ToString();
|
|
_viewOperacaoCenter?.MapaOperacao?.markers?.SetMarkerFocused(VariaveisControleOperacao.SelectedRoverId, true);
|
|
AtualizarDadosTela(VariaveisControleOperacao.RoverEmFoco);
|
|
|
|
VariaveisControleOperacao.RequisitarParametrosOperacao();
|
|
_viewOperacaoCenter?.IniciarStreamCameraFrontal();
|
|
_viewOperacaoCenter?.IniciarStreamCameraErvas();
|
|
VariaveisControleOperacao.EnviarComandoIniciarUDP(VariaveisControleOperacao.RoverEmFoco?.IP, true);
|
|
|
|
_viewOperacaoCenter?._vm?.SelecionarRoverLista(rover);
|
|
|
|
AtualizarTopOperacaoRover(VariaveisControleOperacao.SelectedRoverId, ModoOperacaoAtual == ModoOperacao.Manual);
|
|
}
|
|
}
|
|
private void OnSecaoSelecionadaChanged(SecaoRightBar secao)
|
|
{
|
|
_viewOperacaoCenter?._vm?.DefinirSecao(secao);
|
|
}
|
|
|
|
private void OnLerParametrosSolicitado()
|
|
{
|
|
if (VariaveisControleOperacao.RoverEmFoco == null)
|
|
return;
|
|
|
|
VariaveisControleOperacao.RequisitarParametrosOperacao();
|
|
|
|
_viewOperacaoRight?._vm?.AtualizarParametros(VariaveisControleOperacao.RoverEmFoco);
|
|
}
|
|
private void OnSalvarParametrosSolicitado(OperacaoParametrosModel parametros)
|
|
{
|
|
if (VariaveisControleOperacao.RoverEmFoco == null)
|
|
return;
|
|
|
|
var rover = VariaveisControleOperacao.RoverEmFoco;
|
|
|
|
VariaveisControleOperacao.EnviarParametrosOperacao(new OperacaoParametrosModel()
|
|
{
|
|
Modo = parametros.Modo ?? AgroBase.Models.Enums.ModoOperacao.NaoDefinido,
|
|
Descricao = parametros.Descricao,
|
|
QtdCamerasSolo = parametros.QtdCamerasSolo,
|
|
QtdBicos = parametros.QtdBicos,
|
|
CapacidadeReservatorio = parametros.CapacidadeReservatorio,
|
|
|
|
Controle = parametros.Controle,
|
|
|
|
ModulosMandatorios = rover?.ModulosMandatorios,
|
|
ParametrosMandatorios = rover?.ParametrosMandatorios,
|
|
|
|
RuasPercorrer = _viewOperacaoCenter?.MapaOperacao?.RuasMapaCarregado?.Where(x => x.Selected)?.Select(x => x.Id)?.ToList(),
|
|
Mapa = _viewOperacaoCenter?.MapaOperacao?.CriarDadosMapa()
|
|
});
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
public enum ModoOperacao
|
|
{
|
|
Automatico = 1,
|
|
Manual = 2
|
|
}
|
|
|
|
public enum DockStep
|
|
{
|
|
ConfigConexao = 1,
|
|
PreparacaoMapa = 2,
|
|
ParametrizacaoRover = 3
|
|
}
|
|
|
|
} |