1108 lines
44 KiB
C#
1108 lines
44 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 MapaFeatureCollectionModel Mapa { get; set; }
|
|
public List<string> RuasPercorrer { get; set; }
|
|
public List<double[]> PontosRetorno { get; set; }
|
|
|
|
public OperacaoParametrosDadosModel DadosLeitura { get; set; }
|
|
|
|
|
|
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 _sonarAtivado;
|
|
public bool SonarAtivado
|
|
{
|
|
get => _sonarAtivado;
|
|
set
|
|
{
|
|
if (_sonarAtivado != value)
|
|
{
|
|
_sonarAtivado = value;
|
|
OnPropertyChanged(nameof(SonarAtivado));
|
|
}
|
|
}
|
|
}
|
|
|
|
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 _frenagemAutomaticaAoParar;
|
|
public bool FrenagemAutomaticaAoParar
|
|
{
|
|
get => _frenagemAutomaticaAoParar;
|
|
set
|
|
{
|
|
if (_frenagemAutomaticaAoParar != value)
|
|
{
|
|
_frenagemAutomaticaAoParar = value;
|
|
OnPropertyChanged(nameof(FrenagemAutomaticaAoParar));
|
|
}
|
|
}
|
|
}
|
|
|
|
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 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 _mpcMatrizCusto;
|
|
public bool MpcMatrizCusto
|
|
{
|
|
get => _mpcMatrizCusto;
|
|
set
|
|
{
|
|
if (_mpcMatrizCusto != value)
|
|
{
|
|
_mpcMatrizCusto = value;
|
|
OnPropertyChanged(nameof(MpcMatrizCusto));
|
|
}
|
|
}
|
|
}
|
|
|
|
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 bool CanSerial { 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 OperacaoParametrosDadosMovimentacaoModel Movimentacao { get; set; }
|
|
public OperacaoParametrosDadosDirecionalModel 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()
|
|
{
|
|
var op = Variaveis.OperacaoEmAndamento;
|
|
var sen = op.Sensoriamento;
|
|
var dAtu = op.DispAtu?.Dados;
|
|
var dSen = op.DispSen?.Dados;
|
|
var dMvd = op.DispMvd?.Dados;
|
|
|
|
if (dAtu == null || dSen == null || dMvd == null) return;
|
|
|
|
Momento = DateTime.Now;
|
|
StatusRover = op.Status;
|
|
CanSerial = CanManager.UseCanSerial;
|
|
Operacao = new OperacaoParametrosDadosOperacaoModel()
|
|
{
|
|
Iniciada = op.Iniciado,
|
|
Liberada = op.OperacaoLiberada,
|
|
Status = op.StatusAtual,
|
|
Modo = op.Parametros?.Modo ?? ModoOperacao.NaoDefinido,
|
|
ImpedimentoErro = op.ErroOperacaoLiberada,
|
|
TempoAguardandoSegs = op.TempoAguardandoSegs,
|
|
TempoDecorridoSegs = op.TempoDecorridoSegs,
|
|
Emergencia = op.Emergencia,
|
|
Pausa = op.Pausa,
|
|
IniciadoEm = op.DataInicio,
|
|
FinalizadoEm = op.DataFim,
|
|
ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>(op.Parametros.ModulosMandatorios ?? new List<OperacaoModulosMandatoriosModel>()),
|
|
ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>(op.Parametros.ParametrosMandatorios ?? new List<OperacaoParametrosMandatoriosModel>())
|
|
};
|
|
var t = sen?.Trajetoria;
|
|
Trajetoria = t != null ? new OperacaoParametrosDadosTrajetoriaModel()
|
|
{
|
|
AutonomiaCorredor = new OperacaoParametrosDadosTrajetoriaAutonomiaCorredorModel()
|
|
{
|
|
BateriaSuficiente = t.AutonomiaCooredor.BateriaSuficiente,
|
|
DistanciaCorredor_m = t.AutonomiaCooredor.DistanciaSeguraBateria_m,
|
|
DistanciaSeguraBateria_m = t.AutonomiaCooredor.DistanciaSeguraBateria_m,
|
|
DistanciaSeguraHerbicida_m = t.AutonomiaCooredor.DistanciaSeguraBateria_m,
|
|
HerbicidaSuficiente = t.AutonomiaCooredor.HerbicidaSuficiente,
|
|
Liberado = t.AutonomiaCooredor.Liberado,
|
|
Motivo = t.AutonomiaCooredor.Motivo,
|
|
Motivos = t.AutonomiaCooredor.Motivos.ToList(),
|
|
Status = t.AutonomiaCooredor.Status
|
|
},
|
|
AnguloCaminho = t.AnguloCaminho,
|
|
CorredorAtualDentro = t.CorredorAtual.Dentro,
|
|
CorredorAtualDistanciaPercorrida = t.CorredorAtual.DistanciaPercorridaCorredor,
|
|
CorredorAtualDistanciaTotal = t.CorredorAtual.DistanciaTotal,
|
|
CorredorAtualIdx = t.CorredorAtual.Idx,
|
|
DistanciaDireita = t.DistanciaDireita,
|
|
DistanciaEsquerda = t.DistanciaEsquerda,
|
|
DistanciaPercorrida = t.DistanciaPercorrida,
|
|
DistanciaTotal = t.DistanciaTotal,
|
|
NaMargemDoCorredor = t.NaMargemDoCorredor,
|
|
PercentualOperacao = t.PercentualOperacao,
|
|
PercentualRuaAtual = t.PercentualRuaAtual,
|
|
PontoAtualDistanciaAtual = t.PontoAtual.DistanciaAtual,
|
|
PontoAtualIdx = t.PontoAtual.idxPonto,
|
|
PontoAtualIdxCorredor = t.PontoAtual.idxCorredor,
|
|
ProximoPontoAproximando = t.ProximoPonto.Aproximando,
|
|
ProximoPontoDistanciaAtual = t.ProximoPonto.DistanciaAtual,
|
|
ProximoPontoIdx = t.ProximoPonto.idxPonto,
|
|
QtdPontos = t.QtdPontos,
|
|
StatusCarro = t.StatusCarro,
|
|
TempoEstimadoOperacao = t.TempoEstimadoOperacao
|
|
} : new OperacaoParametrosDadosTrajetoriaModel();
|
|
var c = op.Controle?.Clone();
|
|
Controle = c != null ? new OperacaoParametrosDadosControleModel()
|
|
{
|
|
Angulo = c.Angulo,
|
|
AlturaBarra = c.AlturaBarra,
|
|
PercentualVelocidadeSPKmh = c.PercentualVelocidadeSPKmh,
|
|
TipoMovimento = c.TipoMovimento,
|
|
SimulacaoMPC = c.SimulacaoMPC,
|
|
Motivos = c.Motivos
|
|
} : new OperacaoParametrosDadosControleModel();
|
|
ModulosSaude = new List<ManagerWorkerMessageResponseModulosPendentesModel>(sen?.ModulosSaude ?? new List<ManagerWorkerMessageResponseModulosPendentesModel>());
|
|
DispositivosMapeados = new List<DispositivoDetalhesModel>(sen?.DispositivosMapeados ?? new List<DispositivoDetalhesModel>());
|
|
Imu = sen?.IMU?.Clone();
|
|
Atuador = new OperacaoParametrosDadosAtuadorModel()
|
|
{
|
|
Iniciado = dAtu?.Conectado ?? false,
|
|
Latencia = dAtu?.DadosLeitura?.LatenciaLoop ?? 0,
|
|
|
|
AnguloBarraAltura = sen?.Atuador?.AnguloBarraAltura ?? 0,
|
|
AnguloBarraDireita = sen?.Atuador?.AnguloBarraDireita ?? 0,
|
|
AnguloBarraEsquerda = sen?.Atuador?.AnguloBarraEsquerda ?? 0,
|
|
CapacidadeReservatorio = sen?.Atuador?.CapacidadeReservatorio ?? 0,
|
|
ErvasNoRadar = sen?.Atuador?.ErvasNoRadar ?? false,
|
|
DistanciaEstimadaRestanteMetros = sen?.Atuador?.DistanciaEstimadaRestanteMetros ?? 0,
|
|
HerbicidaConsumidoMl = sen?.Atuador?.HerbicidaConsumido ?? 0,
|
|
HerbicidaPorAtuacaoMl = sen?.Atuador?.HerbicidaPorErva ?? 0,
|
|
LPorMetro = sen?.Atuador?.LPorMetro ?? 0,
|
|
LPorMinuto = sen?.Atuador?.LPorMinuto ?? 0,
|
|
MassaReservatorioKg = sen?.Atuador?.MassaReservatorio ?? 0,
|
|
VolumeReservatorioL = sen?.Atuador?.VolumeReservatorio ?? 0,
|
|
VolumeVazaoMl = sen?.Atuador?.VolumeVazaoMl ?? 0,
|
|
VazaoMediaMLs = sen?.Atuador?.VazaoMedia ?? 0,
|
|
VazaoInstantaneaMLs = sen?.Atuador?.VazaoInstantanea ?? 0,
|
|
TempoEstimadoRestanteMinutos = sen?.Atuador?.TempoEstimadoRestanteMinutos ?? 0,
|
|
QtdCamerasSolo = sen?.Atuador?.QtdCamerasSolo ?? 0,
|
|
PercentualErvasNoRadar = sen?.Atuador?.PercentualErvasNoRadar ?? 0,
|
|
PercentualErvasTerreno = sen?.Atuador?.PercentualErvasTerreno ?? 0,
|
|
PercentualReservatorio = sen?.Atuador?.PercentualReservatorio ?? 0,
|
|
PressaoLinhaPsi = sen?.Atuador?.PressaoLinha ?? 0,
|
|
Bicos = 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 = x._AnguloBicoLeitura,
|
|
ComandoEstado = x.ComandoAtuar,
|
|
LeituraEstado = x._EstadoLeitura == Estado.Ligado,
|
|
VazaoMediaMLs = x.VazaoMediaMLs,
|
|
VazaoInstantaneaMLs = x.VazaoInstantaneaMLs,
|
|
VolumeVazadoML = x.VolumeVazadoML,
|
|
QtdAtuacoes = x.Atuacoes,
|
|
TempoAtuado = x.TempoAtuado,
|
|
TrechosPulverizando = new List<List<double[]>>(x.TrechosAtuado ?? new List<List<double[]>>()),
|
|
UltimoComandoRespondido = x.UltimaLeitura
|
|
}).ToList(),
|
|
Bombas = 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,
|
|
Potencia = x._Potencia,
|
|
TempoAtuado = dAtu?.TempoAtuado ?? 0,
|
|
UltimoComandoRespondido = x.UltimaLeitura,
|
|
}).ToList(),
|
|
Sensores = dAtu?.Sensores?.Select(x => new OperacaoParametrosDadosSensorModel()
|
|
{
|
|
Componente = x.Componente,
|
|
ID = x.ID,
|
|
ID_Num = x.ID_Num,
|
|
Inicializado = x.Inicializado,
|
|
Valores = x.ValoresLeituras?.Where(y => y.funcao != FuncoesPinout.Iniciado)?.Select(y => y.atual?.valor).ToList(),
|
|
UltimoComandoRespondido = x.UltimaLeitura,
|
|
}).ToList(),
|
|
UltimoComandoRespondido = dAtu.DadosLeitura.UltimoComandoRespondido,
|
|
};
|
|
Sensoriamento = new OperacaoParametrosDadosSensoriamentoModel()
|
|
{
|
|
Iniciado = dSen?.Conectado ?? false,
|
|
Latencia = dSen?.DadosLeitura?.LatenciaLoop ?? 0,
|
|
|
|
Sensores = dSen?.Sensores?.Select(x => new OperacaoParametrosDadosSensorModel()
|
|
{
|
|
Componente = x.Componente,
|
|
ID = x.ID,
|
|
ID_Num = x.ID_Num,
|
|
Inicializado = x.Inicializado,
|
|
Valores = x.ValoresLeituras?.Where(y => y.funcao != FuncoesPinout.Iniciado)?.Select(y => y.atual?.valor).ToList(),
|
|
UltimoComandoRespondido = x.UltimaLeitura,
|
|
}).ToList(),
|
|
Servos = 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(),
|
|
Reles = 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(),
|
|
Sinaleiros = 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(),
|
|
UltimoComandoRespondido = dSen.DadosLeitura.UltimoComandoRespondido
|
|
};
|
|
Movimentacao = new OperacaoParametrosDadosMovimentacaoModel()
|
|
{
|
|
VelocidadeMediaMs = sen?.Movimentacao?.VelocidadeMedia ?? 0,
|
|
RPMMedio = sen?.Movimentacao?.RPMMedio ?? 0,
|
|
TemperaturaMedia = sen?.Movimentacao?.TemperaturaMedia ?? 0,
|
|
TempoMovimentoSegs = sen?.Movimentacao?.TempoMovimentoSegs ?? 0,
|
|
DistanciaPercorridaParcial = sen?.Movimentacao?.DistanciaPercorridaParcial ?? 0,
|
|
DistanciaPercorridaTotal = sen?.Movimentacao?.DistanciaPercorridaTotal ?? 0,
|
|
Modulos = dMvd?.Modulos?.Select(x => new OperacaoSensoriamentoLogMovDadosModel()
|
|
{
|
|
Mod_ID = x.MovMotor.Mod_ID,
|
|
ID = x.MovMotor._EnderecoCAN_Rx,
|
|
Iniciado = x.MovMotor.Inicializado,
|
|
Controlar = x.MovMotor.Comandar,
|
|
CicloTrabalho = x.MovMotor.CicloTrabalho,
|
|
Corrente_Barramento = x.MovMotor.Corrente_Barramento,
|
|
Corrente_Motor = x.MovMotor.Corrente_Motor,
|
|
Potencia = x.MovMotor.Potencia,
|
|
RPM_Motor = x.MovMotor.RPM_Motor,
|
|
RPM_Roda = x.MovMotor.RPM_Roda,
|
|
TemperaturaDriver = x.MovMotor.TemperaturaDriver,
|
|
Tensao = x.MovMotor.Tensao,
|
|
VelocidadeInstantaneaMs = x.MovMotor.VelocidadeInstantanea,
|
|
UltimoComandoRespondido = x.MovMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
|
|
}).ToList(),
|
|
UltimoComandoRespondido = dMvd.Modulos.Max(x => x.MovMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue)
|
|
};
|
|
Direcional = new OperacaoParametrosDadosDirecionalModel()
|
|
{
|
|
AnguloMedio = sen?.Direcional?.AnguloMedio ?? 0,
|
|
Modulos = dMvd.Modulos.Select(x => new DirSensoriamentoLogModel()
|
|
{
|
|
Mod_ID = x.DirMotor.Mod_ID,
|
|
ID = x.DirMotor._EnderecoCAN_Rx,
|
|
Iniciado = x.DirMotor.Inicializado,
|
|
Controlar = x.DirMotor.Comandar,
|
|
AnguloDriver = x.DirMotor.AnguloDriver,
|
|
AnguloFolgaCompensar = x.DirMotor.AnguloFolgaCompensar,
|
|
AnguloLeitura = x.DirMotor.AnguloLeitura,
|
|
AnguloReal = x.DirMotor.AnguloReal,
|
|
Angulo_SP = x.DirMotor.Angulo_SP,
|
|
FolgaMecanica = x.DirMotor.FolgaMecanica,
|
|
Sentido = x.DirMotor.Sentido,
|
|
SentidoReal = x.DirMotor.SentidoReal,
|
|
Sentido_SP = x.DirMotor.Sentido_SP,
|
|
Velocidade = x.DirMotor.Velocidade,
|
|
UltimoComandoRespondido = x.DirMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
|
|
}).ToList(),
|
|
UltimoComandoRespondido = dMvd.Modulos.Max(x => x.DirMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue)
|
|
};
|
|
Bateria = sen?.Bateria?.Clone();
|
|
Refrigeracao = sen?.CoolerControl?.Clone();
|
|
Gnss = new OperacaoParametrosDadosGNSSModel()
|
|
{
|
|
Iniciado = sen?.Gps?.Inicializado ?? false,
|
|
Altitude = sen?.Gps?.Altitude ?? 0,
|
|
Distancia = sen?.Gps?.Distancia ?? 0,
|
|
IdadeCorrecao = sen?.Gps?.IdadeCorrecao ?? 0,
|
|
Latitude = sen?.Gps?.Latitude ?? 0,
|
|
Longitude = sen?.Gps?.Longitude ?? 0,
|
|
LeverArmFrontal = sen?.Gps?.LeverArmFrontal ?? 0,
|
|
LeverArmLateral = sen?.Gps?.LeverArmLateral ?? 0,
|
|
NtripAtivado = sen?.Gps?.Ntrip_ativado ?? false,
|
|
NumeroSatelites = sen?.Gps?.NumeroSatelites ?? 0,
|
|
OrientacaoMovimento = sen?.Gps?.OrientacaoMovimento ?? 0,
|
|
OrientacaoReal = sen?.Gps?.OrientacaoReal ?? 0,
|
|
PrecisaoCm = sen?.Gps?.PrecisaoCm ?? 0,
|
|
PrecisaoHorizontal = sen?.Gps?.PrecisaoHorizontal ?? 0,
|
|
QualidadeFix = sen?.Gps?.QualidadeFix ?? TiposCorrecaoGPS.SemCorrecao,
|
|
Velocidade = sen?.Gps?.Velocidade ?? 0,
|
|
UltimoComandoRespondido = sen?.Gps?.UltimoComandoRespondido ?? DateTime.MinValue,
|
|
};
|
|
PerformanceNcp = sen?.DadosPerformance?.Clone();
|
|
LivoxLidar = sen?.LivoxLidar?.Clone();
|
|
CameraWorkerService.GetListaCameras();
|
|
Cameras = CameraWorkerService.ListaCameras;
|
|
OperadorVisual = VisualWorkerService.DadosLeitura?.Resumo?.UpdateClone();
|
|
var l = sen?.Logs;
|
|
Logs = l != null ? l.Where(x => x.Momento >= UltimoEnvioLog).ToList() : new List<OperacaoSensoriamentoLogErrosModel>();
|
|
}
|
|
|
|
public OperacaoParametrosDadosModel Clone()
|
|
{
|
|
return new OperacaoParametrosDadosModel()
|
|
{
|
|
Momento = Momento,
|
|
StatusRover = StatusRover,
|
|
CanSerial = CanSerial,
|
|
Operacao = Operacao,
|
|
Trajetoria = Trajetoria?.Clone(),
|
|
Controle = Controle?.Clone(),
|
|
ModulosSaude = new List<ManagerWorkerMessageResponseModulosPendentesModel>(ModulosSaude ?? new List<ManagerWorkerMessageResponseModulosPendentesModel>()),
|
|
DispositivosMapeados = new List<DispositivoDetalhesModel>(DispositivosMapeados ?? new List<DispositivoDetalhesModel>()),
|
|
Imu = Imu?.Clone(),
|
|
Atuador = Atuador,
|
|
Sensoriamento = Sensoriamento,
|
|
Movimentacao = Movimentacao,
|
|
Direcional = Direcional,
|
|
Bateria = Bateria?.Clone(),
|
|
Refrigeracao = Refrigeracao?.Clone(),
|
|
Gnss = Gnss,
|
|
PerformanceNcp = PerformanceNcp?.Clone(),
|
|
LivoxLidar = LivoxLidar?.Clone(),
|
|
Logs = new List<OperacaoSensoriamentoLogErrosModel>(Logs ?? new List<OperacaoSensoriamentoLogErrosModel>()),
|
|
Cameras = new List<CameraWorkerItemModel>(Cameras ?? new List<CameraWorkerItemModel>()),
|
|
OperadorVisual = OperadorVisual?.Clone(),
|
|
UltimoEnvioLog = UltimoEnvioLog
|
|
};
|
|
}
|
|
|
|
}
|
|
|
|
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,
|
|
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,
|
|
Motivos = 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 double AnguloBarraAltura { 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 TempoAtuado { get; set; }
|
|
public double Potencia { 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<double[]>> 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 OperacaoParametrosDadosMovimentacaoModel
|
|
{
|
|
public double VelocidadeMediaMs { get; set; }
|
|
public double RPMMedio { get; set; }
|
|
public double TempoMovimentoSegs { get; set; }
|
|
public double DistanciaPercorridaTotal { get; set; }
|
|
public double DistanciaPercorridaParcial { get; set; }
|
|
public double TemperaturaMedia { get; set; }
|
|
public List<OperacaoSensoriamentoLogMovDadosModel> Modulos { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosDadosDirecionalModel
|
|
{
|
|
public double AnguloMedio { get; set; }
|
|
public List<DirSensoriamentoLogModel> Modulos { 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
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
}
|