1731 lines
64 KiB
C#
1731 lines
64 KiB
C#
using AgroBase.Models.Modules;
|
|
using AgroBase.Models.Operadores;
|
|
using AgroBase.Services;
|
|
using AgroBase.Services.Operadores;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Linq;
|
|
using static AgroBase.Models.Enums;
|
|
|
|
namespace AgroBase.Models.Operacoes
|
|
{
|
|
public class OperacaoParametrosModel
|
|
{
|
|
private string _roverId;
|
|
public string RoverId
|
|
{
|
|
get => _roverId;
|
|
set
|
|
{
|
|
if (_roverId != value)
|
|
{
|
|
_roverId = value;
|
|
OnPropertyChanged(nameof(RoverId));
|
|
}
|
|
}
|
|
}
|
|
|
|
private string _ip;
|
|
public string IP
|
|
{
|
|
get => _ip;
|
|
set
|
|
{
|
|
if (_ip != value)
|
|
{
|
|
_ip = value;
|
|
OnPropertyChanged(nameof(IP));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _alive;
|
|
public bool Alive
|
|
{
|
|
get => _alive;
|
|
set
|
|
{
|
|
if (_alive != value)
|
|
{
|
|
_alive = value;
|
|
OnPropertyChanged(nameof(Alive));
|
|
}
|
|
}
|
|
}
|
|
|
|
private ModoOperacao? _modo;
|
|
public ModoOperacao? Modo
|
|
{
|
|
get => _modo;
|
|
set
|
|
{
|
|
if (_modo != value)
|
|
{
|
|
_modo = value;
|
|
OnPropertyChanged(nameof(Modo));
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool ControleAutomatico => new List<ModoOperacao>() { ModoOperacao.MapaGPS, ModoOperacao.RetornoBase }.Contains(Modo ?? ModoOperacao.NaoDefinido);
|
|
|
|
private string _descricao;
|
|
public string Descricao
|
|
{
|
|
get => _descricao;
|
|
set
|
|
{
|
|
if (_descricao != value)
|
|
{
|
|
_descricao = value;
|
|
OnPropertyChanged(nameof(Descricao));
|
|
}
|
|
}
|
|
}
|
|
|
|
private int? _qtdCamerasSolo;
|
|
public int? QtdCamerasSolo
|
|
{
|
|
get => _qtdCamerasSolo;
|
|
set
|
|
{
|
|
if (_qtdCamerasSolo != value)
|
|
{
|
|
_qtdCamerasSolo = value;
|
|
OnPropertyChanged(nameof(QtdCamerasSolo));
|
|
}
|
|
}
|
|
}
|
|
|
|
private int? _qtdBicos;
|
|
public int? QtdBicos
|
|
{
|
|
get => _qtdBicos;
|
|
set
|
|
{
|
|
if (_qtdBicos != value)
|
|
{
|
|
_qtdBicos = value;
|
|
OnPropertyChanged(nameof(QtdBicos));
|
|
}
|
|
}
|
|
}
|
|
|
|
private double? _capacidadeReservatorio;
|
|
public double? CapacidadeReservatorio
|
|
{
|
|
get => _capacidadeReservatorio;
|
|
set
|
|
{
|
|
if (_capacidadeReservatorio != value)
|
|
{
|
|
_capacidadeReservatorio = value;
|
|
OnPropertyChanged(nameof(CapacidadeReservatorio));
|
|
}
|
|
}
|
|
}
|
|
|
|
private OperacaoParametrosControleModel _controle;
|
|
public OperacaoParametrosControleModel Controle
|
|
{
|
|
get => _controle;
|
|
set
|
|
{
|
|
if (_controle != value)
|
|
{
|
|
_controle = value;
|
|
OnPropertyChanged(nameof(Controle));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public DateTime UltimoContato { get; set; }
|
|
public bool Configurado { get; set; }
|
|
public List<OperacaoModulosMandatoriosModel> ModulosMandatorios { get; set; }
|
|
public List<OperacaoParametrosMandatoriosModel> ParametrosMandatorios { get; set; }
|
|
|
|
public TipoMapaOperacao TipoMapa { get; set; }
|
|
public MapaFeatureCollectionModel Mapa { get; set; }
|
|
public List<string> RuasPercorrer { get; set; }
|
|
public List<double[]> PontosRetorno { get; set; }
|
|
|
|
private OperacaoParametrosDadosModel _dadosLeitura;
|
|
public OperacaoParametrosDadosModel DadosLeitura
|
|
{
|
|
get => _dadosLeitura;
|
|
set
|
|
{
|
|
if (!object.ReferenceEquals(_dadosLeitura, value))
|
|
{
|
|
_dadosLeitura = value;
|
|
OnPropertyChanged(nameof(DadosLeitura));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
protected void OnPropertyChanged(string nome)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nome));
|
|
}
|
|
}
|
|
|
|
public class OperacaoParametrosControleModel : INotifyPropertyChanged
|
|
{
|
|
private bool _movimentoAutomatico;
|
|
public bool MovimentoAutomatico
|
|
{
|
|
get => _movimentoAutomatico;
|
|
set
|
|
{
|
|
if (_movimentoAutomatico != value)
|
|
{
|
|
_movimentoAutomatico = value;
|
|
OnPropertyChanged(nameof(MovimentoAutomatico));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _direcionalAutomatico;
|
|
public bool DirecionalAutomatico
|
|
{
|
|
get => _direcionalAutomatico;
|
|
set
|
|
{
|
|
if (_direcionalAutomatico != value)
|
|
{
|
|
_direcionalAutomatico = value;
|
|
OnPropertyChanged(nameof(DirecionalAutomatico));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _pulverizadorAutomatico;
|
|
public bool PulverizadorAutomatico
|
|
{
|
|
get => _pulverizadorAutomatico;
|
|
set
|
|
{
|
|
if (_pulverizadorAutomatico != value)
|
|
{
|
|
_pulverizadorAutomatico = value;
|
|
OnPropertyChanged(nameof(PulverizadorAutomatico));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _oakParadaPorObstaculo;
|
|
public bool OakParadaPorObstaculo
|
|
{
|
|
get => _oakParadaPorObstaculo;
|
|
set
|
|
{
|
|
if (_oakParadaPorObstaculo != value)
|
|
{
|
|
_oakParadaPorObstaculo = value;
|
|
OnPropertyChanged(nameof(OakParadaPorObstaculo));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _imuParadaPorInclinacao;
|
|
public bool ImuParadaPorInclinacao
|
|
{
|
|
get => _imuParadaPorInclinacao;
|
|
set
|
|
{
|
|
if (_imuParadaPorInclinacao != value)
|
|
{
|
|
_imuParadaPorInclinacao = value;
|
|
OnPropertyChanged(nameof(ImuParadaPorInclinacao));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _imuAuxilioMovimento;
|
|
public bool ImuAuxilioMovimento
|
|
{
|
|
get => _imuAuxilioMovimento;
|
|
set
|
|
{
|
|
if (_imuAuxilioMovimento != value)
|
|
{
|
|
_imuAuxilioMovimento = value;
|
|
OnPropertyChanged(nameof(ImuAuxilioMovimento));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _imuAuxilioDirecional;
|
|
public bool ImuAuxilioDirecional
|
|
{
|
|
get => _imuAuxilioDirecional;
|
|
set
|
|
{
|
|
if (_imuAuxilioDirecional != value)
|
|
{
|
|
_imuAuxilioDirecional = value;
|
|
OnPropertyChanged(nameof(ImuAuxilioDirecional));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _imuDirecionalPreferirArco;
|
|
public bool ImuDirecionalPreferirArco
|
|
{
|
|
get => _imuDirecionalPreferirArco;
|
|
set
|
|
{
|
|
if (_imuDirecionalPreferirArco != value)
|
|
{
|
|
_imuDirecionalPreferirArco = value;
|
|
OnPropertyChanged(nameof(ImuDirecionalPreferirArco));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _frenagemAutomaticaAoParar;
|
|
public bool FrenagemAutomaticaAoParar
|
|
{
|
|
get => _frenagemAutomaticaAoParar;
|
|
set
|
|
{
|
|
if (_frenagemAutomaticaAoParar != value)
|
|
{
|
|
_frenagemAutomaticaAoParar = value;
|
|
OnPropertyChanged(nameof(FrenagemAutomaticaAoParar));
|
|
}
|
|
}
|
|
}
|
|
|
|
private double _anteciparManobraCorredorM;
|
|
public double AnteciparManobraCorredorM
|
|
{
|
|
get => _anteciparManobraCorredorM;
|
|
set
|
|
{
|
|
if (_anteciparManobraCorredorM != value)
|
|
{
|
|
_anteciparManobraCorredorM = value;
|
|
OnPropertyChanged(nameof(AnteciparManobraCorredorM));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _registrarDadosPosProcessamento;
|
|
public bool RegistrarDadosPosProcessamento
|
|
{
|
|
get => _registrarDadosPosProcessamento;
|
|
set
|
|
{
|
|
if (_registrarDadosPosProcessamento != value)
|
|
{
|
|
_registrarDadosPosProcessamento = value;
|
|
OnPropertyChanged(nameof(RegistrarDadosPosProcessamento));
|
|
}
|
|
}
|
|
}
|
|
|
|
private int _movVelocidadeSErvasPercent;
|
|
public int MovVelocidadeSErvasPercent
|
|
{
|
|
get => _movVelocidadeSErvasPercent;
|
|
set
|
|
{
|
|
if (_movVelocidadeSErvasPercent != value)
|
|
{
|
|
_movVelocidadeSErvasPercent = value;
|
|
OnPropertyChanged(nameof(MovVelocidadeSErvasPercent));
|
|
OnPropertyChanged(nameof(MovRpmMax));
|
|
}
|
|
}
|
|
}
|
|
|
|
public int MovRpmMax => System.Convert.ToInt32(VariaveisEquipamento.RPM_Max_Roda * (MovVelocidadeSErvasPercent / 100.0));
|
|
|
|
private int _movVelocidadeCErvasPercent;
|
|
public int MovVelocidadeCErvasPercent
|
|
{
|
|
get => _movVelocidadeCErvasPercent;
|
|
set
|
|
{
|
|
if (_movVelocidadeCErvasPercent != value)
|
|
{
|
|
_movVelocidadeCErvasPercent = value;
|
|
OnPropertyChanged(nameof(MovVelocidadeCErvasPercent));
|
|
OnPropertyChanged(nameof(MovRpmMin));
|
|
}
|
|
}
|
|
}
|
|
|
|
public int MovRpmMin => System.Convert.ToInt32(VariaveisEquipamento.RPM_Max_Roda * (MovVelocidadeCErvasPercent / 100.0));
|
|
|
|
private int _dirAnguloMaximo;
|
|
public int DirAnguloMaximo
|
|
{
|
|
get => _dirAnguloMaximo;
|
|
set
|
|
{
|
|
if (_dirAnguloMaximo != value)
|
|
{
|
|
_dirAnguloMaximo = value;
|
|
OnPropertyChanged(nameof(DirAnguloMaximo));
|
|
}
|
|
}
|
|
}
|
|
|
|
private double _dirVelocidadeMovimento;
|
|
public double DirVelocidadeMovimento
|
|
{
|
|
get => _dirVelocidadeMovimento;
|
|
set
|
|
{
|
|
if (_dirVelocidadeMovimento != value)
|
|
{
|
|
_dirVelocidadeMovimento = value;
|
|
OnPropertyChanged(nameof(DirVelocidadeMovimento));
|
|
}
|
|
}
|
|
}
|
|
|
|
private TiposControladorDirecional _dirTipoMovimento;
|
|
public TiposControladorDirecional DirTipoMovimento
|
|
{
|
|
get => _dirTipoMovimento;
|
|
set
|
|
{
|
|
if (_dirTipoMovimento != value)
|
|
{
|
|
_dirTipoMovimento = value;
|
|
OnPropertyChanged(nameof(DirTipoMovimento));
|
|
}
|
|
}
|
|
}
|
|
|
|
private ModoAgitadorCalda _atuAgitadorModo;
|
|
public ModoAgitadorCalda AtuAgitadorModo
|
|
{
|
|
get => _atuAgitadorModo;
|
|
set
|
|
{
|
|
if (_atuAgitadorModo != value)
|
|
{
|
|
_atuAgitadorModo = value;
|
|
OnPropertyChanged(nameof(AtuAgitadorModo));
|
|
}
|
|
}
|
|
}
|
|
|
|
private ModoControleBomba _atuModoControle;
|
|
public ModoControleBomba AtuModoControle
|
|
{
|
|
get => _atuModoControle;
|
|
set
|
|
{
|
|
if (_atuModoControle != value)
|
|
{
|
|
_atuModoControle = value;
|
|
OnPropertyChanged(nameof(AtuModoControle));
|
|
}
|
|
}
|
|
}
|
|
|
|
private double _atuPressaoLinha;
|
|
public double AtuPressaoLinha
|
|
{
|
|
get => _atuPressaoLinha;
|
|
set
|
|
{
|
|
if (_atuPressaoLinha != value)
|
|
{
|
|
_atuPressaoLinha = value;
|
|
OnPropertyChanged(nameof(AtuPressaoLinha));
|
|
}
|
|
}
|
|
}
|
|
|
|
private int _atuDuracaoAtuacao;
|
|
public int AtuDuracaoAtuacao
|
|
{
|
|
get => _atuDuracaoAtuacao;
|
|
set
|
|
{
|
|
if (_atuDuracaoAtuacao != value)
|
|
{
|
|
_atuDuracaoAtuacao = value;
|
|
OnPropertyChanged(nameof(AtuDuracaoAtuacao));
|
|
}
|
|
}
|
|
}
|
|
|
|
private double _atuPercentualInicioPulverizacao;
|
|
public double AtuPercentualInicioPulverizacao
|
|
{
|
|
get => _atuPercentualInicioPulverizacao;
|
|
set
|
|
{
|
|
if (_atuPercentualInicioPulverizacao != value)
|
|
{
|
|
_atuPercentualInicioPulverizacao = value;
|
|
OnPropertyChanged(nameof(AtuPercentualInicioPulverizacao));
|
|
}
|
|
}
|
|
}
|
|
|
|
private double _atuAlturaAreaPulverizacao;
|
|
public double AtuAlturaAreaPulverizacao
|
|
{
|
|
get => _atuAlturaAreaPulverizacao;
|
|
set
|
|
{
|
|
if (_atuAlturaAreaPulverizacao != value)
|
|
{
|
|
_atuAlturaAreaPulverizacao = value;
|
|
OnPropertyChanged(nameof(AtuAlturaAreaPulverizacao));
|
|
}
|
|
}
|
|
}
|
|
|
|
private double _atuPercentualErvasBicoOn;
|
|
public double AtuPercentualErvasBicoOn
|
|
{
|
|
get => _atuPercentualErvasBicoOn;
|
|
set
|
|
{
|
|
if (_atuPercentualErvasBicoOn != value)
|
|
{
|
|
_atuPercentualErvasBicoOn = value;
|
|
OnPropertyChanged(nameof(AtuPercentualErvasBicoOn));
|
|
}
|
|
}
|
|
}
|
|
|
|
private double _atuPercentualErvasBicoOff;
|
|
public double AtuPercentualErvasBicoOff
|
|
{
|
|
get => _atuPercentualErvasBicoOff;
|
|
set
|
|
{
|
|
if (_atuPercentualErvasBicoOff != value)
|
|
{
|
|
_atuPercentualErvasBicoOff = value;
|
|
OnPropertyChanged(nameof(AtuPercentualErvasBicoOff));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _movAuxilioSonar;
|
|
public bool MovAuxilioSonar
|
|
{
|
|
get => _movAuxilioSonar;
|
|
set
|
|
{
|
|
if (_movAuxilioSonar != value)
|
|
{
|
|
_movAuxilioSonar = value;
|
|
OnPropertyChanged(nameof(MovAuxilioSonar));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _dirAuxilioSonar;
|
|
public bool DirAuxilioSonar
|
|
{
|
|
get => _dirAuxilioSonar;
|
|
set
|
|
{
|
|
if (_dirAuxilioSonar != value)
|
|
{
|
|
_dirAuxilioSonar = value;
|
|
OnPropertyChanged(nameof(DirAuxilioSonar));
|
|
}
|
|
}
|
|
}
|
|
|
|
private double _mpcHorizonte = 4.0;
|
|
public double MpcHorizonte
|
|
{
|
|
get => _mpcHorizonte;
|
|
set
|
|
{
|
|
if (_mpcHorizonte != value)
|
|
{
|
|
_mpcHorizonte = value;
|
|
OnPropertyChanged(nameof(MpcHorizonte));
|
|
}
|
|
}
|
|
}
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
protected void OnPropertyChanged(string nome)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nome));
|
|
}
|
|
}
|
|
|
|
public class OperacaoParametrosDadosModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public StatusModulo StatusRover { get; set; }
|
|
public CanServiceTipo TipoCanAtivo { get; set; }
|
|
|
|
public OperacaoParametrosDadosOperacaoModel Operacao { get; set; }
|
|
public OperacaoParametrosDadosTrajetoriaModel Trajetoria { get; set; }
|
|
public OperacaoParametrosDadosControleModel Controle { get; set; }
|
|
|
|
public List<ManagerWorkerMessageResponseModulosPendentesModel> ModulosSaude { get; set; }
|
|
public List<DispositivoDetalhesModel> DispositivosMapeados { get; set; }
|
|
|
|
public OperacaoSensoriamentoLogImuModel Imu { get; set; }
|
|
public OperacaoParametrosDadosAtuadorModel Atuador { get; set; }
|
|
public OperacaoParametrosDadosSensoriamentoModel Sensoriamento { get; set; }
|
|
public MovimentacaoLogModel Movimentacao { get; set; }
|
|
public DirecionalLogModel Direcional { get; set; }
|
|
|
|
public OperacaoSensoriamentoLogBateriaModel Bateria { get; set; }
|
|
public CoolerControlDataModel Refrigeracao { get; set; }
|
|
public OperacaoParametrosDadosGNSSModel Gnss { get; set; }
|
|
public PerformanceModel PerformanceNcp { get; set; }
|
|
public LivoxModel LivoxLidar { get; set; }
|
|
|
|
public DateTime UltimoEnvioLog { get; set; } = DateTime.MinValue;
|
|
|
|
public List<OperacaoSensoriamentoLogErrosModel> Logs { get; set; }
|
|
public List<CameraWorkerItemModel> Cameras { get; set; }
|
|
public VisualWorkerResumoModel OperadorVisual { get; set; }
|
|
|
|
public void Atualizar()
|
|
{
|
|
DateTime agora = DateTime.Now;
|
|
|
|
Momento = agora;
|
|
|
|
var op = Variaveis.OperacaoEmAndamento;
|
|
var sen = op?.Sensoriamento;
|
|
|
|
var dAtu = op?.DispAtu?.Dados;
|
|
var dSen = op?.DispSen?.Dados;
|
|
var dMvd = op?.DispMvd?.Dados;
|
|
|
|
StatusRover = op?.Status ?? StatusModulo.Desconectado;
|
|
TipoCanAtivo = CanManager.TipoServico;
|
|
|
|
AtualizarOperacao(op);
|
|
AtualizarTrajetoria(sen);
|
|
AtualizarControle(op);
|
|
AtualizarSaude(sen);
|
|
AtualizarImu(sen);
|
|
AtualizarAtuador(sen, dAtu);
|
|
AtualizarSensoriamento(dSen);
|
|
AtualizarMovimentacao(sen);
|
|
AtualizarDirecional(sen);
|
|
AtualizarGnss(sen);
|
|
AtualizarOutrosBlocos(sen);
|
|
AtualizarCameras();
|
|
AtualizarLogs(sen);
|
|
}
|
|
|
|
private void AtualizarOperacao(OperacaoModel op)
|
|
{
|
|
var parametros = op?.Parametros;
|
|
|
|
Operacao = new OperacaoParametrosDadosOperacaoModel
|
|
{
|
|
Iniciada = op?.Sensoriamento?.Operacao?.OperacaoIniciada ?? false,
|
|
Liberada = op?.Sensoriamento?.Operacao?.OperacaoLiberada ?? false,
|
|
Status = op?.Sensoriamento?.Operacao?.StatusOperacaoAtual ?? StatusOperacao.Erro,
|
|
Modo = parametros?.Modo ?? ModoOperacao.NaoDefinido,
|
|
ImpedimentoErro = op?.Sensoriamento?.Operacao?.ErroOperacaoLiberada,
|
|
TempoAguardandoSegs = op?.Sensoriamento?.Operacao?.TempoAguardandoSeg ?? 0,
|
|
TempoDecorridoSegs = op?.Sensoriamento?.Operacao?.TempoDecorridoSeg ?? 0,
|
|
Emergencia = op?.Sensoriamento?.Operacao?.Emergencia ?? false,
|
|
Pausa = op?.Sensoriamento?.Operacao?.Pausa ?? false,
|
|
IniciadoEm = op?.Sensoriamento?.Operacao?.DataInicio ?? DateTime.MinValue,
|
|
FinalizadoEm = op?.Sensoriamento?.Operacao?.DataFim ?? DateTime.MinValue,
|
|
ModulosMandatorios = CloneList(parametros?.ModulosMandatorios),
|
|
ParametrosMandatorios = CloneList(parametros?.ParametrosMandatorios)
|
|
};
|
|
}
|
|
|
|
private void AtualizarTrajetoria(OperacaoSensoriamentoConjuntoModel sen)
|
|
{
|
|
var t = sen?.Trajetoria;
|
|
|
|
if (t == null)
|
|
{
|
|
Trajetoria = new OperacaoParametrosDadosTrajetoriaModel
|
|
{
|
|
AutonomiaCorredor = new OperacaoParametrosDadosTrajetoriaAutonomiaCorredorModel()
|
|
};
|
|
return;
|
|
}
|
|
|
|
var autonomia = t.AutonomiaCooredor;
|
|
var corredorAtual = t.CorredorAtual;
|
|
var pontoAtual = t.PontoAtual;
|
|
var proximoPonto = t.ProximoPonto;
|
|
|
|
Trajetoria = new OperacaoParametrosDadosTrajetoriaModel
|
|
{
|
|
AutonomiaCorredor =
|
|
autonomia != null
|
|
? new OperacaoParametrosDadosTrajetoriaAutonomiaCorredorModel
|
|
{
|
|
BateriaSuficiente = autonomia.BateriaSuficiente,
|
|
DistanciaCorredor_m = TryGetDouble(
|
|
autonomia,
|
|
"DistanciaCorredor_m",
|
|
TryGetDouble(
|
|
autonomia,
|
|
"DistanciaCorredor",
|
|
autonomia.DistanciaSeguraBateria_m
|
|
)
|
|
),
|
|
DistanciaSeguraBateria_m =
|
|
autonomia.DistanciaSeguraBateria_m,
|
|
DistanciaSeguraHerbicida_m = TryGetDouble(
|
|
autonomia,
|
|
"DistanciaSeguraHerbicida_m",
|
|
TryGetDouble(
|
|
autonomia,
|
|
"DistanciaSeguraHerbicida",
|
|
autonomia.DistanciaSeguraBateria_m
|
|
)
|
|
),
|
|
HerbicidaSuficiente =
|
|
autonomia.HerbicidaSuficiente,
|
|
Liberado = autonomia.Liberado,
|
|
Motivo = autonomia.Motivo,
|
|
Motivos = CloneListString(autonomia.Motivos),
|
|
Status = autonomia.Status
|
|
}
|
|
: new OperacaoParametrosDadosTrajetoriaAutonomiaCorredorModel(),
|
|
|
|
AnguloCaminho = t.AnguloCaminho,
|
|
|
|
CorredorAtualDentro =
|
|
corredorAtual?.Dentro ?? false,
|
|
CorredorAtualDistanciaPercorrida =
|
|
corredorAtual?.DistanciaPercorridaCorredor ?? 0,
|
|
CorredorAtualDistanciaTotal =
|
|
corredorAtual?.DistanciaTotal ?? 0,
|
|
CorredorAtualIdx =
|
|
corredorAtual?.Idx ?? 0,
|
|
|
|
DistanciaDireita = t.DistanciaDireita,
|
|
DistanciaEsquerda = t.DistanciaEsquerda,
|
|
DistanciaPercorrida = t.DistanciaPercorrida,
|
|
DistanciaTotal = t.DistanciaTotal,
|
|
NaMargemDoCorredor = t.NaMargemDoCorredor,
|
|
PercentualOperacao = t.PercentualOperacao,
|
|
PercentualRuaAtual = t.PercentualRuaAtual,
|
|
|
|
PontoAtualDistanciaAtual =
|
|
pontoAtual?.DistanciaAtual ?? 0,
|
|
PontoAtualIdx =
|
|
pontoAtual?.idxPonto ?? 0,
|
|
PontoAtualIdxCorredor =
|
|
pontoAtual?.idxCorredor ?? 0,
|
|
|
|
ProximoPontoAproximando =
|
|
proximoPonto?.Aproximando ?? false,
|
|
ProximoPontoDistanciaAtual =
|
|
proximoPonto?.DistanciaAtual ?? 0,
|
|
ProximoPontoIdx =
|
|
proximoPonto?.idxPonto ?? 0,
|
|
|
|
QtdPontos = t.QtdPontos,
|
|
StatusCarro = t.StatusCarro,
|
|
TempoEstimadoOperacao = t.TempoEstimadoOperacao
|
|
};
|
|
}
|
|
|
|
private void AtualizarControle(OperacaoModel op)
|
|
{
|
|
var c = op?.Controle?.Clone();
|
|
|
|
Controle = c != null
|
|
? new OperacaoParametrosDadosControleModel
|
|
{
|
|
Angulo = c.Angulo,
|
|
AlturaBarra = c.AlturaBarra,
|
|
PercentualVelocidadeSPKmh =
|
|
c.PercentualVelocidadeSPKmh,
|
|
TipoMovimento = c.TipoMovimento,
|
|
SimulacaoMPC = CloneList(c.SimulacaoMPC),
|
|
Motivos = CloneListString(c.Motivos)
|
|
}
|
|
: new OperacaoParametrosDadosControleModel();
|
|
}
|
|
|
|
private void AtualizarSaude(OperacaoSensoriamentoConjuntoModel sen)
|
|
{
|
|
ModulosSaude = CloneList(sen?.OperadorSaude?.ModulosSaude);
|
|
DispositivosMapeados = CloneList(sen?.Operacao?.DispositivosMapeados);
|
|
}
|
|
|
|
private void AtualizarImu(OperacaoSensoriamentoConjuntoModel sen)
|
|
{
|
|
Imu = new OperacaoSensoriamentoLogImuModel
|
|
{
|
|
Iniciado = sen?.IMU?.Iniciado ?? false,
|
|
InclinacaoFrontal = sen?.IMU?.PitchSeguro ?? 0,
|
|
InclinacaoLateral = sen?.IMU?.RollSeguro ?? 0,
|
|
Rotacao = sen?.IMU?.YawSeguro ?? 0
|
|
};
|
|
}
|
|
|
|
private void AtualizarAtuador(OperacaoSensoriamentoConjuntoModel sen, AtuadorModel dAtu)
|
|
{
|
|
var atu = sen?.Atuador;
|
|
|
|
var bicosPulverizadores = ToDynamicList(dAtu == null ? null : dAtu.BicosPulverizadores);
|
|
var bombasPressurizadoras = ToDynamicList(dAtu == null ? null : dAtu.BombasPressurizadoras);
|
|
var sensoresAtuador = ToDynamicList(dAtu == null ? null : dAtu.Sensores);
|
|
|
|
Atuador = new OperacaoParametrosDadosAtuadorModel
|
|
{
|
|
Iniciado = dAtu?.Conectado ?? false,
|
|
Latencia = dAtu?.DadosLeitura?.LatenciaLoop ?? 0,
|
|
|
|
AnguloBarraDireita = atu?.AnguloBarraDireita ?? 0,
|
|
AnguloBarraEsquerda = atu?.AnguloBarraEsquerda ?? 0,
|
|
CapacidadeReservatorio = atu?.CapacidadeReservatorio ?? 0,
|
|
ErvasNoRadar = atu?.ErvasNoRadar ?? false,
|
|
DistanciaEstimadaRestanteMetros = atu?.DistanciaEstimadaRestanteMetros ?? 0,
|
|
HerbicidaConsumidoMl = atu?.HerbicidaConsumido ?? 0,
|
|
HerbicidaPorAtuacaoMl = atu?.HerbicidaPorErva ?? 0,
|
|
LPorMetro = atu?.LPorMetro ?? 0,
|
|
LPorMinuto = atu?.LPorMinuto ?? 0,
|
|
MassaReservatorioKg = atu?.MassaReservatorio ?? 0,
|
|
VolumeReservatorioL = atu?.VolumeReservatorio ?? 0,
|
|
VolumeVazaoMl = atu?.VolumeVazaoML ?? 0,
|
|
VazaoMediaMLs = atu?.VazaoFluxoMLpSMedia ?? 0,
|
|
VazaoInstantaneaMLs = atu?.VazaoFluxoMLpSInstantaneaCorrigida ?? 0,
|
|
TempoEstimadoRestanteMinutos = atu?.TempoEstimadoRestanteMinutos ?? 0,
|
|
QtdCamerasSolo = atu?.QtdCamerasSolo ?? 0,
|
|
PercentualErvasNoRadar = atu?.PercentualErvasNoRadar ?? 0,
|
|
PercentualErvasTerreno = atu?.PercentualErvasTerreno ?? 0,
|
|
PercentualReservatorio = atu?.PercentualReservatorio ?? 0,
|
|
PressaoLinhaPsi = atu?.PressaoLinha ?? 0,
|
|
|
|
Bicos =
|
|
dAtu?.BicosPulverizadores != null
|
|
? ((IEnumerable<dynamic>)dAtu.BicosPulverizadores)
|
|
.Select(x => new OperacaoParametrosDadosBicoModel
|
|
{
|
|
ID = x.ID,
|
|
ID_Num = x.ID_Num,
|
|
Inicializado = x.Inicializado,
|
|
Posicao = x.Posicao,
|
|
AnguloAbertura = x.AnguloAbertura,
|
|
ComandoAngulo = (int)x.AnguloControle,
|
|
LeituraAngulo = (int)x._AnguloBicoLeitura,
|
|
|
|
/*
|
|
* Mantém a decisão correta que já fizemos:
|
|
* comando é mais confiável que leitura CAN de 1 s
|
|
* para métrica instantânea de atuação.
|
|
*/
|
|
ComandoEstado = x.ComandoAtuar,
|
|
LeituraEstado = x._EstadoLeitura == Estado.Ligado,
|
|
|
|
VazaoMediaMLs = x.VazaoMediaMLs,
|
|
VazaoInstantaneaMLs = x.VazaoInstantaneaMLs,
|
|
VolumeVazadoML = x.VolumeVazadoML,
|
|
QtdAtuacoes = x.Atuacoes,
|
|
TempoAtuado = x.TempoAtuado,
|
|
TrechosPulverizando =
|
|
CloneTrechos(x.TrechosAtuado),
|
|
UltimoComandoRespondido = x.UltimaLeitura
|
|
})
|
|
.ToList()
|
|
: new List<OperacaoParametrosDadosBicoModel>(),
|
|
|
|
Bombas =
|
|
dAtu?.BombasPressurizadoras != null
|
|
? ((IEnumerable<dynamic>)dAtu.BombasPressurizadoras)
|
|
.Select(x => new OperacaoParametrosDadosBombaModel
|
|
{
|
|
ID = x.ID,
|
|
ID_Num = x.ID_Num,
|
|
Sensor_ID_Num = x.Sensor_ID_Num,
|
|
Inicializado = x.Inicializado,
|
|
ComandoEstado = x.ComandoAtuar,
|
|
LeituraEstado = x._EstadoLeitura == Estado.Ligado,
|
|
ComandoPressao = x.PressaoSP,
|
|
LeituraPressao = x._PressaoAtual,
|
|
ComandoPotencia = x.PotenciaSP,
|
|
LeituraPotencia = x._Potencia,
|
|
TempoAtuado = dAtu?.TempoAtuado ?? 0,
|
|
UltimoComandoRespondido = x.UltimaLeitura
|
|
})
|
|
.ToList()
|
|
: new List<OperacaoParametrosDadosBombaModel>(),
|
|
|
|
Sensores =
|
|
dAtu?.Sensores != null
|
|
? ((IEnumerable<dynamic>)dAtu.Sensores)
|
|
.Select(x => new OperacaoParametrosDadosSensorModel
|
|
{
|
|
Componente = x.Componente,
|
|
ID = x.ID,
|
|
ID_Num = x.ID_Num,
|
|
Inicializado = x.Inicializado,
|
|
Valores = ExtrairValoresSensor(x.ValoresLeituras),
|
|
UltimoComandoRespondido = x.UltimaLeitura
|
|
})
|
|
.ToList()
|
|
: new List<OperacaoParametrosDadosSensorModel>(),
|
|
|
|
UltimoComandoRespondido =
|
|
dAtu?.DadosLeitura?.UltimoComandoRespondido
|
|
?? DateTime.MinValue
|
|
};
|
|
}
|
|
|
|
private void AtualizarSensoriamento(SensoriamentoModel dSen)
|
|
{
|
|
Sensoriamento = new OperacaoParametrosDadosSensoriamentoModel
|
|
{
|
|
Iniciado = dSen?.Conectado ?? false,
|
|
Latencia = dSen?.DadosLeitura?.LatenciaLoop ?? 0,
|
|
|
|
Sensores =
|
|
dSen?.Sensores != null
|
|
? ((IEnumerable<dynamic>)dSen.Sensores)
|
|
.Select(x => new OperacaoParametrosDadosSensorModel
|
|
{
|
|
Componente = x.Componente,
|
|
ID = x.ID,
|
|
ID_Num = x.ID_Num,
|
|
Inicializado = x.Inicializado,
|
|
Valores = ExtrairValoresSensor(x.ValoresLeituras),
|
|
UltimoComandoRespondido = x.UltimaLeitura
|
|
})
|
|
.ToList()
|
|
: new List<OperacaoParametrosDadosSensorModel>(),
|
|
|
|
Servos =
|
|
dSen?.Servos != null
|
|
? ((IEnumerable<dynamic>)dSen.Servos)
|
|
.Select(x => new OperacaoParametrosDadosServoModel
|
|
{
|
|
ID = x.ID,
|
|
ID_Num = x.ID_Num,
|
|
Inicializado = x.Inicializado,
|
|
Incremental = x.Incremental,
|
|
ComandoAngulo = x._AnguloControle,
|
|
LeituraAngulo = x._AnguloLeiutra,
|
|
UltimoComandoRespondido = x.UltimaLeitura
|
|
})
|
|
.ToList()
|
|
: new List<OperacaoParametrosDadosServoModel>(),
|
|
|
|
Reles =
|
|
dSen?.Reles != null
|
|
? ((IEnumerable<dynamic>)dSen.Reles)
|
|
.Select(x => new OperacaoParametrosDadosReleModel
|
|
{
|
|
ID = x.ID,
|
|
ID_Num = x.ID_Num,
|
|
Inicializado = x.Inicializado,
|
|
ComandoEstado =
|
|
x.StatusControle == Estado.Ligado,
|
|
LeituraEstado =
|
|
x._EstadoLeitura == Estado.Ligado,
|
|
UltimoComandoRespondido = x.UltimaLeitura
|
|
})
|
|
.ToList()
|
|
: new List<OperacaoParametrosDadosReleModel>(),
|
|
|
|
Sinaleiros =
|
|
dSen?.Sinaleiros != null
|
|
? ((IEnumerable<dynamic>)dSen.Sinaleiros)
|
|
.Select(x => new OperacaoParametrosDadosSinaleiroModel
|
|
{
|
|
ID = x.ID,
|
|
ID_Num = x.ID_Num,
|
|
Inicializado = x.Inicializado,
|
|
Comportamento = x.Comportamento,
|
|
StatusLedId = x._StatusLedId,
|
|
StatusLed = x._StatusLed,
|
|
UltimoComandoRespondido = x.UltimaLeitura
|
|
})
|
|
.ToList()
|
|
: new List<OperacaoParametrosDadosSinaleiroModel>(),
|
|
|
|
UltimoComandoRespondido =
|
|
dSen?.DadosLeitura?.UltimoComandoRespondido
|
|
?? DateTime.MinValue
|
|
};
|
|
}
|
|
|
|
private void AtualizarMovimentacao(OperacaoSensoriamentoConjuntoModel sen)
|
|
{
|
|
Movimentacao = sen?.Movimentacao?.Clone();
|
|
}
|
|
|
|
private void AtualizarDirecional(OperacaoSensoriamentoConjuntoModel sen)
|
|
{
|
|
Direcional = sen?.Direcional?.Clone();
|
|
}
|
|
|
|
private void AtualizarGnss(OperacaoSensoriamentoConjuntoModel sen)
|
|
{
|
|
var gps = sen?.Gps;
|
|
|
|
Gnss = new OperacaoParametrosDadosGNSSModel
|
|
{
|
|
Iniciado = gps?.Inicializado ?? false,
|
|
Altitude = gps?.Altitude ?? 0,
|
|
Distancia = gps?.Distancia ?? 0,
|
|
IdadeCorrecao = gps?.IdadeCorrecao ?? -1,
|
|
Latitude = gps?.Latitude ?? 0,
|
|
Longitude = gps?.Longitude ?? 0,
|
|
LeverArmFrontal = gps?.LeverArmFrontal ?? 0,
|
|
LeverArmLateral = gps?.LeverArmLateral ?? 0,
|
|
NtripAtivado = gps?.Ntrip_ativado ?? false,
|
|
NumeroSatelites = gps?.NumeroSatelites ?? 0,
|
|
OrientacaoMovimento = gps?.OrientacaoMovimento ?? 0,
|
|
OrientacaoReal = gps?.OrientacaoReal ?? 0,
|
|
PrecisaoCm = gps?.PrecisaoCm ?? 0,
|
|
PrecisaoHorizontal = gps?.PrecisaoHorizontal ?? 0,
|
|
QualidadeFix = gps?.QualidadeFix ?? TiposCorrecaoGPS.SemCorrecao,
|
|
Velocidade = gps?.Velocidade ?? 0,
|
|
UltimoComandoRespondido = gps?.UltimoComandoRespondido ?? DateTime.MinValue
|
|
};
|
|
}
|
|
|
|
private void AtualizarOutrosBlocos(OperacaoSensoriamentoConjuntoModel sen)
|
|
{
|
|
Bateria = sen?.Bateria?.Clone();
|
|
Refrigeracao = sen?.CoolerControl?.Clone();
|
|
PerformanceNcp = sen?.DadosPerformance?.Clone();
|
|
LivoxLidar = sen?.LivoxLidar?.Clone();
|
|
OperadorVisual = sen?.OperadorVisual?.Resumo?.Clone();
|
|
}
|
|
|
|
private void AtualizarCameras()
|
|
{
|
|
Cameras = CameraWorkerService.ListaCameras != null
|
|
? new List<CameraWorkerItemModel>(CameraWorkerService.ListaCameras)
|
|
: new List<CameraWorkerItemModel>();
|
|
}
|
|
|
|
private void AtualizarLogs(OperacaoSensoriamentoConjuntoModel sen)
|
|
{
|
|
DateTime corte = UltimoEnvioLog;
|
|
|
|
var logs = sen?.Logs;
|
|
|
|
Logs = logs != null
|
|
? logs
|
|
.Where(x => x != null && x.Momento > corte)
|
|
.ToList()
|
|
: new List<OperacaoSensoriamentoLogErrosModel>();
|
|
}
|
|
|
|
public OperacaoParametrosDadosModel Clone()
|
|
{
|
|
return new OperacaoParametrosDadosModel
|
|
{
|
|
Momento = Momento,
|
|
StatusRover = StatusRover,
|
|
TipoCanAtivo = TipoCanAtivo,
|
|
|
|
Operacao = CloneOperacao(Operacao),
|
|
Trajetoria = Trajetoria?.Clone(),
|
|
Controle = Controle?.Clone(),
|
|
|
|
ModulosSaude = CloneList(ModulosSaude),
|
|
DispositivosMapeados = CloneList(DispositivosMapeados),
|
|
|
|
Imu = Imu?.Clone(),
|
|
Atuador = CloneAtuador(Atuador),
|
|
Sensoriamento = CloneSensoriamento(Sensoriamento),
|
|
Movimentacao = Movimentacao?.Clone(),
|
|
Direcional = Direcional?.Clone(),
|
|
|
|
Bateria = Bateria?.Clone(),
|
|
Refrigeracao = Refrigeracao?.Clone(),
|
|
Gnss = CloneGnss(Gnss),
|
|
PerformanceNcp = PerformanceNcp?.Clone(),
|
|
LivoxLidar = LivoxLidar?.Clone(),
|
|
|
|
Logs = CloneList(Logs),
|
|
Cameras = Cameras != null
|
|
? new List<CameraWorkerItemModel>(Cameras)
|
|
: new List<CameraWorkerItemModel>(),
|
|
|
|
OperadorVisual = OperadorVisual?.Clone(),
|
|
UltimoEnvioLog = UltimoEnvioLog
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosOperacaoModel CloneOperacao(OperacaoParametrosDadosOperacaoModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosOperacaoModel
|
|
{
|
|
Modo = src.Modo,
|
|
Status = src.Status,
|
|
ImpedimentoErro = src.ImpedimentoErro,
|
|
Liberada = src.Liberada,
|
|
Iniciada = src.Iniciada,
|
|
Emergencia = src.Emergencia,
|
|
Pausa = src.Pausa,
|
|
IniciadoEm = src.IniciadoEm,
|
|
FinalizadoEm = src.FinalizadoEm,
|
|
TempoAguardandoSegs = src.TempoAguardandoSegs,
|
|
TempoDecorridoSegs = src.TempoDecorridoSegs,
|
|
ModulosMandatorios = CloneList(src.ModulosMandatorios),
|
|
ParametrosMandatorios = CloneList(src.ParametrosMandatorios)
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosAtuadorModel CloneAtuador(OperacaoParametrosDadosAtuadorModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosAtuadorModel
|
|
{
|
|
Iniciado = src.Iniciado,
|
|
Latencia = src.Latencia,
|
|
CapacidadeReservatorio = src.CapacidadeReservatorio,
|
|
QtdCamerasSolo = src.QtdCamerasSolo,
|
|
ErvasNoRadar = src.ErvasNoRadar,
|
|
PercentualErvasNoRadar = src.PercentualErvasNoRadar,
|
|
PercentualErvasTerreno = src.PercentualErvasTerreno,
|
|
HerbicidaConsumidoMl = src.HerbicidaConsumidoMl,
|
|
HerbicidaPorAtuacaoMl = src.HerbicidaPorAtuacaoMl,
|
|
MassaReservatorioKg = src.MassaReservatorioKg,
|
|
VolumeReservatorioL = src.VolumeReservatorioL,
|
|
PercentualReservatorio = src.PercentualReservatorio,
|
|
PressaoLinhaPsi = src.PressaoLinhaPsi,
|
|
VazaoInstantaneaMLs = src.VazaoInstantaneaMLs,
|
|
VazaoMediaMLs = src.VazaoMediaMLs,
|
|
VolumeVazaoMl = src.VolumeVazaoMl,
|
|
LPorMetro = src.LPorMetro,
|
|
LPorMinuto = src.LPorMinuto,
|
|
TempoEstimadoRestanteMinutos =
|
|
src.TempoEstimadoRestanteMinutos,
|
|
DistanciaEstimadaRestanteMetros =
|
|
src.DistanciaEstimadaRestanteMetros,
|
|
AnguloBarraEsquerda = src.AnguloBarraEsquerda,
|
|
AnguloBarraDireita = src.AnguloBarraDireita,
|
|
Bicos = src.Bicos?.Select(CloneBico).ToList()
|
|
?? new List<OperacaoParametrosDadosBicoModel>(),
|
|
Bombas = src.Bombas?.Select(CloneBomba).ToList()
|
|
?? new List<OperacaoParametrosDadosBombaModel>(),
|
|
Sensores = src.Sensores?.Select(CloneSensor).ToList()
|
|
?? new List<OperacaoParametrosDadosSensorModel>(),
|
|
UltimoComandoRespondido = src.UltimoComandoRespondido
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosBicoModel CloneBico(OperacaoParametrosDadosBicoModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosBicoModel
|
|
{
|
|
ID = src.ID,
|
|
ID_Num = src.ID_Num,
|
|
Inicializado = src.Inicializado,
|
|
Posicao = src.Posicao,
|
|
ComandoEstado = src.ComandoEstado,
|
|
LeituraEstado = src.LeituraEstado,
|
|
ComandoAngulo = src.ComandoAngulo,
|
|
LeituraAngulo = src.LeituraAngulo,
|
|
QtdAtuacoes = src.QtdAtuacoes,
|
|
TempoAtuado = src.TempoAtuado,
|
|
VazaoMediaMLs = src.VazaoMediaMLs,
|
|
VazaoInstantaneaMLs = src.VazaoInstantaneaMLs,
|
|
VolumeVazadoML = src.VolumeVazadoML,
|
|
AnguloAbertura = src.AnguloAbertura,
|
|
TrechosPulverizando = CloneTrechos(src.TrechosPulverizando),
|
|
UltimoComandoRespondido = src.UltimoComandoRespondido
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosBombaModel CloneBomba(OperacaoParametrosDadosBombaModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosBombaModel
|
|
{
|
|
ID = src.ID,
|
|
ID_Num = src.ID_Num,
|
|
Sensor_ID_Num = src.Sensor_ID_Num,
|
|
Inicializado = src.Inicializado,
|
|
ComandoEstado = src.ComandoEstado,
|
|
LeituraEstado = src.LeituraEstado,
|
|
ComandoPressao = src.ComandoPressao,
|
|
LeituraPressao = src.LeituraPressao,
|
|
TempoAtuado = src.TempoAtuado,
|
|
ComandoPotencia = src.ComandoPotencia,
|
|
LeituraPotencia = src.LeituraPotencia,
|
|
UltimoComandoRespondido = src.UltimoComandoRespondido
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosSensoriamentoModel CloneSensoriamento(OperacaoParametrosDadosSensoriamentoModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosSensoriamentoModel
|
|
{
|
|
Iniciado = src.Iniciado,
|
|
Latencia = src.Latencia,
|
|
Sinaleiros = src.Sinaleiros?.Select(CloneSinaleiro).ToList()
|
|
?? new List<OperacaoParametrosDadosSinaleiroModel>(),
|
|
Sensores = src.Sensores?.Select(CloneSensor).ToList()
|
|
?? new List<OperacaoParametrosDadosSensorModel>(),
|
|
Servos = src.Servos?.Select(CloneServo).ToList()
|
|
?? new List<OperacaoParametrosDadosServoModel>(),
|
|
Reles = src.Reles?.Select(CloneRele).ToList()
|
|
?? new List<OperacaoParametrosDadosReleModel>(),
|
|
UltimoComandoRespondido = src.UltimoComandoRespondido
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosSensorModel CloneSensor(OperacaoParametrosDadosSensorModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosSensorModel
|
|
{
|
|
Componente = src.Componente,
|
|
ID = src.ID,
|
|
ID_Num = src.ID_Num,
|
|
Inicializado = src.Inicializado,
|
|
Valores = src.Valores != null
|
|
? new List<dynamic>(src.Valores)
|
|
: new List<dynamic>(),
|
|
UltimoComandoRespondido = src.UltimoComandoRespondido
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosServoModel CloneServo(OperacaoParametrosDadosServoModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosServoModel
|
|
{
|
|
ID = src.ID,
|
|
ID_Num = src.ID_Num,
|
|
Inicializado = src.Inicializado,
|
|
Incremental = src.Incremental,
|
|
ComandoAngulo = src.ComandoAngulo,
|
|
LeituraAngulo = src.LeituraAngulo,
|
|
UltimoComandoRespondido = src.UltimoComandoRespondido
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosReleModel CloneRele(OperacaoParametrosDadosReleModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosReleModel
|
|
{
|
|
ID = src.ID,
|
|
ID_Num = src.ID_Num,
|
|
Inicializado = src.Inicializado,
|
|
ComandoEstado = src.ComandoEstado,
|
|
LeituraEstado = src.LeituraEstado,
|
|
UltimoComandoRespondido = src.UltimoComandoRespondido
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosSinaleiroModel CloneSinaleiro(OperacaoParametrosDadosSinaleiroModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosSinaleiroModel
|
|
{
|
|
ID = src.ID,
|
|
ID_Num = src.ID_Num,
|
|
Inicializado = src.Inicializado,
|
|
Comportamento = src.Comportamento,
|
|
StatusLedId = src.StatusLedId,
|
|
StatusLed = src.StatusLed,
|
|
UltimoComandoRespondido = src.UltimoComandoRespondido
|
|
};
|
|
}
|
|
|
|
private static OperacaoParametrosDadosGNSSModel CloneGnss(OperacaoParametrosDadosGNSSModel src)
|
|
{
|
|
if (src == null)
|
|
return null;
|
|
|
|
return new OperacaoParametrosDadosGNSSModel
|
|
{
|
|
Iniciado = src.Iniciado,
|
|
Latitude = src.Latitude,
|
|
Longitude = src.Longitude,
|
|
Altitude = src.Altitude,
|
|
Velocidade = src.Velocidade,
|
|
Distancia = src.Distancia,
|
|
OrientacaoMovimento = src.OrientacaoMovimento,
|
|
OrientacaoReal = src.OrientacaoReal,
|
|
NumeroSatelites = src.NumeroSatelites,
|
|
PrecisaoHorizontal = src.PrecisaoHorizontal,
|
|
PrecisaoCm = src.PrecisaoCm,
|
|
QualidadeFix = src.QualidadeFix,
|
|
NtripAtivado = src.NtripAtivado,
|
|
IdadeCorrecao = src.IdadeCorrecao,
|
|
LeverArmLateral = src.LeverArmLateral,
|
|
LeverArmFrontal = src.LeverArmFrontal,
|
|
UltimoComandoRespondido = src.UltimoComandoRespondido
|
|
};
|
|
}
|
|
|
|
private static List<T> CloneList<T>(IEnumerable<T> src)
|
|
{
|
|
return src != null
|
|
? new List<T>(src)
|
|
: new List<T>();
|
|
}
|
|
|
|
private static List<string> CloneListString(IEnumerable<string> src)
|
|
{
|
|
return src != null
|
|
? src.Where(x => x != null).ToList()
|
|
: new List<string>();
|
|
}
|
|
|
|
private static List<dynamic> ToDynamicList(object src)
|
|
{
|
|
var result = new List<dynamic>();
|
|
|
|
if (src == null)
|
|
return result;
|
|
|
|
var enumerable = src as System.Collections.IEnumerable;
|
|
|
|
if (enumerable == null)
|
|
return result;
|
|
|
|
foreach (var item in enumerable)
|
|
result.Add(item);
|
|
|
|
return result;
|
|
}
|
|
|
|
private static List<dynamic> ExtrairValoresSensor(dynamic valoresLeituras)
|
|
{
|
|
var result = new List<dynamic>();
|
|
|
|
if (valoresLeituras == null)
|
|
return result;
|
|
|
|
foreach (var item in valoresLeituras)
|
|
{
|
|
try
|
|
{
|
|
if (item.funcao == FuncoesPinout.Iniciado)
|
|
continue;
|
|
|
|
result.Add(item.atual?.valor);
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static List<List<PontoGeo>> CloneTrechos(dynamic trechos)
|
|
{
|
|
var result = new List<List<PontoGeo>>();
|
|
|
|
if (trechos == null)
|
|
return result;
|
|
|
|
foreach (var trecho in trechos)
|
|
{
|
|
if (trecho == null)
|
|
{
|
|
result.Add(new List<PontoGeo>());
|
|
continue;
|
|
}
|
|
|
|
var novoTrecho = new List<PontoGeo>();
|
|
|
|
foreach (var ponto in trecho)
|
|
{
|
|
/*
|
|
* Sem assumir que PontoGeo tem Clone().
|
|
* Copia a lista interna para evitar mutação estrutural.
|
|
* Se PontoGeo for mutável, o próximo passo é adicionar
|
|
* Clone() nele também.
|
|
*/
|
|
novoTrecho.Add(ponto);
|
|
}
|
|
|
|
result.Add(novoTrecho);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static double TryGetDouble(object obj, string property, double fallback)
|
|
{
|
|
if (obj == null ||
|
|
string.IsNullOrWhiteSpace(property))
|
|
{
|
|
return fallback;
|
|
}
|
|
|
|
try
|
|
{
|
|
var prop = obj.GetType().GetProperty(property);
|
|
|
|
if (prop == null)
|
|
return fallback;
|
|
|
|
object value = prop.GetValue(obj, null);
|
|
|
|
if (value == null)
|
|
return fallback;
|
|
|
|
return Convert.ToDouble(value);
|
|
}
|
|
catch
|
|
{
|
|
return fallback;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class OperacaoParametrosDadosOperacaoModel
|
|
{
|
|
public ModoOperacao Modo { get; set; }
|
|
public StatusOperacao Status { get; set; }
|
|
public string ImpedimentoErro { get; set; }
|
|
public bool Liberada { get; set; }
|
|
public bool Iniciada { get; set; }
|
|
public bool Emergencia { get; set; }
|
|
public bool Pausa { get; set; }
|
|
public DateTime IniciadoEm { get; set; }
|
|
public DateTime FinalizadoEm { get; set; }
|
|
public double TempoAguardandoSegs { get; set; }
|
|
public double TempoDecorridoSegs { get; set; }
|
|
public List<OperacaoModulosMandatoriosModel> ModulosMandatorios { get; set; }
|
|
public List<OperacaoParametrosMandatoriosModel> ParametrosMandatorios { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosDadosTrajetoriaModel
|
|
{
|
|
public StatusCarroMapa StatusCarro { get; set; }
|
|
public int QtdPontos { get; set; }
|
|
public double AnguloCaminho { get; set; }
|
|
public bool NaMargemDoCorredor { get; set; }
|
|
public OperacaoParametrosDadosTrajetoriaAutonomiaCorredorModel AutonomiaCorredor { get; set; }
|
|
public int ProximoPontoIdx { get; set; }
|
|
public bool ProximoPontoAproximando { get; set; }
|
|
public double ProximoPontoDistanciaAtual { get; set; }
|
|
public int PontoAtualIdx { get; set; }
|
|
public int PontoAtualIdxCorredor { get; set; }
|
|
public double PontoAtualDistanciaAtual { get; set; }
|
|
public double DistanciaEsquerda { get; set; }
|
|
public double DistanciaDireita { get; set; }
|
|
public double PercentualRuaAtual { get; set; }
|
|
public double PercentualOperacao { get; set; }
|
|
public double DistanciaPercorrida { get; set; }
|
|
public double DistanciaTotal { get; set; }
|
|
public string TempoEstimadoOperacao { get; set; }
|
|
public bool CorredorAtualDentro { get; set; }
|
|
public int CorredorAtualIdx { get; set; }
|
|
public double CorredorAtualDistanciaTotal { get; set; }
|
|
public double CorredorAtualDistanciaPercorrida { get; set; }
|
|
|
|
public OperacaoParametrosDadosTrajetoriaModel Clone()
|
|
{
|
|
return new OperacaoParametrosDadosTrajetoriaModel
|
|
{
|
|
TempoEstimadoOperacao = TempoEstimadoOperacao,
|
|
StatusCarro = StatusCarro,
|
|
QtdPontos = QtdPontos,
|
|
ProximoPontoIdx = ProximoPontoIdx,
|
|
ProximoPontoDistanciaAtual = ProximoPontoDistanciaAtual,
|
|
AnguloCaminho = AnguloCaminho,
|
|
AutonomiaCorredor =
|
|
AutonomiaCorredor == null
|
|
? null
|
|
: new OperacaoParametrosDadosTrajetoriaAutonomiaCorredorModel
|
|
{
|
|
Status = AutonomiaCorredor.Status,
|
|
DistanciaCorredor_m =
|
|
AutonomiaCorredor.DistanciaCorredor_m,
|
|
DistanciaSeguraBateria_m =
|
|
AutonomiaCorredor.DistanciaSeguraBateria_m,
|
|
DistanciaSeguraHerbicida_m =
|
|
AutonomiaCorredor.DistanciaSeguraHerbicida_m,
|
|
BateriaSuficiente =
|
|
AutonomiaCorredor.BateriaSuficiente,
|
|
HerbicidaSuficiente =
|
|
AutonomiaCorredor.HerbicidaSuficiente,
|
|
Liberado = AutonomiaCorredor.Liberado,
|
|
Motivo = AutonomiaCorredor.Motivo,
|
|
Motivos = AutonomiaCorredor.Motivos != null
|
|
? new List<string>(AutonomiaCorredor.Motivos)
|
|
: new List<string>()
|
|
},
|
|
CorredorAtualDentro = CorredorAtualDentro,
|
|
CorredorAtualDistanciaPercorrida =
|
|
CorredorAtualDistanciaPercorrida,
|
|
CorredorAtualDistanciaTotal =
|
|
CorredorAtualDistanciaTotal,
|
|
CorredorAtualIdx = CorredorAtualIdx,
|
|
DistanciaDireita = DistanciaDireita,
|
|
DistanciaEsquerda = DistanciaEsquerda,
|
|
DistanciaPercorrida = DistanciaPercorrida,
|
|
DistanciaTotal = DistanciaTotal,
|
|
NaMargemDoCorredor = NaMargemDoCorredor,
|
|
PercentualOperacao = PercentualOperacao,
|
|
PercentualRuaAtual = PercentualRuaAtual,
|
|
PontoAtualDistanciaAtual = PontoAtualDistanciaAtual,
|
|
PontoAtualIdx = PontoAtualIdx,
|
|
PontoAtualIdxCorredor = PontoAtualIdxCorredor,
|
|
ProximoPontoAproximando = ProximoPontoAproximando
|
|
};
|
|
}
|
|
}
|
|
|
|
public class OperacaoParametrosDadosTrajetoriaAutonomiaCorredorModel
|
|
{
|
|
public AutonomiaCorredorStatus Status { get; set; }
|
|
public double DistanciaCorredor_m { get; set; }
|
|
public double DistanciaSeguraBateria_m { get; set; }
|
|
public double DistanciaSeguraHerbicida_m { get; set; }
|
|
public bool BateriaSuficiente { get; set; }
|
|
public bool HerbicidaSuficiente { get; set; }
|
|
public bool Liberado { get; set; }
|
|
public string Motivo { get; set; }
|
|
public List<string> Motivos { get; set; }
|
|
|
|
}
|
|
|
|
public class OperacaoParametrosDadosControleModel
|
|
{
|
|
public double AlturaBarra { get; set; }
|
|
public double Angulo { get; set; }
|
|
public TipoMovimentoDirecional TipoMovimento { get; set; }
|
|
public double PercentualVelocidadeSPKmh { get; set; }
|
|
public List<MPCSimulacaoModel> SimulacaoMPC { get; set; } = new List<MPCSimulacaoModel>();
|
|
public List<string> Motivos { get; set; } = new List<string>();
|
|
|
|
public OperacaoParametrosDadosControleModel Clone()
|
|
{
|
|
return new OperacaoParametrosDadosControleModel
|
|
{
|
|
AlturaBarra = AlturaBarra,
|
|
Angulo = Angulo,
|
|
PercentualVelocidadeSPKmh = PercentualVelocidadeSPKmh,
|
|
TipoMovimento = TipoMovimento,
|
|
SimulacaoMPC = SimulacaoMPC != null
|
|
? new List<MPCSimulacaoModel>(SimulacaoMPC)
|
|
: new List<MPCSimulacaoModel>(),
|
|
Motivos = Motivos != null
|
|
? new List<string>(Motivos)
|
|
: new List<string>()
|
|
};
|
|
}
|
|
}
|
|
|
|
public class OperacaoParametrosDadosAtuadorModel
|
|
{
|
|
public bool Iniciado { get; set; }
|
|
public double Latencia { get; set; }
|
|
|
|
public double CapacidadeReservatorio { get; set; }
|
|
|
|
public int QtdCamerasSolo { get; set; }
|
|
|
|
public bool ErvasNoRadar { get; set; }
|
|
public double PercentualErvasNoRadar { get; set; }
|
|
public double PercentualErvasTerreno { get; set; }
|
|
|
|
public double HerbicidaConsumidoMl { get; set; }
|
|
public double HerbicidaPorAtuacaoMl { get; set; }
|
|
public double MassaReservatorioKg { get; set; }
|
|
public double VolumeReservatorioL { get; set; }
|
|
public double PercentualReservatorio { get; set; }
|
|
|
|
public double PressaoLinhaPsi { get; set; }
|
|
|
|
public double VazaoInstantaneaMLs { get; set; }
|
|
public double VazaoMediaMLs { get; set; }
|
|
public double VolumeVazaoMl { get; set; }
|
|
|
|
public double LPorMetro { get; set; }
|
|
public double LPorMinuto { get; set; }
|
|
public double TempoEstimadoRestanteMinutos { get; set; }
|
|
public double DistanciaEstimadaRestanteMetros { get; set; }
|
|
|
|
public double AnguloBarraEsquerda { get; set; }
|
|
public double AnguloBarraDireita { get; set; }
|
|
|
|
public List<OperacaoParametrosDadosBicoModel> Bicos { get; set; }
|
|
public List<OperacaoParametrosDadosBombaModel> Bombas { get; set; }
|
|
public List<OperacaoParametrosDadosSensorModel> Sensores { get; set; }
|
|
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
|
|
}
|
|
|
|
public class OperacaoParametrosDadosBombaModel
|
|
{
|
|
public string ID { get; set; }
|
|
public int ID_Num { get; set; }
|
|
public int Sensor_ID_Num { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public bool ComandoEstado { get; set; }
|
|
public bool LeituraEstado { get; set; }
|
|
public double ComandoPressao { get; set; }
|
|
public double LeituraPressao { get; set; }
|
|
public double TempoAtuado { get; set; }
|
|
public double ComandoPotencia { get; set; }
|
|
public double LeituraPotencia { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosDadosBicoModel
|
|
{
|
|
public string ID { get; set; }
|
|
public int ID_Num { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public int Posicao { get; set; }
|
|
public bool ComandoEstado { get; set; }
|
|
public bool LeituraEstado { get; set; }
|
|
public int ComandoAngulo { get; set; }
|
|
public int LeituraAngulo { get; set; }
|
|
public int QtdAtuacoes { get; set; }
|
|
public double TempoAtuado { get; set; }
|
|
public double VazaoMediaMLs { get; set; }
|
|
public double VazaoInstantaneaMLs { get; set; }
|
|
public double VolumeVazadoML { get; set; }
|
|
public double AnguloAbertura { get; set; }
|
|
public List<List<PontoGeo>> TrechosPulverizando { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosDadosServoModel
|
|
{
|
|
public string ID { get; set; }
|
|
public int ID_Num { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public bool Incremental { get; set; }
|
|
public int ComandoAngulo { get; set; }
|
|
public int LeituraAngulo { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosDadosReleModel
|
|
{
|
|
public string ID { get; set; }
|
|
public int ID_Num { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public bool ComandoEstado { get; set; }
|
|
public bool LeituraEstado { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosDadosSensorModel
|
|
{
|
|
public S_Code Componente { get; set; }
|
|
public string ID { get; set; }
|
|
public int ID_Num { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public List<dynamic> Valores { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosDadosSinaleiroModel
|
|
{
|
|
public string ID { get; set; }
|
|
public int ID_Num { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public SensorSinaleiroComportamentoModel Comportamento { get; set; }
|
|
public int StatusLedId { get; set; }
|
|
public StatusLED StatusLed { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosDadosSensoriamentoModel
|
|
{
|
|
public bool Iniciado { get; set; }
|
|
public double Latencia { get; set; }
|
|
|
|
public List<OperacaoParametrosDadosSinaleiroModel> Sinaleiros { get; set; }
|
|
public List<OperacaoParametrosDadosSensorModel> Sensores { get; set; }
|
|
public List<OperacaoParametrosDadosServoModel> Servos { get; set; }
|
|
public List<OperacaoParametrosDadosReleModel> Reles { get; set; }
|
|
|
|
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosDadosGNSSModel
|
|
{
|
|
public bool Iniciado { get; set; }
|
|
public double Latitude { get; set; }
|
|
public double Longitude { get; set; }
|
|
public double Altitude { get; set; }
|
|
public double Velocidade { get; set; }
|
|
public double Distancia { get; set; }
|
|
public double OrientacaoMovimento { get; set; }
|
|
public double OrientacaoReal { get; set; }
|
|
public int NumeroSatelites { get; set; }
|
|
public double PrecisaoHorizontal { get; set; }
|
|
public double PrecisaoCm { get; set; }
|
|
public TiposCorrecaoGPS QualidadeFix { get; set; }
|
|
public bool NtripAtivado { get; set; }
|
|
public double IdadeCorrecao { get; set; }
|
|
public double LeverArmLateral { get; set; }
|
|
public double LeverArmFrontal { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
|
|
public GPSModel ToGpsModel()
|
|
{
|
|
return new GPSModel()
|
|
{
|
|
Inicializado = Iniciado,
|
|
Latitude = Latitude,
|
|
Longitude = Longitude,
|
|
Altitude = Altitude,
|
|
Velocidade = Velocidade,
|
|
Distancia = Distancia,
|
|
OrientacaoMovimento = OrientacaoMovimento,
|
|
OrientacaoReal = OrientacaoReal,
|
|
NumeroSatelites = NumeroSatelites,
|
|
PrecisaoHorizontal = PrecisaoHorizontal,
|
|
QualidadeFix = QualidadeFix,
|
|
Ntrip_ativado = NtripAtivado,
|
|
IdadeCorrecao = IdadeCorrecao,
|
|
LeverArmFrontal = LeverArmFrontal,
|
|
LeverArmLateral = LeverArmLateral,
|
|
UltimoComandoRespondido = UltimoComandoRespondido
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
}
|