3090 lines
150 KiB
C#
3090 lines
150 KiB
C#
using AgroBase.Comum;
|
|
using AgroBase.Forms.Operacoes;
|
|
using AgroBase.Models.Modules;
|
|
using AgroBase.Models.Operacoes;
|
|
using AgroBase.Services;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using static AgroBase.Models.Enums;
|
|
using System.Drawing;
|
|
using System.Text;
|
|
using static AgroBase.Services.OIDCanService.OidHandler;
|
|
using AgroBase.Models.Operadores;
|
|
using AgroBase.Services.Operadores;
|
|
using AgroMonitor;
|
|
using Newtonsoft.Json.Linq;
|
|
|
|
namespace AgroBase.Models
|
|
{
|
|
public class OperacaoModel
|
|
{
|
|
|
|
public OperacaoModel(ModoOperacao Modo)
|
|
{
|
|
this.Modo = Modo;
|
|
|
|
if (Variaveis.OperacaoEmAndamento != null)
|
|
{
|
|
tmrLogs?.Dispose();
|
|
tmrLogs = new AsyncTaskTimerModel("tmrLogs", tmrLogs_Tick, 1000);
|
|
|
|
tmrLeituras?.Dispose();
|
|
tmrLeituras = new AsyncTaskTimerModel("tmrLeitura", tmrLeituras_Tick, 500);
|
|
tmrLeituras.Start();
|
|
|
|
tmrComunicacao?.Dispose();
|
|
tmrComunicacao = new AsyncTaskTimerModel("tmrComunicacao", tmrComunicacao_Tick, 1000);
|
|
tmrComunicacao.Start();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public ModoOperacao Modo { get; set; }
|
|
public StatusModulo Status { get; set; }
|
|
public string Descricao { get; set; }
|
|
public string OprPath { get; set; }
|
|
public OperacaoControleModel Controle { get; set; } = new OperacaoControleModel();
|
|
public OperacaoControleModel ControleAnterior { get; set; } = new OperacaoControleModel();
|
|
public DispositivosService<MovimentacaoUnificadaModel> DispMvd { get; set; }
|
|
public DispositivosService<SensoriamentoModel> DispSen { get; set; }
|
|
public DispositivosService<AtuadorModel> DispAtu { get; set; }
|
|
public MapasModel Mapa { get; set; } = new MapasModel();
|
|
public TrajetoriaMapaOperacaoModel Trajetoria { get; set; }
|
|
public List<GPSModel> GPSTrajetoria { get; set; } = new List<GPSModel>();
|
|
public OperacaoParametrosModel Parametros { get; set; } = new OperacaoParametrosModel();
|
|
public OperacaoSensoriamentoLogModel Sensoriamento { get; set; } = new OperacaoSensoriamentoLogModel();
|
|
public PerformanceModel DadosPerformance { get; set; } = new PerformanceModel();
|
|
public Form frmOperacao { get; set; }
|
|
|
|
#region STATUS DE CONTEXTO
|
|
public StatusOperacao StatusAtual { get; private set; } = StatusOperacao.NaoIniciado;
|
|
public StatusOperacao StatusAnterior { get; private set; } = StatusOperacao.NaoIniciado;
|
|
public bool Emergencia { get; set; } = false;
|
|
public bool Pausa { get; set; } = false;
|
|
public bool OperacaoLiberada { get; private set; } = false;
|
|
public bool OperacaoConfigurada { get; private set; } = false;
|
|
public string ErroOperacaoLiberada { get; set; }
|
|
public DateTime TempoAguardando { get; private set; } = DateTime.Now;
|
|
public double TempoAguardandoSegs => (TempoAguardando.AddSeconds(TempoIniciarOperacao) - DateTime.Now).TotalSeconds;
|
|
public bool Iniciado { get; set; }
|
|
public bool Finalizando { get; set; } = false;
|
|
public bool Calibrando { get; set; } = false;
|
|
public DateTime DataInicio { get; set; } = DateTime.MinValue;
|
|
public DateTime DataFim { get; set; } = DateTime.MinValue;
|
|
public double TempoDecorridoSegs
|
|
{
|
|
get
|
|
{
|
|
return (StatusAtual == StatusOperacao.Parametrizando ? 0 : ((Variaveis.OperacaoEmAndamento.DataFim != DateTime.MinValue ? Variaveis.OperacaoEmAndamento.DataFim : DateTime.Now) - Variaveis.OperacaoEmAndamento.DataInicio).TotalSeconds);
|
|
}
|
|
}
|
|
|
|
public void AtualizarDadosContexto()
|
|
{
|
|
HealthWorkerService.AtualizarDadosContexto();
|
|
|
|
Variaveis.OperacaoEmAndamento.StatusAtual = (StatusOperacao)RedisService.GetField<int>(CtxKey.DadosOperacao, "status", 0);
|
|
Variaveis.OperacaoEmAndamento.OperacaoLiberada = RedisService.GetField(CtxKey.DadosOperacao, "liberado", false);
|
|
Variaveis.OperacaoEmAndamento.OperacaoConfigurada = RedisService.GetField(CtxKey.DadosOperacao, "configurado", false);
|
|
var tempoAguardando = RedisService.GetField<long>(CtxKey.DadosOperacao, "tempo_aguardando", 0);
|
|
Variaveis.OperacaoEmAndamento.TempoAguardando = DateTimeOffset.FromUnixTimeSeconds(tempoAguardando).UtcDateTime.AddSeconds(tempoAguardando % 1).ToLocalTime();
|
|
Variaveis.OperacaoEmAndamento.ErroOperacaoLiberada = RedisService.GetField<string>(CtxKey.DadosOperacao, "motivo_nao_liberado");
|
|
GPSService.CorrecaoRTK_Ntrip = RedisService.GetField<bool>(RedisService.ModKey(T_Code.Gps), "correcao_ntrip", false);
|
|
|
|
if (Variaveis.OperacaoEmAndamento.StatusAtual != Variaveis.OperacaoEmAndamento.StatusAnterior)
|
|
{
|
|
AudioAlertaService.AlertaSonoroPorStatus(Variaveis.OperacaoEmAndamento.StatusAtual);
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.StatusAnterior = Variaveis.OperacaoEmAndamento.StatusAtual;
|
|
|
|
List<ManagerWorkerMessageResponseModulosPendentesModel> saudeAnterior = new List<ManagerWorkerMessageResponseModulosPendentesModel>(HealthWorkerService.ModulosSaude ?? new List<ManagerWorkerMessageResponseModulosPendentesModel>());
|
|
HealthWorkerService.ModulosSaude = RedisService.GetField<ManagerWorkerMessageResponseModulosPendentesModel[]>(CtxKey.DadosOperacao, "status_modulos").ToList();
|
|
|
|
foreach (var mod in HealthWorkerService.ModulosSaude)
|
|
{
|
|
var mod_ant = saudeAnterior.FirstOrDefault(x => x.modulo == mod.modulo);
|
|
if (mod.status != mod_ant?.status)
|
|
{
|
|
string msg = mod.motivos.Any() ? string.Join("; ", mod.motivos) : $"{mod.status} ({mod.saude:0}%)";
|
|
string msg2 = mod.condicoes_operacionais.Any() ? string.Join("; ", mod.condicoes_operacionais.Select(x => x.descricao)) : null;
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.InserirLog(mod.modulo, mod.status, mod.saude, msg, condicoes: msg2);
|
|
}
|
|
if (mod.saude_individual.Any())
|
|
{
|
|
foreach (var ind in mod.saude_individual)
|
|
{
|
|
var ind_ant = saudeAnterior.FirstOrDefault(x => x.modulo == mod.modulo && x.saude_individual.Any(y => y.id == ind.id))?.saude_individual?.FirstOrDefault(x => x.id == ind.id);
|
|
if (ind.status != ind_ant?.status)
|
|
{
|
|
string msg = ind.motivos.Any() ? string.Join("; ", ind.motivos) : $"{ind.status} ({ind.saude:0}%)";
|
|
string msg2 = ind.condicoes_operacionais.Any() ? string.Join("; ", ind.condicoes_operacionais.Select(x => x.descricao)) : null;
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.InserirLog(mod.modulo, ind.status, ind.saude, msg, condicoes: msg2, id: ind.label);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
double saude_geral = HealthWorkerService.ModulosSaude.DefaultIfEmpty().Average(x => x?.saude ?? 0);
|
|
Variaveis.OperacaoEmAndamento.Status =
|
|
!Variaveis.OperacaoEmAndamento.OperacaoLiberada ? StatusModulo.Falha :
|
|
saude_geral <= 0.0 ? StatusModulo.Desconectado :
|
|
saude_geral < 80.0 ? StatusModulo.Alerta :
|
|
StatusModulo.Operante;
|
|
|
|
SerialService.DispositivosMapeados.ForEach(d => d.AtualizarDados());
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
public bool Treinando { get; set; } = false;
|
|
public bool Simulando { get; set; } = false;
|
|
public double SimulacaoAnguloControle { get; set; } = 0;
|
|
public double SimulacaoRpmControle { get; set; } = 0;
|
|
|
|
public Dictionary<T_Code, Dictionary<string, bool>> ModsCalibragem { get; set; } = new Dictionary<T_Code, Dictionary<string, bool>>();
|
|
|
|
|
|
//public List<OperacaoModulosMandatoriosModel> ModulosMandatorios { get; set; } = new List<OperacaoModulosMandatoriosModel>();
|
|
//public List<OperacaoParametrosMandatoriosModel> ParametrosMandatorios { get; set; } = new List<OperacaoParametrosMandatoriosModel>();
|
|
public int TempoIniciarOperacao { get; set; } = 10;
|
|
public string ID { get; set; }
|
|
public double tmrLogsInterval
|
|
{
|
|
get
|
|
{
|
|
return tmrLogs.Interval;
|
|
}
|
|
set
|
|
{
|
|
tmrLogs.SetInterval((int)value);
|
|
}
|
|
}
|
|
private static AsyncTaskTimerModel tmrLogs;
|
|
public double tmrLeiturasInterval
|
|
{
|
|
get
|
|
{
|
|
return tmrLeituras.Interval;
|
|
}
|
|
set
|
|
{
|
|
tmrLeituras.SetInterval((int)value);
|
|
}
|
|
}
|
|
private static AsyncTaskTimerModel tmrLeituras;
|
|
private static AsyncTaskTimerModel tmrComunicacao;
|
|
|
|
|
|
|
|
#region PARAMETRIZACAO
|
|
|
|
public bool SalvarParametrizacaoOperacao(
|
|
string descricao,
|
|
double capacidadeReservatorio,
|
|
double pressaoLinha,
|
|
int duracaoAtuacao,
|
|
int percentualAtuacao,
|
|
int anguloMaximo,
|
|
int velocidadeMovimento,
|
|
int velocidadeServasPercent,
|
|
int velocidadeCervasPercent,
|
|
UltrasonicA05Configuracoes ConfigUltrassom,
|
|
bool sonarAtivado,
|
|
int qtdCamerasSolo,
|
|
TiposControladorDirecional tipoControleDirecional,
|
|
bool movimentoAutomatico,
|
|
bool direcionalAutomatico,
|
|
bool pulverizadorAutomatico,
|
|
bool frenagemAutomatica)
|
|
{
|
|
if (string.IsNullOrEmpty(descricao))
|
|
{
|
|
MessageBox.Show("Preencha a descrição para identificação da operação!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return false;
|
|
}
|
|
|
|
if (Variaveis.OperacaoEmAndamento.Parametros.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && x.Mandatorio) && string.IsNullOrEmpty(Variaveis.OperacaoEmAndamento.Mapa?.mapaService?.CaminhoMapa) && !(Variaveis.OperacaoEmAndamento.Mapa?.RuasPercorrer ?? new List<string>()).Any())
|
|
{
|
|
MessageBox.Show("Selecione o mapa da operação e selecione as ruas a serem percorridas!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return false;
|
|
}
|
|
|
|
OperacaoParametrosModel Parametros = new OperacaoParametrosModel()
|
|
{
|
|
Modo = Variaveis.OperacaoEmAndamento.Modo,
|
|
Descricao = descricao,
|
|
CapacidadeReservatorio = capacidadeReservatorio,
|
|
Controle = new OperacaoParametrosControleModel()
|
|
{
|
|
SonarAtivado = sonarAtivado,
|
|
MovimentoAutomatico = movimentoAutomatico,
|
|
DirecionalAutomatico = direcionalAutomatico,
|
|
PulverizadorAutomatico = pulverizadorAutomatico,
|
|
FrenagemAutomaticaAoParar = frenagemAutomatica,
|
|
AtuDuracaoAtuacao = duracaoAtuacao,
|
|
AtuPercentualInicioPulverizacao = percentualAtuacao,
|
|
AtuPressaoLinha = pressaoLinha,
|
|
DirAnguloMaximo = anguloMaximo,
|
|
DirVelocidadeMovimento = velocidadeMovimento,
|
|
DirTipoMovimento = tipoControleDirecional,
|
|
MovVelocidadeCErvasPercent = velocidadeCervasPercent,
|
|
MovVelocidadeSErvasPercent = velocidadeServasPercent,
|
|
},
|
|
|
|
ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>(Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios),
|
|
ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>(Variaveis.OperacaoEmAndamento.Parametros.ParametrosMandatorios),
|
|
//Mapa = Variaveis.OperacaoEmAndamento.Mapa,
|
|
//ConfiguracaoUltrassom = ConfigUltrassom,
|
|
|
|
QtdCamerasSolo = qtdCamerasSolo,
|
|
|
|
};
|
|
//Parametros.Mapa.LimparDados(true);
|
|
|
|
string ParametrosJson = JsonConvert.SerializeObject(Parametros, Formatting.None);
|
|
SaveFileDialog saveFileDialog = new SaveFileDialog();
|
|
saveFileDialog.Filter = "Arquivo de Operação (*.opr)|*.opr";
|
|
saveFileDialog.DefaultExt = "opr";
|
|
saveFileDialog.AddExtension = true;
|
|
saveFileDialog.InitialDirectory = Variaveis.CaminhoSistema + Variaveis.CaminhoOperacoes;
|
|
saveFileDialog.FileName = descricao;
|
|
if (saveFileDialog.ShowDialog() == DialogResult.OK)
|
|
{
|
|
string filePath = saveFileDialog.FileName;
|
|
|
|
File.WriteAllText(filePath, ParametrosJson, Encoding.UTF8);
|
|
|
|
MessageBox.Show("Operação salva com sucesso!", "Sucesso", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public (bool, List<string>) CarregarParametrizacaoOperacao(Panel pnlMapa, Label lblMapa, string opPath = "")
|
|
{
|
|
string path = Variaveis.CaminhoSistema + Variaveis.CaminhoOperacoes + MapasVariaveisModel.NomeArquivoMapaInterativoSaida;
|
|
|
|
OpenFileDialog openFileDialog = new OpenFileDialog();
|
|
openFileDialog.Filter = "Arquivo de Operação (*.opr)|*.opr";
|
|
openFileDialog.DefaultExt = "opr";
|
|
openFileDialog.AddExtension = true;
|
|
openFileDialog.InitialDirectory = Variaveis.CaminhoSistema + Variaveis.CaminhoOperacoes;
|
|
if (!string.IsNullOrEmpty(opPath) || openFileDialog.ShowDialog() == DialogResult.OK)
|
|
{
|
|
string opr_path = !string.IsNullOrEmpty(opPath) ? opPath : openFileDialog.FileName;
|
|
|
|
if (!File.Exists(opr_path)) return (false, new List<string>());
|
|
|
|
string ParametrosJson = File.ReadAllText(opr_path, Encoding.UTF8);
|
|
|
|
var Parametros = JsonConvert.DeserializeObject<OperacaoParametrosModel>(ParametrosJson);
|
|
|
|
if (Parametros.Modo == null) return (false, new List<string>());
|
|
|
|
CarregarParametrosOperacaoPadrao((ModoOperacao)Parametros.Modo, true);
|
|
|
|
Variaveis.OperacaoEmAndamento.Parametros = Parametros;
|
|
|
|
Variaveis.OperacaoEmAndamento.Descricao = Parametros.Descricao;
|
|
Variaveis.OperacaoEmAndamento.OprPath = opr_path;
|
|
if (Variaveis.OperacaoEmAndamento.DispSen == null)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.DispSen = new DispositivosService<SensoriamentoModel>();
|
|
}
|
|
//Variaveis.OperacaoEmAndamento.DispSen.Dados.ConfiguracaoSensorUltrassom = Parametros.ConfiguracaoUltrassom;
|
|
|
|
List<string> ruasSelecionadas = new List<string>();
|
|
//if (Parametros.Mapa.mapaService.DadosMapa != null)
|
|
//{
|
|
// ruasSelecionadas = Parametros.Mapa.RuasPercorrer.ToList();
|
|
// string geoJson = JsonConvert.SerializeObject(Parametros.Mapa.mapaService.DadosMapa, Formatting.None);
|
|
// File.WriteAllText(path, geoJson, Encoding.UTF8);
|
|
// Variaveis.OperacaoEmAndamento.Mapa = Parametros.Mapa;
|
|
//
|
|
// /*Panel pnlMapa = FuncoesGlobais.FindControlRecursive<Panel>(Variaveis.OperacaoEmAndamento.frmOperacao, "pnlMapa");
|
|
// Label lblMapa = FuncoesGlobais.FindControlRecursive<Label>(Variaveis.OperacaoEmAndamento.frmOperacao, "lblMapaCarregado");*/
|
|
// Variaveis.OperacaoEmAndamento.Mapa.pnlMapa = pnlMapa;
|
|
// Variaveis.OperacaoEmAndamento.Mapa.lblMapa = lblMapa;
|
|
//
|
|
// Variaveis.OperacaoEmAndamento.Mapa.btnCarregar_Click(new object(), new EventArgs(), path);
|
|
//
|
|
// //bool condicaoMapaCarregado() => Variaveis.OperacaoEmAndamento.Mapa.mapaService.Carregado;
|
|
// //bool resultado = await FuncoesGlobais.AguardarCondicaoAsync(condicaoMapaCarregado, 5000, 200);
|
|
//}
|
|
|
|
RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));
|
|
|
|
return (true, ruasSelecionadas);
|
|
}
|
|
else
|
|
{
|
|
return (false, new List<string>());
|
|
}
|
|
}
|
|
|
|
|
|
public static OperacaoParametrosModel CarregarParametrosOperacaoPadrao(ModoOperacao Modo, bool isagrobase)
|
|
{
|
|
OperacaoParametrosModel p = new OperacaoParametrosModel()
|
|
{
|
|
Modo = Modo,
|
|
QtdCamerasSolo = VariaveisEquipamento.QuantidadeCamerasSolo,
|
|
QtdBicos = VariaveisEquipamento.QuantidadeBicosPulverizadores,
|
|
CapacidadeReservatorio = VariaveisEquipamento.CapacidadeReservatorio,
|
|
RoverId = VariaveisEquipamento.Parametros.serial_number,
|
|
RuasPercorrer = null,
|
|
Mapa = null,
|
|
DadosLeitura = new OperacaoParametrosDadosModel(),
|
|
};
|
|
|
|
if (isagrobase)
|
|
{
|
|
var SenConectado = (DispositivosService<SensoriamentoModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Sen);
|
|
var AtuConectado = (DispositivosService<AtuadorModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Atu);
|
|
var MvdConectado = (DispositivosService<MovimentacaoUnificadaModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Mvd);
|
|
tmrLogs?.Stop();
|
|
Variaveis.OperacaoEmAndamento = new OperacaoModel(Modo)
|
|
{
|
|
Iniciado = false,
|
|
DataInicio = DateTime.MinValue,
|
|
DataFim = DateTime.MinValue,
|
|
DispAtu = AtuConectado,
|
|
DispSen = SenConectado,
|
|
DispMvd = MvdConectado,
|
|
};
|
|
}
|
|
|
|
switch (Modo)
|
|
{
|
|
case ModoOperacao.Manual:
|
|
p.Controle = new OperacaoParametrosControleModel()
|
|
{
|
|
RegistrarDadosPosProcessamento = false,
|
|
|
|
MovimentoAutomatico = false,
|
|
DirecionalAutomatico = false,
|
|
PulverizadorAutomatico = false,
|
|
|
|
SonarAtivado = false,
|
|
FrenagemAutomaticaAoParar = false,
|
|
ImuParadaPorInclinacao = false,
|
|
OakParadaPorObstaculo = false,
|
|
MpcMatrizCusto = false,
|
|
MpcHorizonte = 4.0,
|
|
|
|
MovVelocidadeSErvasPercent = 100,
|
|
MovVelocidadeCErvasPercent = 15,
|
|
DirAnguloMaximo = 25,
|
|
DirVelocidadeMovimento = 40,
|
|
|
|
DirTipoMovimento = TiposControladorDirecional.Manual,
|
|
|
|
AtuAlturaAreaPulverizacao = 10,
|
|
AtuDuracaoAtuacao = 200,
|
|
AtuPercentualErvasBicoOff = 2,
|
|
AtuPercentualErvasBicoOn = 1,
|
|
AtuPercentualInicioPulverizacao = 70,
|
|
AtuPressaoLinha = 85,
|
|
};
|
|
p.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
|
|
{
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Mov,
|
|
Mandatorio = false,
|
|
Utilizar = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Dir,
|
|
Mandatorio = false,
|
|
Utilizar = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Atu,
|
|
Mandatorio = false,
|
|
Utilizar = true,
|
|
}
|
|
};
|
|
p.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
|
|
{
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.Joystick,
|
|
Mandatorio = false,
|
|
Utilizar = true,
|
|
},
|
|
};
|
|
if (isagrobase)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.frmOperacao = new frmOperacaoManual();
|
|
Variaveis.OperacaoEmAndamento.ControleAnterior = new OperacaoControleModel();
|
|
Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
|
|
{
|
|
TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
|
|
Angulo = 25,
|
|
Direcao = Direcao.Parado,
|
|
EmFreio = false,
|
|
PercentualVelocidadeSP = 20,
|
|
AlturaBarra = 50,
|
|
TiposControle = new List<OperacaoControleTipoModel>()
|
|
{
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Mov,
|
|
DelayEnvioComandoBase = 10,
|
|
DelayEnvioComando = 10,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Dir,
|
|
DelayEnvioComandoBase = 10,
|
|
DelayEnvioComando = 10,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Atu,
|
|
DelayEnvioComandoBase = 10,
|
|
DelayEnvioComando = 10,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
},
|
|
};
|
|
}
|
|
break;
|
|
case ModoOperacao.MapaGPS:
|
|
p.Controle = new OperacaoParametrosControleModel()
|
|
{
|
|
RegistrarDadosPosProcessamento = false,
|
|
|
|
MovimentoAutomatico = true,
|
|
DirecionalAutomatico = true,
|
|
PulverizadorAutomatico = true,
|
|
|
|
SonarAtivado = false,
|
|
FrenagemAutomaticaAoParar = true,
|
|
ImuParadaPorInclinacao = true,
|
|
OakParadaPorObstaculo = true,
|
|
MpcMatrizCusto = false,
|
|
MpcHorizonte = 4.0,
|
|
|
|
MovVelocidadeSErvasPercent = 50,
|
|
MovVelocidadeCErvasPercent = 20,
|
|
DirAnguloMaximo = 30,
|
|
DirVelocidadeMovimento = 50,
|
|
|
|
DirTipoMovimento = TiposControladorDirecional.MPC,
|
|
|
|
AtuAlturaAreaPulverizacao = 10,
|
|
AtuDuracaoAtuacao = 200,
|
|
AtuPercentualErvasBicoOff = 2,
|
|
AtuPercentualErvasBicoOn = 1,
|
|
AtuPercentualInicioPulverizacao = 70,
|
|
AtuPressaoLinha = 85,
|
|
};
|
|
p.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
|
|
{
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Mov,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Dir,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Sen,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Atu,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Gps,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Cam,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Snr,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
},
|
|
};
|
|
p.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
|
|
{
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.Mapa,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
},
|
|
};
|
|
if (isagrobase)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.frmOperacao = new frmOperacaoMapaGPS();
|
|
Variaveis.OperacaoEmAndamento.ControleAnterior = new OperacaoControleModel();
|
|
Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
|
|
{
|
|
TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
|
|
Angulo = 0,
|
|
Direcao = Direcao.Parado,
|
|
EmFreio = false,
|
|
PercentualVelocidadeSP = 0,
|
|
AlturaBarra = 50,
|
|
TiposControle = new List<OperacaoControleTipoModel>()
|
|
{
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Mov,
|
|
DelayEnvioComandoBase = 500,
|
|
DelayEnvioComando = 500,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Dir,
|
|
DelayEnvioComandoBase = 300,
|
|
DelayEnvioComando = 300,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Atu,
|
|
DelayEnvioComandoBase = 200,
|
|
DelayEnvioComando = 200,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
},
|
|
};
|
|
}
|
|
break;
|
|
case ModoOperacao.TreinamentoIA:
|
|
p.Controle = new OperacaoParametrosControleModel()
|
|
{
|
|
RegistrarDadosPosProcessamento = false,
|
|
|
|
MovimentoAutomatico = true,
|
|
DirecionalAutomatico = true,
|
|
PulverizadorAutomatico = false,
|
|
|
|
SonarAtivado = false,
|
|
FrenagemAutomaticaAoParar = false,
|
|
ImuParadaPorInclinacao = false,
|
|
OakParadaPorObstaculo = false,
|
|
MpcMatrizCusto = false,
|
|
MpcHorizonte = 4.0,
|
|
|
|
MovVelocidadeSErvasPercent = 50,
|
|
MovVelocidadeCErvasPercent = 20,
|
|
DirAnguloMaximo = 30,
|
|
DirVelocidadeMovimento = 50,
|
|
DirTipoMovimento = TiposControladorDirecional.IA,
|
|
|
|
AtuAlturaAreaPulverizacao = 10,
|
|
AtuDuracaoAtuacao = 200,
|
|
AtuPercentualErvasBicoOff = 2,
|
|
AtuPercentualErvasBicoOn = 1,
|
|
AtuPercentualInicioPulverizacao = 70,
|
|
AtuPressaoLinha = 85,
|
|
};
|
|
p.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
|
|
{
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Mov,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Dir,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Atu,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Gps,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Sen,
|
|
Mandatorio = false,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Wit,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Pzm,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Lra,
|
|
Mandatorio = true,
|
|
}
|
|
};
|
|
p.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
|
|
{
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.CameraSolo,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.Sonar,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.Mapa,
|
|
Mandatorio = true,
|
|
}
|
|
};
|
|
if (isagrobase)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.ControleAnterior = new OperacaoControleModel();
|
|
Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
|
|
{
|
|
TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
|
|
Angulo = 0,
|
|
Direcao = Direcao.Parado,
|
|
EmFreio = false,
|
|
PercentualVelocidadeSP = 0,
|
|
TiposControle = new List<OperacaoControleTipoModel>()
|
|
{
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Mov,
|
|
DelayEnvioComandoBase = 500,
|
|
DelayEnvioComando = 500,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Dir,
|
|
DelayEnvioComandoBase = 1000,
|
|
DelayEnvioComando = 1000,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Atu,
|
|
DelayEnvioComandoBase = 500,
|
|
DelayEnvioComando = 500,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
},
|
|
};
|
|
}
|
|
break;
|
|
case ModoOperacao.MapeamentoVisual:
|
|
p.Controle = new OperacaoParametrosControleModel()
|
|
{
|
|
RegistrarDadosPosProcessamento = false,
|
|
|
|
MovimentoAutomatico = true,
|
|
DirecionalAutomatico = true,
|
|
PulverizadorAutomatico = false,
|
|
|
|
SonarAtivado = false,
|
|
FrenagemAutomaticaAoParar = true,
|
|
ImuParadaPorInclinacao = true,
|
|
OakParadaPorObstaculo = true,
|
|
MpcMatrizCusto = false,
|
|
MpcHorizonte = 4.0,
|
|
|
|
MovVelocidadeSErvasPercent = 40,
|
|
MovVelocidadeCErvasPercent = 20,
|
|
DirAnguloMaximo = 30,
|
|
DirVelocidadeMovimento = 50,
|
|
|
|
DirTipoMovimento = TiposControladorDirecional.PID,
|
|
|
|
AtuAlturaAreaPulverizacao = 10,
|
|
AtuDuracaoAtuacao = 200,
|
|
AtuPercentualErvasBicoOff = 2,
|
|
AtuPercentualErvasBicoOn = 1,
|
|
AtuPercentualInicioPulverizacao = 70,
|
|
AtuPressaoLinha = 85,
|
|
};
|
|
p.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
|
|
{
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Mov,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Dir,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
}
|
|
};
|
|
p.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
|
|
{
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.Sonar,
|
|
Mandatorio = true,
|
|
Utilizar = true,
|
|
}
|
|
};
|
|
if (isagrobase)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.ControleAnterior = new OperacaoControleModel();
|
|
Variaveis.OperacaoEmAndamento.Controle = new OperacaoControleModel()
|
|
{
|
|
TipoMovimento = TipoMovimentoDirecional.RodasDianteiras,
|
|
Angulo = 0,
|
|
Direcao = Direcao.Parado,
|
|
EmFreio = false,
|
|
PercentualVelocidadeSP = 0,
|
|
TiposControle = new List<OperacaoControleTipoModel>()
|
|
{
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Mov,
|
|
DelayEnvioComandoBase = 500,
|
|
DelayEnvioComando = 500,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Dir,
|
|
DelayEnvioComandoBase = 200,
|
|
DelayEnvioComando = 200,
|
|
DelayEnvioComandoExtra = 0,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
}
|
|
},
|
|
};
|
|
}
|
|
break;
|
|
}
|
|
|
|
p.ModulosMandatorios.Add(new OperacaoModulosMandatoriosModel() { Dispositivo = T_Code.Npc, Mandatorio = true, Utilizar = true });
|
|
p.ModulosMandatorios.Add(new OperacaoModulosMandatoriosModel() { Dispositivo = T_Code.Can, Mandatorio = true, Utilizar = true });
|
|
p.ModulosMandatorios.Add(new OperacaoModulosMandatoriosModel() { Dispositivo = T_Code.Ipb, Mandatorio = true, Utilizar = true });
|
|
p.ModulosMandatorios.Add(new OperacaoModulosMandatoriosModel() { Dispositivo = T_Code.Bat, Mandatorio = true, Utilizar = true });
|
|
p.ModulosMandatorios.ForEach(m => m.ComponentesEmUso = Variaveis.OperacaoEmAndamento.PreencherComponentesEmUso(m.Dispositivo));
|
|
|
|
if (isagrobase)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Parametros = p;
|
|
Variaveis.OperacaoEmAndamento.Trajetoria = new TrajetoriaMapaOperacaoModel(new List<List<GPSModel>>());
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento = new OperacaoSensoriamentoLogModel();
|
|
RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.AtualizarDados();
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
private Dictionary<string, (bool, bool)> PreencherComponentesEmUso(T_Code Modulo)
|
|
{
|
|
Dictionary<string, (bool, bool)> d = new Dictionary<string, (bool, bool)>();
|
|
switch (Modulo)
|
|
{
|
|
case T_Code.Mov:
|
|
if (Variaveis.OperacaoEmAndamento.DispMvd != null)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos?.ForEach(m => d.Add(m.MovMotor.Mod_ID, (true, m.MovMotor.Comandar)));
|
|
}
|
|
break;
|
|
case T_Code.Dir:
|
|
if (Variaveis.OperacaoEmAndamento.DispMvd != null)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos?.ForEach(m => d.Add(m.DirMotor.Mod_ID, (true, m.DirMotor.Comandar)));
|
|
}
|
|
break;
|
|
case T_Code.Atu:
|
|
if (Variaveis.OperacaoEmAndamento.DispAtu != null)
|
|
{
|
|
var da = Variaveis.OperacaoEmAndamento.DispAtu.Dados;
|
|
da.Sensores?.ForEach(s => d.Add(s.ID, (s.Mandatorio, s.Aferir)));
|
|
da.BombasPressurizadoras?.ForEach(b => d.Add(b.ID, (b.Mandatorio, b.Comandar)));
|
|
da.BicosPulverizadores?.ForEach(b => d.Add(b.ID, (b.Mandatorio, b.Comandar)));
|
|
da.Servos?.ForEach(s => d.Add(s.ID, (s.Mandatorio, s.Controlar)));
|
|
}
|
|
break;
|
|
case T_Code.Sen:
|
|
if (Variaveis.OperacaoEmAndamento.DispSen != null)
|
|
{
|
|
var ds = Variaveis.OperacaoEmAndamento.DispSen.Dados;
|
|
ds.Sensores?.ForEach(s => d.Add(s.ID, (s.Mandatorio, s.Aferir)));
|
|
ds.Sinaleiros?.ForEach(s => d.Add(s.ID, (s.Mandatorio, s.Controlar)));
|
|
ds.Servos?.ForEach(s => d.Add(s.ID, (s.Mandatorio, s.Controlar)));
|
|
ds.Reles?.ForEach(r => d.Add(r.ID, (r.Mandatorio, r.Controlar)));
|
|
}
|
|
break;
|
|
}
|
|
return d;
|
|
}
|
|
|
|
private void DefinirComponentesEmUso()
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios.ForEach(m =>
|
|
{
|
|
switch (m.Dispositivo)
|
|
{
|
|
case T_Code.Mov:
|
|
foreach (var c in m.ComponentesEmUso)
|
|
{
|
|
var d = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.FirstOrDefault(x => x.MovMotor.Mod_ID == c.Key).MovMotor;
|
|
d.Comandar = c.Value.Item2;
|
|
}
|
|
break;
|
|
case T_Code.Dir:
|
|
foreach (var c in m.ComponentesEmUso)
|
|
{
|
|
var d = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.FirstOrDefault(x => x.DirMotor.Mod_ID == c.Key).DirMotor;
|
|
d.Comandar = c.Value.Item2;
|
|
}
|
|
break;
|
|
case T_Code.Atu:
|
|
var da = Variaveis.OperacaoEmAndamento.DispAtu.Dados;
|
|
foreach (var c in m.ComponentesEmUso)
|
|
{
|
|
var s = da.Sensores.FirstOrDefault(x => x.ID == c.Key);
|
|
if (s != null)
|
|
{
|
|
s.Mandatorio = c.Value.Item1;
|
|
s.Aferir = c.Value.Item2;
|
|
continue;
|
|
}
|
|
var bc = da.BicosPulverizadores.FirstOrDefault(x => x.ID == c.Key);
|
|
if (bc != null)
|
|
{
|
|
bc.Mandatorio = c.Value.Item1;
|
|
bc.Comandar = c.Value.Item2;
|
|
continue;
|
|
}
|
|
var bo = da.BombasPressurizadoras.FirstOrDefault(x => x.ID == c.Key);
|
|
if (bo != null)
|
|
{
|
|
bo.Mandatorio = c.Value.Item1;
|
|
bo.Comandar = c.Value.Item2;
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
case T_Code.Sen:
|
|
var ds = Variaveis.OperacaoEmAndamento.DispSen.Dados;
|
|
foreach (var c in m.ComponentesEmUso)
|
|
{
|
|
var s = ds.Sensores.FirstOrDefault(x => x.ID == c.Key);
|
|
if (s != null)
|
|
{
|
|
s.Mandatorio = c.Value.Item1;
|
|
s.Aferir = c.Value.Item2;
|
|
continue;
|
|
}
|
|
var sv = ds.Servos.FirstOrDefault(x => x.ID == c.Key);
|
|
if (sv != null)
|
|
{
|
|
sv.Mandatorio = c.Value.Item1;
|
|
sv.Controlar = c.Value.Item2;
|
|
continue;
|
|
}
|
|
var rl = ds.Reles.FirstOrDefault(x => x.ID == c.Key);
|
|
if (rl != null)
|
|
{
|
|
rl.Mandatorio = c.Value.Item1;
|
|
rl.Controlar = c.Value.Item2;
|
|
continue;
|
|
}
|
|
var ld = ds.Sinaleiros.FirstOrDefault(x => x.ID == c.Key);
|
|
if (ld != null)
|
|
{
|
|
ld.Mandatorio = c.Value.Item1;
|
|
ld.Controlar = c.Value.Item2;
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
|
|
public (bool, List<string>) CarregarParamerosOperacaoBase(OperacaoParametrosModel Parametros)
|
|
{
|
|
if (Parametros.Modo == null) return (false, new List<string>());
|
|
|
|
CarregarParametrosOperacaoPadrao((ModoOperacao)Parametros.Modo, true);
|
|
|
|
Variaveis.OperacaoEmAndamento.Parametros = Parametros;
|
|
Variaveis.OperacaoEmAndamento.Parametros.RoverId = VariaveisEquipamento.Parametros.serial_number;
|
|
Variaveis.OperacaoEmAndamento.Parametros.DadosLeitura = new OperacaoParametrosDadosModel();
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.AtualizarDados();
|
|
Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios.ForEach(m => m.ComponentesEmUso = Variaveis.OperacaoEmAndamento.PreencherComponentesEmUso(m.Dispositivo));
|
|
Variaveis.OperacaoEmAndamento.DefinirComponentesEmUso();
|
|
|
|
Variaveis.OperacaoEmAndamento.Descricao = Parametros.Descricao;
|
|
Variaveis.OperacaoEmAndamento.OprPath = $"Base ({VariaveisEquipamento.Parametros.base_ip})";
|
|
|
|
List<string> ruasSelecionadas = Parametros.RuasPercorrer ?? new List<string>();
|
|
if (Parametros.Mapa != null)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Mapa = new MapasModel() { RuasPercorrer = ruasSelecionadas };
|
|
Variaveis.OperacaoEmAndamento.Mapa.PopularTrajetoriaMapa(Parametros.Mapa);
|
|
}
|
|
|
|
RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));
|
|
|
|
return (true, ruasSelecionadas);
|
|
}
|
|
|
|
|
|
public async Task IniciarOperacao()
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.UltimoRegistroLog = DateTime.Now;
|
|
tmrLogs?.Start();
|
|
|
|
Iniciado = true;
|
|
Simulando = false;
|
|
Treinando = false;
|
|
Emergencia = false;
|
|
Pausa = false;
|
|
DataInicio = DateTime.Now;
|
|
DataFim = DateTime.MinValue;
|
|
idxLog = 0;
|
|
|
|
ID = DataInicio.ToString("dd_MM_yyyy_HH_mm_ss") + "_" + Modo.ToString();
|
|
Directory.CreateDirectory(Variaveis.CaminhoOperacoes + ID + "/");
|
|
|
|
SalvarOperacao();
|
|
|
|
Sensoriamento.AtualizarDados();
|
|
|
|
DispMvd?.Dados?.ReiniciarLeituras(DispMvd?.Dados);
|
|
DispAtu?.Dados?.ReiniciarLeituras(DispAtu?.Dados);
|
|
DispSen?.Dados?.ReiniciarLeituras(DispSen?.Dados);
|
|
|
|
ModsCalibragem = new Dictionary<T_Code, Dictionary<string, bool>>()
|
|
{
|
|
{ T_Code.Mov, new Dictionary<string, bool>() { } },
|
|
{ T_Code.Dir, new Dictionary<string, bool>() { } },
|
|
{ T_Code.Atu, new Dictionary<string, bool>() { } },
|
|
};
|
|
|
|
RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));
|
|
WeedWorkerService.ReiniciarLeituraAnalise();
|
|
VisualWorkerService.ReiniciarLeituraAnalise();
|
|
|
|
Controle.Reiniciar();
|
|
ControleAnterior.Reiniciar();
|
|
|
|
GPSTrajetoria = new List<GPSModel>();
|
|
|
|
Trajetoria?.ProjetarTrajetoriaFixa();
|
|
RedisService.Publish(CmdKey.ManagerWorkerRx, JsonConvert.SerializeObject(new { cmd = ManagerWorkerCommandType.IniciarMPC }));
|
|
|
|
await RealizarCalibragemInicialAsync(true);
|
|
}
|
|
|
|
public async Task FinalizarOperacao()
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.Finalizando)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.Finalizando = true;
|
|
|
|
Variaveis.OperacaoEmAndamento.Trajetoria?.LoopAtualizaDados();
|
|
|
|
await Task.Delay(2000);
|
|
|
|
Variaveis.OperacaoEmAndamento.Iniciado = false;
|
|
Variaveis.OperacaoEmAndamento.Emergencia = false;
|
|
Variaveis.OperacaoEmAndamento.Pausa = false;
|
|
|
|
Variaveis.OperacaoEmAndamento.DataFim = DateTime.Now;
|
|
|
|
tmrLogs?.Stop();
|
|
|
|
SalvarLogs(false);
|
|
|
|
Variaveis.OperacaoEmAndamento.Finalizando = false;
|
|
Variaveis.OperacaoEmAndamento.Trajetoria?.AutonomiaCorredor?.Parar();
|
|
}
|
|
|
|
public async Task RealizarCalibragemInicialAsync(bool forcar)
|
|
{
|
|
bool modsCalibrados = Variaveis.OperacaoEmAndamento.ModsCalibragem.All(x => x.Value.Values.Count > 0 && x.Value.Values.All(y => y == true));
|
|
if (!forcar && modsCalibrados) return;
|
|
|
|
var DispAtu = Variaveis.OperacaoEmAndamento.DispAtu;
|
|
var DispMvd = Variaveis.OperacaoEmAndamento.DispMvd;
|
|
List<StatusModulo> sv = new List<StatusModulo>() { StatusModulo.Operante, StatusModulo.Alerta };
|
|
var s = HealthWorkerService.ModulosSaude;
|
|
var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle;
|
|
var _Controle = Variaveis.OperacaoEmAndamento.Controle;
|
|
|
|
bool calibragemAtuNecessaria = pControle.PulverizadorAutomatico && (DispAtu?.Dados != null && sv.Contains(s.FirstOrDefault(x => x.modulo == T_Code.Atu)?.status ?? StatusModulo.Desconectado) && (forcar || Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Atu].Any(x => !x.Value) || !Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Atu].Any()));
|
|
bool calibragemDirNecessaria = (DispMvd?.Dados != null && sv.Contains(s.FirstOrDefault(x => x.modulo == T_Code.Dir)?.status ?? StatusModulo.Desconectado) && (forcar || Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Dir].Any(x => !x.Value) || !Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Dir].Any()));
|
|
bool calibragemMovNecessaria = (DispMvd?.Dados != null && sv.Contains(s.FirstOrDefault(x => x.modulo == T_Code.Mov)?.status ?? StatusModulo.Desconectado) && (forcar || Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Mov].Any(x => !x.Value) || !Variaveis.OperacaoEmAndamento.ModsCalibragem[T_Code.Mov].Any()));
|
|
calibragemDirNecessaria = false;
|
|
|
|
if (!calibragemAtuNecessaria && !calibragemDirNecessaria && !calibragemMovNecessaria) return;
|
|
|
|
Console.WriteLine("Pausa para calibragem inicial");
|
|
Variaveis.OperacaoEmAndamento.Pausa = true;
|
|
await Task.Delay(5000);
|
|
|
|
Console.WriteLine("Calibragem dos modulos inciada...");
|
|
Variaveis.OperacaoEmAndamento.Calibrando = true;
|
|
RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("calibrando", Variaveis.OperacaoEmAndamento.Calibrando));
|
|
|
|
TipoMovimentoDirecional tipoControle = _Controle.TipoMovimento;
|
|
|
|
var tasks = new List<Task>();
|
|
|
|
if (calibragemAtuNecessaria) tasks.AddRange(DispAtu.Dados.RealizarCalibragemAsync(forcar));
|
|
if (calibragemDirNecessaria) tasks.AddRange(DispMvd.Dados.RealizarCalibragemDirAsync(forcar));
|
|
if (calibragemMovNecessaria) tasks.AddRange(DispMvd.Dados.RealizarCalibragemMovAsync(forcar));
|
|
|
|
if (tasks.Count == 0)
|
|
{
|
|
Console.WriteLine("Nenhuma calibragem foi iniciada.");
|
|
_Controle.TipoMovimento = tipoControle;
|
|
Variaveis.OperacaoEmAndamento.Calibrando = false;
|
|
Variaveis.OperacaoEmAndamento.Pausa = false;
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
var allTasks = Task.WhenAll(tasks);
|
|
var completed = await Task.WhenAny(allTasks, Task.Delay(2 * 60 * 1000));
|
|
|
|
if (completed == allTasks)
|
|
{
|
|
Console.WriteLine("Calibragem finalizada com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("Timeout na calibragem. Continuando mesmo assim.");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"Erro durante calibragem: {ex.Message}");
|
|
}
|
|
_Controle.TipoMovimento = tipoControle;
|
|
Variaveis.OperacaoEmAndamento.Calibrando = false;
|
|
Variaveis.OperacaoEmAndamento.Pausa = false;
|
|
RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("calibrando", Variaveis.OperacaoEmAndamento.Calibrando));
|
|
}
|
|
|
|
|
|
public async Task IniciarSimulacao()
|
|
{
|
|
Iniciado = true;
|
|
Simulando = true;
|
|
Treinando = false;
|
|
DataInicio = DateTime.Now;
|
|
DataFim = DateTime.MinValue;
|
|
|
|
ID = "";
|
|
|
|
Sensoriamento.AtualizarDados();
|
|
|
|
DispMvd?.Dados?.ReiniciarLeituras(DispMvd.Dados);
|
|
DispAtu?.Dados?.ReiniciarLeituras(DispAtu.Dados);
|
|
DispSen?.Dados?.ReiniciarLeituras(DispSen.Dados);
|
|
|
|
RedisService.AtualizarCampos(CtxKey.DadosOperacao, ("configurado", false));
|
|
WeedWorkerService.ReiniciarLeituraAnalise();
|
|
VisualWorkerService.ReiniciarLeituraAnalise();
|
|
|
|
Controle.Reiniciar();
|
|
ControleAnterior.Reiniciar();
|
|
|
|
GPSTrajetoria = new List<GPSModel>();
|
|
|
|
Trajetoria?.ProjetarTrajetoriaFixa();
|
|
RedisService.Publish(CmdKey.ManagerWorkerRx, JsonConvert.SerializeObject(new { cmd = ManagerWorkerCommandType.IniciarMPC }));
|
|
}
|
|
|
|
public void ReiniciarSimulacao()
|
|
{
|
|
RedisService.AtualizarCampos(
|
|
CtxKey.DadosOperacao,
|
|
("status", StatusOperacao.Parametrizando),
|
|
("iniciado", false)
|
|
);
|
|
|
|
Variaveis.OperacaoEmAndamento.Iniciado = false;
|
|
Variaveis.OperacaoEmAndamento.Simulando = false;
|
|
Variaveis.OperacaoEmAndamento.Mapa = new MapasModel();
|
|
Variaveis.OperacaoEmAndamento.Trajetoria = new TrajetoriaMapaOperacaoModel(new List<List<GPSModel>>());
|
|
Variaveis.OperacaoEmAndamento.GPSTrajetoria = new List<GPSModel>();
|
|
|
|
var Topico = Variaveis.MqttServiceLocal.Topicos.FirstOrDefault(x => x.Topico == MapasVariaveisModel.TopicoSelecaoRuasMapa);
|
|
Topico.Mensagens.Add(new MqttService.MqttTopicosMensagensModel()
|
|
{
|
|
Mensagem = "[]",
|
|
Momento = DateTime.Now
|
|
});
|
|
}
|
|
|
|
|
|
public void IniciarTreinamento()
|
|
{
|
|
Iniciado = true;
|
|
Treinando = true;
|
|
DataInicio = DateTime.Now;
|
|
DataFim = DateTime.MinValue;
|
|
|
|
ID = "";
|
|
|
|
if (DispMvd != null)
|
|
{
|
|
DispMvd.Dados.ReiniciarLeituras(DispMvd.Dados);
|
|
}
|
|
if (DispAtu != null)
|
|
{
|
|
DispAtu.Dados.ReiniciarLeituras(DispAtu.Dados);
|
|
}
|
|
if (DispSen != null)
|
|
{
|
|
DispSen.Dados.ReiniciarLeituras(DispSen.Dados);
|
|
}
|
|
|
|
Controle.Angulo = 0;
|
|
Controle.PercentualVelocidadeSP = 0;
|
|
|
|
GPSTrajetoria = new List<GPSModel>();
|
|
}
|
|
|
|
|
|
public static string DeserializarDadosOperacao(string caminho, string arquivo)
|
|
{
|
|
string opPath = caminho.Replace("data.lgop", arquivo) + ".json";
|
|
string opStr = "";
|
|
if (File.Exists(opPath))
|
|
opStr = File.ReadAllText(opPath);
|
|
else
|
|
opStr = "[";
|
|
if (opStr != "" && !opStr.EndsWith("]"))
|
|
{
|
|
opStr += "]";
|
|
}
|
|
return opStr;
|
|
}
|
|
|
|
private void SalvarOperacao()
|
|
{
|
|
if (string.IsNullOrEmpty(Variaveis.OperacaoEmAndamento.OprPath)) return;
|
|
|
|
var Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID;
|
|
if (!Directory.Exists(Caminho))
|
|
{
|
|
Directory.CreateDirectory(Caminho);
|
|
}
|
|
|
|
Caminho += "/operacao.opr";
|
|
File.Copy(Variaveis.OperacaoEmAndamento.OprPath, Caminho);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region CONTROLE DA OPERACAO
|
|
|
|
public void AtualizaInformacoesControleOperacao()
|
|
{
|
|
var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle;
|
|
if (pControle.MovimentoAutomatico)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.AtualizarDadosControle(false, new List<T_Code>() { T_Code.Mov });
|
|
}
|
|
if (pControle.DirecionalAutomatico)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.AtualizarDadosControle(false, new List<T_Code>() { T_Code.Dir });
|
|
}
|
|
if (pControle.PulverizadorAutomatico)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.AtualizarDadosControle(false, new List<T_Code>() { T_Code.Atu });
|
|
}
|
|
}
|
|
|
|
public void AtualizarDadosControle(bool ForcarEnvio, List<T_Code> Dispositivos)
|
|
{
|
|
DateTime Agora = DateTime.Now;
|
|
|
|
var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle;
|
|
var _Controle = Variaveis.OperacaoEmAndamento.Controle;
|
|
var mm = Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios;
|
|
|
|
foreach (var Ctrl in _Controle.TiposControle.Where(x => Dispositivos.Contains(x.Tipo)))
|
|
{
|
|
if (!ForcarEnvio)
|
|
{
|
|
if (mm.Any(x => x.Dispositivo == Ctrl.Tipo && !x.Utilizar))
|
|
continue;
|
|
if (Ctrl.Tipo == T_Code.Atu && !pControle.PulverizadorAutomatico)
|
|
continue;
|
|
if (Ctrl.Tipo == T_Code.Mov && !pControle.MovimentoAutomatico)
|
|
continue;
|
|
if (Ctrl.Tipo == T_Code.Dir && !pControle.DirecionalAutomatico)
|
|
continue;
|
|
}
|
|
|
|
if (ForcarEnvio || ((Agora - Ctrl.UltimoComando).TotalMilliseconds > Ctrl.DelayEnvioComando))
|
|
{
|
|
var Protocolos = EnviarProtocoloComando(Ctrl.Tipo, ForcarEnvio);
|
|
Ctrl.UltimoComando = Agora;
|
|
Ctrl.DelayEnvioComando = Ctrl.DelayEnvioComandoBase + Ctrl.DelayEnvioComandoExtra;
|
|
Ctrl.DelayEnvioComandoExtra = 0;
|
|
Ctrl.Comandos.AddRange(Protocolos);
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<string> EnviarProtocoloComando(T_Code Tipo, bool ForcarEnvio)
|
|
{
|
|
if (!Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
return new List<string>();
|
|
}
|
|
|
|
List<string> Protocolos = new List<string>();
|
|
|
|
var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle;
|
|
var _Controle = Variaveis.OperacaoEmAndamento.Controle;
|
|
var _ControleAnterior = Variaveis.OperacaoEmAndamento.ControleAnterior;
|
|
|
|
switch (Tipo)
|
|
{
|
|
case T_Code.Mov:
|
|
{
|
|
if (pControle.FrenagemAutomaticaAoParar && _Controle.EmFreio)
|
|
{
|
|
_Controle.Direcao = Direcao.EmFreio;
|
|
}
|
|
else if (_Controle.RPM_SP == 0)
|
|
{
|
|
_Controle.Direcao = Direcao.Parado;
|
|
}
|
|
else if (_Controle.RPM_SP < 0)
|
|
{
|
|
_Controle.PercentualVelocidadeSP *= -1;
|
|
_Controle.Direcao = Direcao.Tras;
|
|
}
|
|
else if (_Controle.RPM_SP > 0)
|
|
{
|
|
_Controle.Direcao = Direcao.Frente;
|
|
}
|
|
|
|
var modsAtualizar = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Where(Mod => Mod.MovMotor.NovoRPMNecessario).Select(x => x.Modulo_ID).ToList();
|
|
bool envioNecessario = ForcarEnvio || _Controle.RPM_SP != _ControleAnterior.RPM_SP;
|
|
if (envioNecessario || modsAtualizar.Any())
|
|
{
|
|
foreach (var Mod in Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Where(x => envioNecessario ? true : modsAtualizar.Contains(x.Modulo_ID)))
|
|
{
|
|
Mod.MovMotor.EnviarComandoControle(_Controle.Direcao);
|
|
}
|
|
|
|
_Controle.TiposControle.FirstOrDefault(x => x.Tipo == Tipo).UltimaDirecao = _Controle.Direcao;
|
|
}
|
|
|
|
_ControleAnterior.PercentualVelocidadeSP = _Controle.PercentualVelocidadeSP;
|
|
_ControleAnterior.Direcao = _Controle.Direcao;
|
|
_ControleAnterior.EmFreio = _Controle.EmFreio;
|
|
|
|
RedisService.AtualizarCampos(
|
|
CtxKey.DadosControle,
|
|
("velocidade_sp_ant", _Controle.PercentualVelocidadeSP)
|
|
);
|
|
|
|
Protocolos = new List<string>()
|
|
{
|
|
_Controle.Direcao.ToString() + ";" + _Controle.RPM_SP.ToString() + ";" + (ForcarEnvio ? "1": "0")
|
|
};
|
|
break;
|
|
}
|
|
case T_Code.Dir:
|
|
{
|
|
if (_Controle.Angulo > 0)
|
|
{
|
|
_Controle.Direcao = Direcao.Direita;
|
|
}
|
|
else if (_Controle.Angulo < 0)
|
|
{
|
|
_Controle.Direcao = Direcao.Esquerda;
|
|
}
|
|
else
|
|
{
|
|
_Controle.Direcao = Direcao.Parado;
|
|
}
|
|
|
|
bool envioNecessario = ForcarEnvio || _Controle.Angulo != _ControleAnterior.Angulo || _Controle.TipoMovimento != _ControleAnterior.TipoMovimento;
|
|
var modsAtualizar = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Where(Mod => !Mod.DirMotor.AtingiuAnguloSP).Select(x => x.Modulo_ID).ToList();
|
|
if (!MKS057DCanService.Referenciando && (envioNecessario || modsAtualizar.Any()))
|
|
{
|
|
foreach (var Mod in Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Where(x => envioNecessario ? true : modsAtualizar.Contains(x.Modulo_ID)))
|
|
{
|
|
Mod.DirMotor.EnviarComandoControle(_Controle.Direcao);
|
|
}
|
|
|
|
_Controle.TiposControle.FirstOrDefault(x => x.Tipo == Tipo).UltimaDirecao = _Controle.Direcao;
|
|
}
|
|
|
|
_ControleAnterior.Angulo = _Controle.Angulo;
|
|
_ControleAnterior.Direcao = _Controle.Direcao;
|
|
|
|
RedisService.AtualizarCampos(
|
|
CtxKey.DadosControle,
|
|
("angulo_sp_ant", _Controle.Angulo),
|
|
("tipo_movimento_direcional_ant", _Controle.TipoMovimento)
|
|
);
|
|
|
|
Protocolos = new List<string>()
|
|
{
|
|
_Controle.Direcao.ToString() + ";" + _Controle.Angulo.ToString() + ";" + _Controle.TipoMovimento.ToString() + ";" + (ForcarEnvio ? "1": "0")
|
|
};
|
|
break;
|
|
}
|
|
case T_Code.Atu:
|
|
{
|
|
bool enviarComando = false;
|
|
for (int i = 0; i < _Controle.Bicos.Count; i++)
|
|
{
|
|
Estado comandoEstado = _Controle.Bicos[i].ComandoAtuar ? Estado.Ligado : Estado.Desligado;
|
|
if (ForcarEnvio || comandoEstado != _Controle.Bicos[i]._EstadoLeitura)
|
|
{
|
|
GeneralJoystick.EnviarComandoAtuador(_Controle.Bicos[i].Componente, _Controle.Bicos[i].ID, Status: _Controle.Bicos[i].ComandoAtuar);
|
|
enviarComando = true;
|
|
}
|
|
}
|
|
|
|
// Ligar a bomba caso esteja desligada e tenha herbicida suficiente no reservatorio
|
|
if ((Variaveis.OperacaoEmAndamento.DispAtu?.Dados?.ContadorCarga?.PulverizadorLiberado ?? false) && enviarComando)
|
|
{
|
|
foreach (var Bomba in Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombasPressurizadoras)
|
|
{
|
|
if (Bomba._EstadoLeitura == Estado.Desligado)
|
|
{
|
|
GeneralJoystick.EnviarComandoAtuador(Bomba.Componente, Bomba.ID, Status: true);
|
|
}
|
|
}
|
|
}
|
|
|
|
Protocolos = new List<string>()
|
|
{
|
|
string.Join(";", _Controle.Bicos.Select(x => x.ComandoAtuar ? "1" : "0")) + ";" + (ForcarEnvio ? "1": "0")
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
|
|
return Protocolos;
|
|
}
|
|
|
|
private async Task tmrLeituras_Tick()
|
|
{
|
|
if (Variaveis.IsAgroMonitor)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.AtualizarDados();
|
|
//Variaveis.LoraService?.EnviarDadosParaBase();
|
|
|
|
if (Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.Manual)
|
|
{
|
|
var Sonar = Variaveis.OperacaoEmAndamento.Sensoriamento.OperadorVisual;
|
|
Sonar?.Resumo?.AtualizarStatusBloqueio(true);
|
|
if (Sonar?.Resumo?.EnviarComandoParada ?? false)
|
|
{
|
|
GeneralJoystick.EnviaComandoMotor(Keys.Space, T_Code.Mov);
|
|
}
|
|
else if (Sonar?.Resumo?.EnviarComandoRetomada ?? false)
|
|
{
|
|
GeneralJoystick.EnviaComandoMotor(Keys.Escape, T_Code.Mov);
|
|
}
|
|
|
|
if (!Variaveis.OperacaoEmAndamento.OperacaoLiberada)
|
|
{
|
|
if ((Variaveis.OperacaoEmAndamento.Controle.TiposControle.FirstOrDefault(x => x.Tipo == T_Code.Mov)?.UltimaDirecao ?? Direcao.Parado) != Direcao.Parado)
|
|
{
|
|
GeneralJoystick.EnviaComandoMotor(Keys.Escape, T_Code.Mov, ForcarComando: true);
|
|
}
|
|
if ((Variaveis.OperacaoEmAndamento.Controle.TiposControle.FirstOrDefault(x => x.Tipo == T_Code.Dir)?.UltimaDirecao ?? Direcao.Parado) != Direcao.Parado)
|
|
{
|
|
GeneralJoystick.EnviaComandoMotor(Keys.Escape, T_Code.Dir, ForcarComando: true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ExecutaComandoDaBase(OperacaoComandoBaseModel controleBase)
|
|
{
|
|
if (controleBase.Dispositivo == T_Code.Mod)
|
|
{
|
|
var _Parametros = controleBase.Parametros;
|
|
|
|
switch (controleBase.Tecla)
|
|
{
|
|
case BotoesJoystick.Share: // Requisitar parametros da operacao
|
|
var topico = Variaveis.MqttServiceBase.Topicos.FirstOrDefault(x => x.Topico == VariaveisEquipamento.TopicoMqttParametros.Replace("<id>", VariaveisEquipamento.Parametros.serial_number));
|
|
string msg = JsonConvert.SerializeObject(Variaveis.OperacaoEmAndamento.Parametros);
|
|
Task.Run(async () => await Variaveis.MqttServiceBase.PublishAsync(topico, msg));
|
|
break;
|
|
case BotoesJoystick.Options: // Operacao nao iniciada, carrega todos os parametros compeltos
|
|
Variaveis.OperacaoEmAndamento.CarregarParamerosOperacaoBase(_Parametros);
|
|
break;
|
|
case BotoesJoystick.Touchpad: // Operacao em andamento, atualiza apenas os dados de controle
|
|
if (_Parametros.Modo != null) Variaveis.OperacaoEmAndamento.Parametros.Modo = _Parametros.Modo;
|
|
if (_Parametros.QtdBicos != null) Variaveis.OperacaoEmAndamento.Parametros.QtdBicos = _Parametros.QtdBicos;
|
|
if (_Parametros.Descricao != null) Variaveis.OperacaoEmAndamento.Parametros.Descricao = _Parametros.Descricao;
|
|
if (_Parametros.QtdCamerasSolo != null) Variaveis.OperacaoEmAndamento.Parametros.QtdCamerasSolo = _Parametros.QtdCamerasSolo;
|
|
if (_Parametros.CapacidadeReservatorio != null) Variaveis.OperacaoEmAndamento.Parametros.CapacidadeReservatorio = _Parametros.CapacidadeReservatorio;
|
|
|
|
if (_Parametros.Controle != null) Variaveis.OperacaoEmAndamento.Parametros.Controle = _Parametros.Controle;
|
|
if (_Parametros.ParametrosMandatorios != null) Variaveis.OperacaoEmAndamento.Parametros.ParametrosMandatorios = _Parametros.ParametrosMandatorios;
|
|
if (_Parametros.ModulosMandatorios != null)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios = _Parametros.ModulosMandatorios;
|
|
Variaveis.OperacaoEmAndamento.DefinirComponentesEmUso();
|
|
}
|
|
|
|
HealthWorkerService.AtualizarDadosOperacao(true);
|
|
break;
|
|
case BotoesJoystick.L1: // Inicia o modo simulador
|
|
if (!Variaveis.OperacaoEmAndamento.Iniciado)
|
|
Task.Run(async () => await Variaveis.OperacaoEmAndamento.IniciarSimulacao());
|
|
break;
|
|
case BotoesJoystick.L2: // Inicia a operacao
|
|
if (!Variaveis.OperacaoEmAndamento.Iniciado)
|
|
Task.Run(async () => await Variaveis.OperacaoEmAndamento.IniciarOperacao());
|
|
break;
|
|
case BotoesJoystick.L3: // Finaliza a operacao
|
|
if (Variaveis.OperacaoEmAndamento.Iniciado)
|
|
Task.Run(async () => await Variaveis.OperacaoEmAndamento.FinalizarOperacao());
|
|
break;
|
|
case BotoesJoystick.R1: // Libera a operacao interrompida mediante supervisao humana
|
|
if (!(Variaveis.OperacaoEmAndamento.Trajetoria?.AutonomiaCorredor?.Liberado ?? false))
|
|
{
|
|
var (idx_corredor, b_liberada, h_liberado) = ((JObject)controleBase._comp_value).ToObject<(int, bool, bool)>();
|
|
Variaveis.OperacaoEmAndamento.Trajetoria?.AtualizarDadosAutonomiaCorredor(idxCorredor: idx_corredor, bat_liberada: b_liberada, herb_liberado: h_liberado);
|
|
}
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (controleBase.Dispositivo == T_Code.Ipb)
|
|
{
|
|
if (controleBase._comp_value == true)
|
|
{
|
|
Variaveis.IniciarUDP();
|
|
}
|
|
else
|
|
{
|
|
Variaveis.StopUdpChannel();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (controleBase.Dispositivo == T_Code.Gps)
|
|
{
|
|
var (la_frontal, la_lateral) = ((JObject)controleBase._comp_value).ToObject<(double?, double?)>();
|
|
if (la_frontal != null) VariaveisEquipamento.LeverArmFrontal = (double)la_frontal;
|
|
if (la_lateral != null) VariaveisEquipamento.LeverArmLateral = (double)la_lateral;
|
|
GPSService.UltimaLeitura.LeverArmFrontal = VariaveisEquipamento.LeverArmFrontal;
|
|
GPSService.UltimaLeitura.LeverArmLateral = VariaveisEquipamento.LeverArmLateral;
|
|
if (la_lateral != null || la_frontal != null)
|
|
GPSService.LeverArm = new GeoLeverArm(VariaveisEquipamento.LeverArmFrontal, VariaveisEquipamento.LeverArmLateral);
|
|
return;
|
|
}
|
|
|
|
if (controleBase.Dispositivo == T_Code.Snr && Variaveis.OperacaoEmAndamento.DispSen?.Dados?.CameraCaminho?.Id != null)
|
|
{
|
|
RedisService.AtualizarCampos(
|
|
RedisService.CamKey(Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraCaminho.Id),
|
|
("streaming", controleBase.Tecla == BotoesJoystick.L1),
|
|
("frame_type", (TipoFrameCamera)controleBase._comp_value)
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (controleBase.Dispositivo == T_Code.Cam && (Variaveis.OperacaoEmAndamento.DispSen?.Dados?.CamerasSolo?.Any(x => !string.IsNullOrEmpty(x.Id)) ?? false))
|
|
{
|
|
RedisService.AtualizarCampos(
|
|
RedisService.CamKey(Variaveis.OperacaoEmAndamento.DispSen.Dados.CamerasSolo.FirstOrDefault(x => !string.IsNullOrEmpty(x.Id)).Id),
|
|
("streaming", controleBase.Tecla == BotoesJoystick.L1),
|
|
("frame_type", (TipoFrameCamera)controleBase._comp_value)
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (controleBase.Dispositivo == T_Code.Atu && Variaveis.OperacaoEmAndamento.DispAtu != null)
|
|
{
|
|
if (controleBase.Controle == null) return;
|
|
|
|
S_Code get_comp(string id)
|
|
{
|
|
if (string.IsNullOrEmpty(id)) return S_Code.sMOD;
|
|
var d_atu = Variaveis.OperacaoEmAndamento.DispAtu.Dados;
|
|
if (d_atu.BicosPulverizadores.Any(x => x.ID == id)) return S_Code.sBIC;
|
|
if (d_atu.BombasPressurizadoras.Any(x => x.ID == id)) return S_Code.sBMB;
|
|
if (d_atu.Sensores.Any(x => x.ID == id)) return d_atu.Sensores.First(x => x.ID == id).Componente;
|
|
if (d_atu.Servos.Any(x => x.ID == id)) return S_Code.sSRV;
|
|
return S_Code.sVZO;
|
|
}
|
|
|
|
S_Code comp = get_comp(controleBase._comp_id);
|
|
|
|
switch (comp)
|
|
{
|
|
case S_Code.sMOD:
|
|
if (controleBase.Controle.Altura != null) Variaveis.OperacaoEmAndamento.Controle.AlturaBarra = (double)controleBase.Controle.Altura;
|
|
break;
|
|
case S_Code.sBIC:
|
|
if (controleBase._comp_value != null)
|
|
{
|
|
var bico = Variaveis.OperacaoEmAndamento.Controle.Bicos.FirstOrDefault(x => x.ID == controleBase._comp_id);
|
|
if (bico != null)
|
|
{
|
|
bico.AnguloAbertura = (int)controleBase._comp_value;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
GeneralJoystick.EnviarComandoAtuador(comp, controleBase._comp_id, Status: controleBase.Controle.Estado, Valor: controleBase.Controle.AnguloSP, Forcar: true);
|
|
return;
|
|
}
|
|
|
|
if (controleBase.Dispositivo == T_Code.Sen && Variaveis.OperacaoEmAndamento.DispSen != null)
|
|
{
|
|
S_Code get_comp(string id)
|
|
{
|
|
if (string.IsNullOrEmpty(id)) return S_Code.sMOD;
|
|
var d_sen = Variaveis.OperacaoEmAndamento.DispSen.Dados;
|
|
if (d_sen.Reles.Any(x => x.ID == id)) return S_Code.sRLE;
|
|
if (d_sen.Servos.Any(x => x.ID == id)) return S_Code.sSRV;
|
|
if (d_sen.Sinaleiros.Any(x => x.ID == id)) return S_Code.sLED;
|
|
if (d_sen.Sensores.Any(x => x.ID == id)) return d_sen.Sensores.First(x => x.ID == id).Componente;
|
|
return S_Code.sVZO;
|
|
}
|
|
|
|
S_Code comp = get_comp(controleBase._comp_id);
|
|
GeneralJoystick.EnviarComandoSensoriamento(comp, controleBase._comp_id, controleBase._comp_value, Forcar: true);
|
|
return;
|
|
}
|
|
|
|
if (controleBase.Dispositivo == T_Code.Dir && controleBase.Tecla == BotoesJoystick.R3)
|
|
{
|
|
GeneralJoystick.EnviaComandoMotor(Keys.R, ForcarComando: true, ID: controleBase._comp_id);
|
|
return;
|
|
}
|
|
|
|
if (controleBase.Dispositivo == T_Code.Npc)
|
|
{
|
|
var (modo, e_entrada, e_saida, t_ligar, t_turbo) = ((JObject)controleBase._comp_value).ToObject<(CoolerControlService.CoolerMode, Estado?, Estado?, double?, double?)>();
|
|
Variaveis.OperacaoEmAndamento.DispSen?.Dados?.CoolerControl?.AlterarControle(modo, entrada: e_entrada, saida: e_saida, tempOn: t_ligar, tempTurbo: t_turbo);
|
|
return;
|
|
}
|
|
|
|
if (controleBase.Dispositivo == T_Code.Trj)
|
|
{
|
|
var (lat, lon, pontosRetorno) = ((JObject)controleBase._comp_value).ToObject<(double?, double?, List<double[]>)>();
|
|
if (lat == null || lon == null) return;
|
|
GPSModel posicaoBase = new GPSModel() { Latitude = lat.Value, Longitude = lon.Value };
|
|
List<GPSModel> pontosRetornoPos = null;
|
|
if (pontosRetorno?.Any() ?? false)
|
|
pontosRetornoPos = pontosRetorno.Select(x => new GPSModel() { Latitude = x[0], Longitude = x[1] }).ToList();
|
|
Variaveis.OperacaoEmAndamento.Trajetoria?.IniciarRetornoBase(posicaoBase, pontosRetornoPos);
|
|
return;
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.Emergencia = controleBase.Emergencia;
|
|
if (Variaveis.OperacaoEmAndamento.Emergencia) return;
|
|
|
|
Variaveis.OperacaoEmAndamento.Pausa = controleBase.Pausa;
|
|
if (Variaveis.OperacaoEmAndamento.Pausa) return;
|
|
|
|
if (controleBase.Controle == null) return;
|
|
|
|
var cmdRover = GeneralJoystick.DeParaComandos.FirstOrDefault(x => x.botaoJoy == controleBase.Tecla);
|
|
|
|
if (cmdRover?.Dispositivo == T_Code.Mov && Variaveis.OperacaoEmAndamento.Parametros.Controle.MovimentoAutomatico && Variaveis.OperacaoEmAndamento.Iniciado) return;
|
|
if (cmdRover?.Dispositivo == T_Code.Dir && Variaveis.OperacaoEmAndamento.Parametros.Controle.DirecionalAutomatico && Variaveis.OperacaoEmAndamento.Iniciado) return;
|
|
|
|
var _Controle = Variaveis.OperacaoEmAndamento.Controle;
|
|
if (controleBase.Controle.PercentualVelocidadeSP != null) _Controle.PercentualVelocidadeSP = (double)controleBase.Controle.PercentualVelocidadeSP;
|
|
if (controleBase.Controle.AnguloSP != null) _Controle.Angulo = (double)controleBase.Controle.AnguloSP;
|
|
if (controleBase.Controle.TipoMovimentoDirecional != null) _Controle.TipoMovimento = (TipoMovimentoDirecional)controleBase.Controle.TipoMovimentoDirecional;
|
|
if (controleBase.Controle.EmFreio != null) _Controle.EmFreio = (bool)controleBase.Controle.EmFreio;
|
|
|
|
Keys tecla = cmdRover?.key ?? Keys.Escape;
|
|
GeneralJoystick.EnviaComandoMotor(tecla, controleBase.Dispositivo, ForcarComando: true, ID: controleBase._comp_id);
|
|
}
|
|
|
|
private async Task tmrComunicacao_Tick()
|
|
{
|
|
if (Variaveis.MqttServiceBase == null) return;
|
|
|
|
bool base_encontrada = (DateTime.Now - VariaveisOperacao.PosicaoBase.UltimoComandoRespondido).TotalSeconds < 10;
|
|
MqttService.MqttTopicosModel topico = null;
|
|
string msg = string.Empty;
|
|
if (!base_encontrada)
|
|
{
|
|
topico = Variaveis.MqttServiceBase.Topicos.FirstOrDefault(x => x.Topico == VariaveisMonitoramento.TopicoMqttDispositivos);
|
|
msg = $"{VariaveisEquipamento.Parametros.serial_number},{VariaveisEquipamento.Parametros.rover_ip}";
|
|
}
|
|
else
|
|
{
|
|
topico = Variaveis.MqttServiceBase.Topicos.FirstOrDefault(x => x.Topico == VariaveisEquipamento.TopicoMqttTelemetria.Replace("<id>", VariaveisEquipamento.Parametros.serial_number));
|
|
Variaveis.OperacaoEmAndamento.Parametros.DadosLeitura.Atualizar();
|
|
var data = Variaveis.OperacaoEmAndamento.Parametros.DadosLeitura.Clone();
|
|
msg = JsonConvert.SerializeObject(data);
|
|
}
|
|
if (topico != null && !string.IsNullOrEmpty(msg))
|
|
{
|
|
await Variaveis.MqttServiceBase.PublishAsync(topico, msg);
|
|
if (Variaveis.OperacaoEmAndamento.Parametros.DadosLeitura != null)
|
|
Variaveis.OperacaoEmAndamento.Parametros.DadosLeitura.UltimoEnvioLog = DateTime.Now;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region REGISTRO DE LOGS
|
|
|
|
private int idxLog = 0;
|
|
|
|
private async Task tmrLogs_Tick()
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
SalvarLogs(false);
|
|
|
|
if (idxLog % 10 == 0)
|
|
{
|
|
AudioAlertaService.AlertaSonoroPorStatus(Variaveis.OperacaoEmAndamento.StatusAtual);
|
|
}
|
|
|
|
if (idxLog % 5 == 0 && !Variaveis.OperacaoEmAndamento.Calibrando)
|
|
{
|
|
Task.Run(async () => await RealizarCalibragemInicialAsync(false));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SalvarLogs(bool Fim)
|
|
{
|
|
try
|
|
{
|
|
if (!string.IsNullOrEmpty(Variaveis.OperacaoEmAndamento.ID))
|
|
{
|
|
DateTime Agora = DateTime.Now;
|
|
|
|
OperacaoSensoriamentoLogModel logGeral = Variaveis.OperacaoEmAndamento.Sensoriamento.Clone();
|
|
logGeral.Momento = Agora;
|
|
SalvarLog("operacao", logGeral, Fim);
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.UltimoRegistroLog = DateTime.Now;
|
|
Variaveis.OperacaoEmAndamento.Controle.TiposControle.ForEach(x => x.Comandos.Clear());
|
|
|
|
Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.ForEach(Modulo =>
|
|
{
|
|
MovSensoriamentoLogModel logMov = new MovSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Modulo_ID = Modulo.Modulo_ID,
|
|
Inicializado = Modulo.MovMotor.Inicializado,
|
|
RPM_SP = Modulo.MovMotor.RPM_SP,
|
|
RPM_Motor = Modulo.MovMotor.RPM_Motor,
|
|
RPM_Roda = Modulo.MovMotor.RPM_Roda,
|
|
Corrente_Motor = Modulo.MovMotor.Corrente_Motor,
|
|
Temperatura = Modulo.MovMotor.Temperatura,
|
|
TemperaturaDriver = Modulo.MovMotor.TemperaturaDriver,
|
|
Tensao = Modulo.MovMotor.Tensao,
|
|
Sentido_SP = Modulo.MovMotor.Sentido_SP,
|
|
Sentido = Modulo.MovMotor.Sentido,
|
|
Velocidade = Modulo.MovMotor.VelocidadeInstantanea,
|
|
CodAlarme = Modulo.MovMotor.CodigoAlarme,
|
|
AlarmeSensores = Modulo.MovMotor.AlarmeSensores,
|
|
AlarmeComando = Modulo.MovMotor.AlarmeComando,
|
|
EmFreio = Modulo.MovMotor.ConfigFreio.Leitura,
|
|
Ativado = Modulo.MovMotor.LeituraLigado,
|
|
UltimoComandoRespondido = Modulo.MovMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
|
|
Corrente_Barramento = Modulo.MovMotor.Corrente_Barramento,
|
|
Potencia = Modulo.MovMotor.Potencia,
|
|
CicloTrabalho = Modulo.MovMotor.CicloTrabalho
|
|
};
|
|
SalvarLog(T_Code.Mov.ToString(), logMov, false);
|
|
|
|
DirSensoriamentoLogModel logDir = new DirSensoriamentoLogModel()
|
|
{
|
|
Mod_ID = Modulo.Modulo_ID,
|
|
Iniciado = Modulo.DirMotor.Inicializado,
|
|
AnguloDriver = Modulo.DirMotor.AnguloDriver,
|
|
Angulo_SP = Modulo.DirMotor.Angulo_SP,
|
|
Controlar = Modulo.DirMotor.Comandar,
|
|
Sentido_SP = Modulo.DirMotor.Sentido_SP,
|
|
Sentido = Modulo.DirMotor.Sentido,
|
|
SentidoReal = Modulo.DirMotor.SentidoReal,
|
|
Velocidade = (Modulo.DirMotor.Velocidade / Modulo.DirMotor.Velocidade_Max) * 100.0,
|
|
FolgaMecanica = Modulo.DirMotor.FolgaMecanica,
|
|
UltimoComandoRespondido = Modulo.DirMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
|
|
AnguloLeitura = Modulo.DirMotor.AnguloLeitura,
|
|
AnguloFolgaCompensar = Modulo.DirMotor.AnguloFolgaCompensar,
|
|
AnguloReal = Modulo.DirMotor.AnguloReal
|
|
};
|
|
SalvarLog(T_Code.Dir.ToString(), logDir, false);
|
|
});
|
|
|
|
AtuSensoriamentoLogModel logAtu = new AtuSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Inicializado = Variaveis.OperacaoEmAndamento.DispAtu.Dados.ConexaoAtiva,
|
|
QualidadeWifi = Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.QualidadeWifi,
|
|
LatenciaLoop = Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.LatenciaLoop,
|
|
MassaReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.ContadorCarga.MassaAtual_Kg,
|
|
PercentualReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.ContadorCarga.PercentualAtual,
|
|
VolumeReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.ContadorCarga.VolumeAtual_L,
|
|
PressaoLinha_SP = Variaveis.OperacaoEmAndamento.Parametros.Controle.AtuPressaoLinha,
|
|
PressaoLinha = Variaveis.OperacaoEmAndamento.DispAtu.Dados.PressaoLinha,
|
|
PotenciaBomba = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombasPressurizadoras.FirstOrDefault()?._Potencia ?? 0,
|
|
BombaLigada = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombasPressurizadoras.FirstOrDefault().ComandoAtuar,
|
|
VazaoFluxoMLpSInstantanea = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VazaoFluxoMLpSInstantanea,
|
|
VazaoFluxoMLpSMedia = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VazaoMediaMLs,
|
|
VolumeVazaoML = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VolumeVazadoML,
|
|
QuantidadeBicos = Variaveis.OperacaoEmAndamento.Parametros.QtdBicos ?? VariaveisEquipamento.QuantidadeBicosPulverizadores,
|
|
TempoPulverizadorAtuado = Variaveis.OperacaoEmAndamento.DispAtu.Dados.TempoAtuado,
|
|
Bicos = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BicosPulverizadores.Select(Bico => new AtuBicoSensoriamentoLogModel()
|
|
{
|
|
ID = Bico.ID,
|
|
Inicializado = Bico.Inicializado,
|
|
Comandar = Bico.Comandar,
|
|
Atuado = Bico.ComandoAtuar,
|
|
MediaNivelFluxo = Bico.VazaoMediaMLs,
|
|
Posicao = Bico.Posicao,
|
|
StatusBico = Bico._EstadoLeitura == Estado.Ligado,
|
|
Atuacoes = Bico.Atuacoes,
|
|
TempoAtuado = Bico.TempoAtuado,
|
|
}).ToList(),
|
|
UltimoComandoRespondido = Variaveis.OperacaoEmAndamento.DispAtu.Dados.DadosLeitura.Momento,
|
|
};
|
|
SalvarLog(T_Code.Atu.ToString(), logAtu, false);
|
|
|
|
var senLeitura = Variaveis.OperacaoEmAndamento.DispSen.Dados;
|
|
SensoriamentoMensagemJsonModel logSen = new SensoriamentoMensagemJsonModel()
|
|
{
|
|
Momento = Agora,
|
|
Conectado = senLeitura.DadosLeitura.Conectado,
|
|
LatenciaLoop = senLeitura.DadosLeitura.LatenciaLoop,
|
|
QualidadeWifi = senLeitura.DadosLeitura.QualidadeWifi,
|
|
Mod_ID = senLeitura.DadosLeitura.Mod_ID,
|
|
UltimoComandoRespondido = senLeitura.DadosLeitura.UltimoComandoRespondido,
|
|
Reles = new List<SensorReleModel>(senLeitura.Reles),
|
|
Sensores = new List<SensorModel>(senLeitura.Sensores),
|
|
Servos = new List<SensorServoModel>(senLeitura.Servos),
|
|
Sinaleiros = new List<SensorSinaleiroModel>(senLeitura.Sinaleiros),
|
|
};
|
|
SalvarLog(T_Code.Sen.ToString(), logSen, false);
|
|
|
|
SalvarLogCameraSolo();
|
|
SalvarLogCameraCaminho();
|
|
|
|
string ArquivoOp = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/data.lgop";
|
|
if (!File.Exists(ArquivoOp))
|
|
{
|
|
var data = new OperacaoDadosModel()
|
|
{
|
|
id = Variaveis.OperacaoEmAndamento.ID,
|
|
operacao = "operacao",
|
|
dir = T_Code.Dir.ToString(),
|
|
mov = T_Code.Mov.ToString(),
|
|
atu = T_Code.Atu.ToString(),
|
|
sen = T_Code.Sen.ToString(),
|
|
cam_caminho = T_Code.Snr.ToString(),
|
|
cam_solo = Variaveis.OperacaoEmAndamento.DispSen.Dados.CamerasSolo.Select((x, i) => x.Dispositivo.ToString() + i).ToList(),
|
|
};
|
|
File.WriteAllText(ArquivoOp, JsonConvert.SerializeObject(data));
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.idxLog++;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Erro ao salvar log: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private void SalvarLog<T>(string Arquivo, T Objeto, bool Fim)
|
|
{
|
|
var Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID;
|
|
if (!Directory.Exists(Caminho))
|
|
{
|
|
Directory.CreateDirectory(Caminho);
|
|
}
|
|
|
|
Caminho += "/" + Arquivo + ".json";
|
|
string jsonLog = JsonConvert.SerializeObject(Objeto, Formatting.None);
|
|
|
|
if (!File.Exists(Caminho))
|
|
{
|
|
File.WriteAllText(Caminho, "[" + jsonLog);
|
|
}
|
|
else
|
|
{
|
|
File.AppendAllText(Caminho, "," + jsonLog + (Fim ? "]" : ""));
|
|
}
|
|
}
|
|
|
|
private void SalvarLogCameraSolo()
|
|
{
|
|
foreach (var Camera in Variaveis.OperacaoEmAndamento.DispSen.Dados.CamerasSolo)
|
|
{
|
|
string camera_name = Camera.Dispositivo.ToString() + Variaveis.OperacaoEmAndamento.DispSen.Dados.CamerasSolo.IndexOf(Camera);
|
|
string Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/" + camera_name;
|
|
if (!Directory.Exists(Caminho))
|
|
{
|
|
Directory.CreateDirectory(Caminho);
|
|
}
|
|
|
|
string nome = Variaveis.OperacaoEmAndamento.idxLog.ToString();
|
|
var frames_salvar = new List<TipoFrameCamera>() { TipoFrameCamera.Rgb, TipoFrameCamera.Segmentacao };
|
|
if (Variaveis.OperacaoEmAndamento.Parametros.Controle.RegistrarDadosPosProcessamento) frames_salvar.Add(TipoFrameCamera.Raw4);
|
|
Camera.SaveFrames(frames_salvar, nome, Caminho);
|
|
|
|
var cameras_conectadas = JsonConvert.DeserializeObject<Dictionary<string, object>>(RedisService.Get(CtxKey.DadosCameras));
|
|
bool conectada = cameras_conectadas.ContainsKey(Camera?.Id ?? "");
|
|
if (conectada)
|
|
{
|
|
var cam_data = JsonConvert.DeserializeObject<Dictionary<string, object>>(RedisService.Get(RedisService.CamKey(Camera.Id)));
|
|
SalvarLog(camera_name, cam_data, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SalvarLogCameraCaminho()
|
|
{
|
|
var Camera = Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraCaminho;
|
|
|
|
string Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/" + Camera.Dispositivo;
|
|
if (!Directory.Exists(Caminho))
|
|
{
|
|
Directory.CreateDirectory(Caminho);
|
|
}
|
|
|
|
string nome = Variaveis.OperacaoEmAndamento.idxLog.ToString();
|
|
var frames_salvar = new List<TipoFrameCamera>() { TipoFrameCamera.Rgb, TipoFrameCamera.Segmentacao };
|
|
if (Variaveis.OperacaoEmAndamento.Parametros.Controle.RegistrarDadosPosProcessamento) frames_salvar.Add(TipoFrameCamera.Heatmap);
|
|
Camera.SaveFrames(frames_salvar, nome, Caminho);
|
|
|
|
var cameras_conectadas = JsonConvert.DeserializeObject<Dictionary<string, object>>(RedisService.Get(CtxKey.DadosCameras));
|
|
bool conectada = cameras_conectadas.ContainsKey(Camera?.Id ?? "");
|
|
if (conectada)
|
|
{
|
|
var cam_data = JsonConvert.DeserializeObject<Dictionary<string, object>>(RedisService.Get(RedisService.CamKey(Camera.Id)));
|
|
SalvarLog(Camera.Dispositivo.ToString(), cam_data, false);
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region FORMULARIO
|
|
|
|
public void AbrirForm()
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.OperacaoLiberada)
|
|
{
|
|
frmOperacao =
|
|
Modo == ModoOperacao.Manual ? new frmOperacaoManual() :
|
|
Modo == ModoOperacao.MapaGPS ? new frmOperacaoMapaGPS() :
|
|
new Form();
|
|
|
|
frmOperacao.Show();
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show(Variaveis.OperacaoEmAndamento.ErroOperacaoLiberada, "Conexão de módulos pendentes", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
}
|
|
}
|
|
|
|
public string TextoFormOperacao(string ModoNome)
|
|
{
|
|
var statusAtual = Variaveis.OperacaoEmAndamento.StatusAtual;
|
|
|
|
if (statusAtual == StatusOperacao.Parametrizando)
|
|
{
|
|
return "Operação " + ModoNome + " - Parametrização";
|
|
}
|
|
else if (statusAtual == StatusOperacao.Aguardando)
|
|
{
|
|
return "Operação " + ModoNome + " - Iniciando em " + (Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) - DateTime.Now).TotalSeconds.ToString("0") + " segundo" + ((Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) - DateTime.Now).TotalSeconds < 1 ? "" : "s") + "...";
|
|
}
|
|
else if (statusAtual == StatusOperacao.Concluido)
|
|
{
|
|
return "Operação " + ModoNome + " - Concluída";
|
|
}
|
|
else if (statusAtual == StatusOperacao.EmAndamento)
|
|
{
|
|
return "Operação " + ModoNome + " - Em andamento";
|
|
}
|
|
else if (statusAtual == StatusOperacao.Parado)
|
|
{
|
|
return "Operação " + ModoNome + " - Parado";
|
|
}
|
|
else
|
|
{
|
|
return "Operação " + ModoNome;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DIAGNOSTICO
|
|
|
|
public static void PopularTreeView(TreeView treeView, List<ManagerWorkerMessageResponseModulosPendentesModel> modulos)
|
|
{
|
|
treeView.Font = new Font("Consolas", 10);
|
|
treeView.Nodes.Clear();
|
|
|
|
foreach (var modulo in modulos)
|
|
{
|
|
string nomeModulo = $"{modulo.modulo} {modulo.status} (Saúde: {modulo.saude:0}%)";
|
|
TreeNode nodoModulo = new TreeNode(nomeModulo);
|
|
|
|
if (modulo.saude_individual.Any())
|
|
{
|
|
foreach (var item in modulo.saude_individual.Where(x => x.em_uso))
|
|
{
|
|
string nomeItem = $"{item.label} ({item.id}) {item.status} (Saúde: {item.saude:0}%)";
|
|
TreeNode nodoItem = new TreeNode(nomeItem);
|
|
|
|
// Adiciona os motivos normais (de saúde)
|
|
foreach (var motivo in item.motivos)
|
|
{
|
|
nodoItem.Nodes.Add(new TreeNode(motivo));
|
|
}
|
|
|
|
// Agrupamento das condições operacionais (se houver)
|
|
if (item.condicoes_operacionais != null && item.condicoes_operacionais.Count > 0)
|
|
{
|
|
TreeNode nodoCondicoes = new TreeNode("Condições Operacionais");
|
|
|
|
foreach (var cond in item.condicoes_operacionais)
|
|
{
|
|
string textoCond = $"{cond.descricao} (Valor: {cond.valor}, Severidade: {cond.severidade:0}%)";
|
|
nodoCondicoes.Nodes.Add(new TreeNode(textoCond));
|
|
}
|
|
|
|
nodoItem.Nodes.Add(nodoCondicoes);
|
|
}
|
|
|
|
nodoModulo.Nodes.Add(nodoItem);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Adiciona os motivos normais (de saúde)
|
|
foreach (var motivo in modulo.motivos)
|
|
{
|
|
nodoModulo.Nodes.Add(new TreeNode(motivo));
|
|
}
|
|
}
|
|
if (modulo.condicoes_operacionais?.Any() ?? false)
|
|
{
|
|
// Agrupamento das condições operacionais (se houver)
|
|
if (modulo.condicoes_operacionais != null && modulo.condicoes_operacionais.Count > 0)
|
|
{
|
|
TreeNode nodoCondicoes = new TreeNode("Condições Operacionais");
|
|
|
|
foreach (var cond in modulo.condicoes_operacionais)
|
|
{
|
|
string textoCond = $"{cond.descricao} (Valor: {cond.valor}, Severidade: {cond.severidade:0}%)";
|
|
nodoCondicoes.Nodes.Add(new TreeNode(textoCond));
|
|
}
|
|
|
|
nodoModulo.Nodes.Add(nodoCondicoes);
|
|
}
|
|
}
|
|
|
|
treeView.Nodes.Add(nodoModulo);
|
|
}
|
|
|
|
treeView.ExpandAll();
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
|
|
public class OperacaoControleModel
|
|
{
|
|
public double Angulo { get; set; }
|
|
public int heartbeat { get; set; } = 1;
|
|
public DateTime ticks_sem_resposta { get; set; } = DateTime.MinValue;
|
|
public int RPM_SP
|
|
{
|
|
get
|
|
{
|
|
return Convert.ToInt32(VariaveisEquipamento.RPM_Max_Roda * (PercentualVelocidadeSP / 100.0));
|
|
}
|
|
}
|
|
public int RPM_Motor
|
|
{
|
|
get
|
|
{
|
|
return Convert.ToInt32(RPM_SP * VariaveisEquipamento.RelacaoRPM);
|
|
}
|
|
}
|
|
public double PercentualVelocidadeSP { get; set; }
|
|
public double PercentualVelocidadeSPKmh
|
|
{
|
|
get
|
|
{
|
|
return FuncoesMatematicas.ConverteMsParaKmh(FuncoesMatematicas.CalculaVelocidadeMsPercentual(PercentualVelocidadeSP));
|
|
}
|
|
}
|
|
public bool EmFreio { get; set; } = false;
|
|
public Direcao Direcao { get; set; } = Direcao.Parado;
|
|
public List<AtuadorBicoModel> Bicos => Variaveis.OperacaoEmAndamento.DispAtu?.Dados?.BicosPulverizadores;
|
|
public double AlturaBarra { get; set; }
|
|
private TipoMovimentoDirecional _tipoMovimento = TipoMovimentoDirecional.Diagnostico;
|
|
public TipoMovimentoDirecional TipoMovimento
|
|
{
|
|
get
|
|
{
|
|
return _tipoMovimento;
|
|
}
|
|
set
|
|
{
|
|
var DispMvd = Variaveis.OperacaoEmAndamento.DispMvd;
|
|
if (DispMvd != null)
|
|
{
|
|
if (value != _tipoMovimento)
|
|
{
|
|
var _Controle = Variaveis.OperacaoEmAndamento.Controle;
|
|
switch (value)
|
|
{
|
|
case TipoMovimentoDirecional.RodasDianteiras:
|
|
DispMvd.Dados.Modulos.ForEach(x =>
|
|
{
|
|
x.MovMotor.Comandar = true;
|
|
x.DirMotor.Comandar = x.Modulo_ID.Contains("F");
|
|
x.DirMotor.Angulo_SP = x.DirMotor.Comandar ? _Controle.Angulo : 0;
|
|
});
|
|
break;
|
|
case TipoMovimentoDirecional.RodasTraseiras:
|
|
DispMvd.Dados.Modulos.ForEach(x =>
|
|
{
|
|
x.MovMotor.Comandar = true;
|
|
x.DirMotor.Comandar = x.Modulo_ID.Contains("T");
|
|
x.DirMotor.Angulo_SP = x.DirMotor.Comandar ? _Controle.Angulo : 0;
|
|
});
|
|
break;
|
|
default:
|
|
DispMvd.Dados.Modulos.ForEach(x =>
|
|
{
|
|
x.MovMotor.Comandar = true;
|
|
x.DirMotor.Comandar = true;
|
|
x.DirMotor.Angulo_SP = _Controle.Angulo;
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
_tipoMovimento = value;
|
|
}
|
|
}
|
|
public List<OperacaoControleTipoModel> TiposControle { get; set; } = new List<OperacaoControleTipoModel>();
|
|
public List<MPCSimulacaoModel> SimulacaoMPC { get; set; } = new List<MPCSimulacaoModel>();
|
|
public double Latencia { get; set; }
|
|
public double ErroLateral { get; set; } = 0.0;
|
|
public Dictionary<string, ManagerWorkerMessageResponseDebugCustoModel> DebugCustoMpc { get; set; } = new Dictionary<string, ManagerWorkerMessageResponseDebugCustoModel>();
|
|
public List<string> Motivos { get; set; } = new List<string>();
|
|
|
|
public void Reiniciar()
|
|
{
|
|
var _Parametros = Variaveis.OperacaoEmAndamento.Parametros.Controle;
|
|
PercentualVelocidadeSP = _Parametros.MovimentoAutomatico ? 0 : _Parametros.MovVelocidadeCErvasPercent;
|
|
Angulo = _Parametros.DirecionalAutomatico ? 0 : _Parametros.DirAnguloMaximo;
|
|
EmFreio = false;
|
|
Direcao = Direcao.Parado;
|
|
TipoMovimento = TipoMovimentoDirecional.RodasDianteiras;
|
|
TiposControle.ForEach(x => x.UltimaDirecao = Direcao.Parado);
|
|
}
|
|
|
|
public OperacaoControleModel Clone()
|
|
{
|
|
return new OperacaoControleModel()
|
|
{
|
|
Angulo = Angulo,
|
|
Direcao = Direcao,
|
|
PercentualVelocidadeSP = PercentualVelocidadeSP,
|
|
_tipoMovimento = _tipoMovimento,
|
|
TipoMovimento = TipoMovimento,
|
|
TiposControle = new List<OperacaoControleTipoModel>(TiposControle),
|
|
SimulacaoMPC = new List<MPCSimulacaoModel>(SimulacaoMPC),
|
|
AlturaBarra = AlturaBarra,
|
|
heartbeat = heartbeat,
|
|
ticks_sem_resposta = ticks_sem_resposta,
|
|
Latencia = Latencia,
|
|
EmFreio = EmFreio,
|
|
ErroLateral = ErroLateral,
|
|
DebugCustoMpc = new Dictionary<string, ManagerWorkerMessageResponseDebugCustoModel>(DebugCustoMpc ?? new Dictionary<string, ManagerWorkerMessageResponseDebugCustoModel>()),
|
|
Motivos = new List<string>(Motivos ?? new List<string>())
|
|
};
|
|
}
|
|
}
|
|
|
|
public class OperacaoControleTipoModel
|
|
{
|
|
public T_Code Tipo { get; set; }
|
|
public int DelayEnvioComandoBase { get; set; }
|
|
public int DelayEnvioComando { get; set; }
|
|
public int DelayEnvioComandoExtra { get; set; }
|
|
public DateTime UltimoComando { get; set; }
|
|
public List<string> Comandos { get; set; }
|
|
public Direcao UltimaDirecao { get; set; } = Direcao.Parado;
|
|
}
|
|
|
|
public class OperacaoModulosMandatoriosModel
|
|
{
|
|
public T_Code Dispositivo { get; set; }
|
|
public bool Mandatorio { get; set; }
|
|
public bool Utilizar { get; set; }
|
|
public bool Conectado { get; set; }
|
|
public Dictionary<string, (bool, bool)> ComponentesEmUso { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosMandatoriosModel
|
|
{
|
|
public ParametrosOperacao Parametro { get; set; }
|
|
public bool Mandatorio { get; set; }
|
|
public bool Utilizar { get; set; }
|
|
}
|
|
|
|
public class OperacaoComandoBaseModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public BotoesJoystick Tecla { get; set; }
|
|
public T_Code Dispositivo { get; set; }
|
|
public bool Emergencia { get; set; }
|
|
public bool Pausa { get; set; }
|
|
public string _comp_id { get; set; }
|
|
public dynamic _comp_value { get; set; }
|
|
public OperacaoParametrosModel Parametros { get; set; }
|
|
public OperacaoComandoBaseControleModel Controle { get; set; }
|
|
}
|
|
|
|
public class OperacaoComandoBaseControleModel
|
|
{
|
|
public double? PercentualVelocidadeSP { get; set; }
|
|
public double? AnguloSP { get; set; }
|
|
public TipoMovimentoDirecional? TipoMovimentoDirecional { get; set; }
|
|
public bool? EmFreio { get; set; }
|
|
public bool? Estado { get; set; }
|
|
public double? Altura { get; set; }
|
|
}
|
|
|
|
|
|
public class OperacaoDadosModel
|
|
{
|
|
public string id { get; set; }
|
|
public string operacao { get; set; }
|
|
public string dir { get; set; }
|
|
public string mov { get; set; }
|
|
public string atu { get; set; }
|
|
public string sen { get; set; }
|
|
public string cam_caminho { get; set; }
|
|
public List<string> cam_solo { get; set; }
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public ModoOperacao Modo { get; set; }
|
|
public StatusModulo Status { get; set; }
|
|
public string ErroOperacaoLiberada { get; set; }
|
|
public bool OperacaoLiberada { get; set; }
|
|
public bool OperacaoIniciada { get; set; }
|
|
public bool Emergencia { get; set; }
|
|
public bool Pausa { get; set; }
|
|
public StatusOperacao StatusOperacao { get; set; } = StatusOperacao.Parado;
|
|
public DateTime DataInicio { get; set; }
|
|
public DateTime DataFim { get; set; }
|
|
public double TempoAguardandoSeg { get; set; }
|
|
public double TempoDecorridoSeg { get; set; }
|
|
public DateTime TempoDecorrido
|
|
{
|
|
get
|
|
{
|
|
return new DateTime().AddSeconds(TempoDecorridoSeg);
|
|
}
|
|
}
|
|
public OperacaoSensoriamentoLogImuModel IMU { get; set; }
|
|
public OperacaoSensoriamentoLogAtuModel Atuador { get; set; }
|
|
public OperacaoSensoriamentoLogMovModel Movimentacao { get; set; }
|
|
public OperacaoSensoriamentoLogDirModel Direcional { get; set; }
|
|
public OperacaoSensoriamentoLogBateriaModel Bateria { get; set; }
|
|
public OperacaoSensoriamentoLogTrajetoriaModel Trajetoria { get; set; }
|
|
public LraSensoriamentoLogModel DadosLoRa { get; set; }
|
|
public GPSModel Gps { get; set; }
|
|
public PerformanceModel DadosPerformance { get; set; } = new PerformanceModel();
|
|
public OperacaoControleModel Controle { get; set; }
|
|
public VisualWorkerModel OperadorVisual { get; set; }
|
|
public WeedWorkerModel OperadorErvas { get; set; }
|
|
public LivoxModel LivoxLidar { get; set; }
|
|
public List<OperacaoModulosMandatoriosModel> ModulosMandatorios { get; set; }
|
|
public List<OperacaoParametrosMandatoriosModel> ParametrosMandatorios { get; set; }
|
|
public List<ManagerWorkerMessageResponseModulosPendentesModel> ModulosSaude { get; set; }
|
|
public List<DispositivoDetalhesModel> DispositivosMapeados { get; set; }
|
|
public Dictionary<T_Code, Dictionary<string, bool>> ModsCalibragem { get; set; }
|
|
public bool CanSerialAtivado { get; set; }
|
|
public List<OperacaoSensoriamentoLogErrosModel> Logs { get; set; }
|
|
public DateTime UltimoRegistroLog { get; set; } = DateTime.MinValue;
|
|
public CoolerControlDataModel CoolerControl { get; set; }
|
|
|
|
public void InserirLog(T_Code dispositivo, StatusModulo status, double saude, string mensagem, string id = null, string condicoes = null)
|
|
{
|
|
if (Logs == null)
|
|
Logs = new List<OperacaoSensoriamentoLogErrosModel>();
|
|
|
|
Logs.Add(new OperacaoSensoriamentoLogErrosModel()
|
|
{
|
|
Momento = DateTime.Now,
|
|
Dispositivo = dispositivo,
|
|
ID = id,
|
|
Status = status,
|
|
Saude = saude,
|
|
Mensagem = mensagem,
|
|
Condicoes = condicoes
|
|
});
|
|
}
|
|
|
|
|
|
public void AtualizarDados()
|
|
{
|
|
Variaveis.OperacaoEmAndamento.AtualizarDadosContexto();
|
|
Variaveis.OperacaoEmAndamento.DadosPerformance.AtualizarDadosPerformance();
|
|
VisualWorkerService.AtualizarAnalise();
|
|
WeedWorkerService.AtualizarAnalise();
|
|
GPSService.AtualizaDadosRedis();
|
|
LivoxManagerProcess.AtualizarLeitura();
|
|
MovimentacaoMovimentoCompensadoModel.AtualizarDados();
|
|
DalyBMSService.AtualizarDados();
|
|
|
|
var _Trajetoria = Variaveis.OperacaoEmAndamento.Trajetoria;
|
|
var _DispMvd = Variaveis.OperacaoEmAndamento.DispMvd;
|
|
var _DispAtu = Variaveis.OperacaoEmAndamento.DispAtu;
|
|
var _DispSen = Variaveis.OperacaoEmAndamento.DispSen;
|
|
var _Controle = Variaveis.OperacaoEmAndamento.Controle;
|
|
var _Bateria = _DispSen?.Dados?.ContadorCarga;
|
|
var _Reservatorio = _DispAtu?.Dados?.ContadorCarga;
|
|
var _Cooler = _DispSen?.Dados?.CoolerControl;
|
|
|
|
double tmp_max = Math.Max(Variaveis.OperacaoEmAndamento.DadosPerformance?.GPU_temp ?? 0, Variaveis.OperacaoEmAndamento.DadosPerformance?.CPU_temp ?? 0);
|
|
_DispMvd?.Dados?.AtualizarDadosFreio();
|
|
_DispSen?.Dados?.AtualizarStatusSinaleiros(Variaveis.OperacaoEmAndamento.Modo, Variaveis.OperacaoEmAndamento.StatusAtual);
|
|
_DispAtu?.Dados?.AtualizaTempoAtuadoGeral();
|
|
_Cooler?.Atualizar(tmp_max, DateTime.Now);
|
|
_Bateria?.AtualizarConsumo(_DispMvd?.Dados?.DistanciaPercorridaTotal ?? 0);
|
|
_Reservatorio?.AtualizarConsumo(_DispMvd?.Dados?.DistanciaPercorridaTotal ?? 0, Variaveis.OperacaoEmAndamento.TempoDecorridoSegs);
|
|
_Trajetoria?.AtualizarDadosAutonomiaCorredor();
|
|
|
|
//var sIMU = LivoxManagerProcess.DadosLeitura.imu;
|
|
string imu = RedisService.Get(RedisService.ModKey(T_Code.Imu)) ?? "";
|
|
var sIMU = JsonConvert.DeserializeObject<OAKImuModel>(imu);
|
|
bool imu_iniciado = sIMU.timestamp > 0 && HealthWorkerService.ModulosSaude.FirstOrDefault(x => x.modulo == T_Code.Imu)?.status != StatusModulo.Desconectado;
|
|
var dadosIMU = sIMU != null ? new OperacaoSensoriamentoLogImuModel()
|
|
{
|
|
Iniciado = imu_iniciado,
|
|
InclinacaoLateral = imu_iniciado ? sIMU.pitch : 0,
|
|
InclinacaoFrontal = imu_iniciado ? sIMU.roll : 0,
|
|
Rotacao = imu_iniciado ? sIMU.yaw : 0,
|
|
RotacaoCorrigida = imu_iniciado ? sIMU.yaw_fixed : 0,
|
|
} : new OperacaoSensoriamentoLogImuModel();
|
|
|
|
var dadosAtuador = _DispAtu != null ? new OperacaoSensoriamentoLogAtuModel()
|
|
{
|
|
QtdCamerasSolo = _DispSen.Dados.CamerasSolo.Count,
|
|
CapacidadeReservatorio = VariaveisEquipamento.CapacidadeReservatorio,
|
|
HerbicidaConsumido = _DispAtu.Dados.VolumeVazadoML,
|
|
PercentualErvasTerreno = _DispAtu.Dados.PercentualErvasTerreno,
|
|
HerbicidaPorErva = _Reservatorio.HerbicidaPorAtuacao,
|
|
ErvasNoRadar = WeedWorkerService.DadosLeitura?.Analise?.ervas_no_radar ?? false,
|
|
PercentualErvasNoRadar = WeedWorkerService.DadosLeitura?.Analise?.estatisticas?.erva?.ema_global ?? 0,
|
|
PercentualReservatorio = _Reservatorio.PercentualAtual,
|
|
VolumeReservatorio = _Reservatorio.VolumeAtual_L,
|
|
MassaReservatorio = _Reservatorio.MassaAtual_Kg,
|
|
PressaoLinha = _DispAtu.Dados.PressaoLinha,
|
|
PressaoLinhaCalc = _DispAtu.Dados.PressaoLinhaCalc,
|
|
VazaoInstantanea = _DispAtu.Dados.VazaoFluxoMLpSInstantanea,
|
|
VazaoInstantaneaCalc = _DispAtu.Dados.VazaoFluxoMLpSInstantaneaCalc,
|
|
VazaoMedia = _DispAtu.Dados.VazaoMediaMLs,
|
|
TempoBombaAtuada = _DispAtu.Dados.TempoAtuado,
|
|
ComandoBomba = _DispAtu.Dados.BombasPressurizadoras.FirstOrDefault().ComandoAtuar,
|
|
LeituraComandoBomba = _DispAtu.Dados.BombasPressurizadoras.FirstOrDefault()._EstadoLeitura == Estado.Ligado,
|
|
LeituraPotenciaBomba = FuncoesMatematicas.Clamp(_DispAtu.Dados.BombasPressurizadoras.FirstOrDefault()._Potencia, 0, 100),
|
|
VolumeVazaoMl = _DispAtu.Dados.VolumeVazadoML,
|
|
Iniciados = _DispAtu.Dados.Sensores.Select(s => new { s.ID, s.Inicializado }).Union(_DispAtu.Dados.BicosPulverizadores.Select(b => new { b.ID, b.Inicializado })).Union(_DispAtu.Dados.BombasPressurizadoras.Select(b => new { b.ID, b.Inicializado })).ToDictionary(x => x.ID, x => x.Inicializado),
|
|
Servos = _DispAtu.Dados.Servos?.ToDictionary(x => x.ID, y => (y._AnguloControle, y._AnguloLeiutra, y.Incremental)),
|
|
AnguloBarraEsquerda = _DispAtu.Dados.AnguloBarraEsquerda,
|
|
AnguloBarraDireita = _DispAtu.Dados.AnguloBarraDireita,
|
|
AnguloBarraAltura = _DispAtu.Dados.AnguloBarraAltura,
|
|
UltimoComandoRespondido = _DispAtu.Dados.DadosLeitura?.UltimoComandoRespondido ?? DateTime.MinValue,
|
|
LPorMetro = _Reservatorio.LPorMetro,
|
|
LPorMinuto = _Reservatorio.LPorMinuto,
|
|
TempoEstimadoRestanteMinutos = _Reservatorio.TempoEstimadoMinutosPulverizando,
|
|
DistanciaEstimadaRestanteMetros = _Reservatorio.DistanciaEstimadaRestantePulverizando_m,
|
|
Bicos = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BicosPulverizadores.Select(Bico => new AtuBicoSensoriamentoLogModel()
|
|
{
|
|
ID = Bico.ID,
|
|
Inicializado = Bico.Inicializado,
|
|
Comandar = Bico.Comandar,
|
|
Atuado = Bico.ComandoAtuar,
|
|
MediaNivelFluxo = Bico.VazaoMediaMLs,
|
|
Posicao = Bico.Posicao,
|
|
StatusBico = Bico._EstadoLeitura == Estado.Ligado,
|
|
Atuacoes = Bico.Atuacoes,
|
|
TempoAtuado = Bico.TempoAtuado,
|
|
AnguloAbertura = Bico.AnguloAbertura,
|
|
AnguloControle = Bico.AnguloControle,
|
|
}).ToList(),
|
|
} : new OperacaoSensoriamentoLogAtuModel();
|
|
|
|
var dadosMovimentacao = _DispMvd != null ? new OperacaoSensoriamentoLogMovModel()
|
|
{
|
|
VelocidadeMedia = _DispMvd.Dados.VelocidadeMedia,
|
|
RPMMedio = _DispMvd.Dados.Modulos.Where(x => x.MovMotor.Inicializado).DefaultIfEmpty()?.Average(x => x?.MovMotor?.RPM_Roda ?? 0) ?? 0,
|
|
TemperaturaMedia = _DispMvd.Dados.Modulos.Where(x => x.MovMotor.Inicializado).DefaultIfEmpty()?.Average(x => x?.MovMotor?.Temperatura ?? 0) ?? 0,
|
|
TempoMovimentoSegs = _DispMvd.Dados.TempoEmAtividade,
|
|
DistanciaPercorridaTotal = _DispMvd.Dados.DistanciaPercorridaTotal,
|
|
DistanciaPercorridaParcial = _DispMvd.Dados.DistanciaPercorridaParcial,
|
|
Esq_Status = _DispMvd.Dados.StatusModulosMOV(Direcao.Esquerda),
|
|
Dir_Status = _DispMvd.Dados.StatusModulosMOV(Direcao.Direita),
|
|
Dados = _DispMvd.Dados.Modulos.Select(x => new OperacaoSensoriamentoLogMovDadosModel()
|
|
{
|
|
Mod_ID = x.MovMotor.Mod_ID,
|
|
ID = x.MovMotor._EnderecoCAN_Rx,
|
|
Iniciado = x.MovMotor.Inicializado,
|
|
Tensao = x.MovMotor.Tensao,
|
|
Corrente_Barramento = x.MovMotor.Corrente_Barramento,
|
|
Corrente_Motor = x.MovMotor.Corrente_Motor,
|
|
Potencia = x.MovMotor.Potencia,
|
|
CicloTrabalho = x.MovMotor.CicloTrabalho,
|
|
TemperaturaDriver = x.MovMotor.TemperaturaDriver,
|
|
RPM_Motor = x.MovMotor.RPM_Motor,
|
|
RPM_Roda = x.MovMotor.RPM_Roda,
|
|
VelocidadeInstantaneaMs = x.MovMotor.VelocidadeInstantanea,
|
|
UltimoComandoRespondido = x.MovMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
|
|
}).ToList(),
|
|
} : new OperacaoSensoriamentoLogMovModel();
|
|
|
|
var dadosDirecional = _DispMvd != null ? new OperacaoSensoriamentoLogDirModel()
|
|
{
|
|
AnguloMedio = _DispMvd.Dados.Modulos.Where(x => x.DirMotor.Inicializado && x.DirMotor.Comandar).DefaultIfEmpty().Average(x => Math.Abs(x?.DirMotor?.AnguloLeitura ?? 0)),
|
|
Status = _DispMvd.Dados.StatusModulosDIR(_Controle.TipoMovimento),
|
|
Dados = _DispMvd.Dados.Modulos.Select(x => new DirSensoriamentoLogModel()
|
|
{
|
|
Mod_ID = x.DirMotor.Mod_ID,
|
|
ID = x.DirMotor._EnderecoCAN_Rx,
|
|
Iniciado = x.DirMotor.Inicializado,
|
|
AnguloDriver = x.DirMotor.AnguloDriver,
|
|
AnguloReal = x.DirMotor.AnguloReal,
|
|
Angulo_SP = x.DirMotor.Angulo_SP,
|
|
Sentido = x.DirMotor.Sentido,
|
|
Sentido_SP = x.DirMotor.Sentido_SP,
|
|
SentidoReal = x.DirMotor.SentidoReal,
|
|
FolgaMecanica = x.DirMotor.FolgaMecanica,
|
|
AnguloFolgaCompensar = x.DirMotor.AnguloFolgaCompensar,
|
|
AnguloLeitura = x.DirMotor.AnguloLeitura,
|
|
Controlar = x.DirMotor.Comandar,
|
|
UltimoComandoRespondido = x.DirMotor.Leitura?.UltimoComandoRecebido ?? DateTime.MinValue,
|
|
Velocidade = x.DirMotor.Velocidade,
|
|
}).ToList()
|
|
} : new OperacaoSensoriamentoLogDirModel();
|
|
|
|
var dadosBateria = _Bateria != null ? new OperacaoSensoriamentoLogBateriaModel()
|
|
{
|
|
Iniciado = _Bateria.Iniciado,
|
|
BmsLigado = _Bateria.BmsLigado,
|
|
_dt = _Bateria._dt,
|
|
PercentualBateria = _Bateria.PercentualBateria,
|
|
PercentualBateriaConsumida = _Bateria.PercentualConsumido,
|
|
TempoEstimadoRestanteMinutos = _Bateria.TempoEstimadoMinutos,
|
|
CorrenteInstantanea = _Bateria.CorrenteInstantanea,
|
|
TensaoInstantanea = _Bateria.TensaoInstantanea,
|
|
PotenciaInstantanea = _Bateria.PotenciaInstantanea,
|
|
EnergiaConsumida_Wh = _Bateria.EnergiaConsumida_Wh,
|
|
WhPorMetro = _Bateria.WhPorMetro,
|
|
DistanciaEstimadaRestanteMetros = _Bateria.DistanciaEstimadaRestante_m,
|
|
Temperatura = _Bateria.Temperatura,
|
|
Barramentos = _DispSen?.Dados?.Sensores?.Where(x => x.Componente == S_Code.sCOR)?.Select(x => new OperacaoSensoriamentoLogBateriaBarramentoModel()
|
|
{
|
|
ID = x.ID,
|
|
Iniciado = x.Inicializado,
|
|
Descricao = x.Descricao,
|
|
Tensao = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Tensao)?.atual?.valor ?? -1,
|
|
Corrente = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Corrente)?.atual?.valor ?? -1,
|
|
Potencia = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Potencia)?.atual?.valor ?? -1,
|
|
Energia = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Energia)?.atual?.valor ?? -1,
|
|
Temperatura = x.ValoresLeituras?.FirstOrDefault(y => y.funcao == FuncoesPinout.Temperatura)?.atual?.valor ?? -1,
|
|
}).ToList()
|
|
} : new OperacaoSensoriamentoLogBateriaModel();
|
|
|
|
var dadosTrajetoria = new OperacaoSensoriamentoLogTrajetoriaModel()
|
|
{
|
|
StatusCarro = _Trajetoria?.StatusAtual ?? StatusCarroMapa.Parado,
|
|
TrajetoriaConcluida = _Trajetoria?.TrajeotiraConcluida ?? false,
|
|
DistanciaDireita = _Trajetoria?.DistanciaDireita ?? 0,
|
|
DistanciaEsquerda = _Trajetoria?.DistanciaEsquerda ?? 0,
|
|
ProgressoTrajeto = FuncoesMatematicas.Clamp(_Trajetoria?.PercentualTrajetoria ?? 0, 0, 100),
|
|
CorredorAtual = _Trajetoria?.CorredorAtual?.Clone(false) ?? new CorredorTrajetoriaModel(),
|
|
DirecaoCaminho = _Trajetoria?.DirecaoCaminho ?? DirecaoCarroRua.Parado,
|
|
AnguloCaminho = _Trajetoria?.AnguloCaminho ?? 0,
|
|
AnguloMedioCorredor = _Trajetoria?.AnguloMedioCorredor ?? 0,
|
|
DistanciaTotal = _Trajetoria?.DistanciaTotal ?? 0,
|
|
DistanciaPercorrida = _Trajetoria?.DistanciaPercorrida ?? 0,
|
|
DistanciaRestante = _Trajetoria?.DistanciaRestante ?? 0,
|
|
NaMargemDoCorredor = _Trajetoria?.NaMargemDoCorredor ?? false,
|
|
ManobrandoEntreRuas = _Trajetoria?.ManobrandoEntreRuas ?? false,
|
|
TempoEstimadoRestante = _Trajetoria?.TempoEstimadoRestante ?? "",
|
|
TempoEstimadoOperacao = _Trajetoria?.TempoEstimadoOperacao ?? "",
|
|
ProximoPonto = _Trajetoria?.ProximoPonto?.Clone() ?? new PontoTrajetoriaModel(TipoPontoRua.PosicaoRobo),
|
|
PontoMaisProximo = _Trajetoria?.PontoMaisProximo?.Clone() ?? new PontoTrajetoriaModel(TipoPontoRua.PosicaoRobo),
|
|
PontoAtual = _Trajetoria?.PontoAtual?.Clone() ?? new PontoTrajetoriaModel(TipoPontoRua.PosicaoRobo),
|
|
ErroLateralAngular = _Trajetoria?.ErroLateralAngular ?? 0,
|
|
ErroOrientacaoAngular = _Trajetoria?.ErroOrientacaoAngular ?? 0,
|
|
ErroOrientacaoAngularCombinado = _Trajetoria?.ErroOrientacaoAngularCombinado ?? 0,
|
|
ErroOrientacaoAngularCaminho = _Trajetoria?.ErroOrientacaoAngularCaminho ?? 0,
|
|
ErroOrientacaoAngularProximoPonto = _Trajetoria?.ErroOrientacaoAngularProximoPonto ?? 0,
|
|
PercentualOperacao = _Trajetoria?.PercentualTrajetoria ?? 0,
|
|
PercentualRuaAtual = _Trajetoria?.CorredorAtual?.Progresso ?? 0,
|
|
IdxRuaAtual = _Trajetoria?.CorredorAtual?.Idx ?? 0,
|
|
QtdPontos = _Trajetoria?.TrajetoriaFixa?.Count ?? 0,
|
|
DistanciaErroMapaCana = _Trajetoria?.DistanciaErroMapaPlantacao ?? 0,
|
|
PrimeiroPontoDentroMapa = _Trajetoria?.PrimeiroPontoDentroMapa?.Clone() ?? new GPSModel(),
|
|
PrimeiroPontoDentroCana = _Trajetoria?.PrimeiroPontoDentroCana?.Clone() ?? new GPSModel(),
|
|
AutonomiaCooredor = _Trajetoria?.AutonomiaCorredor?.Clone(),
|
|
};
|
|
|
|
var dadosGps = GPSService.UltimaLeitura.Clone();
|
|
|
|
var dadosControle = _Controle.Clone();
|
|
|
|
var dadosPerformance = Variaveis.OperacaoEmAndamento.DadosPerformance.Clone();
|
|
|
|
var dadosLora = new LraSensoriamentoLogModel()
|
|
{
|
|
Momento = DateTime.Now,
|
|
Conectado = _DispSen?.Dados?.loRaService?.Conectado ?? false,
|
|
Configurado = _DispSen?.Dados?.loRaService?.Configurado ?? false,
|
|
EnderecoCarro = _DispSen?.Dados?.loRaService?.ParametrosGet?.address ?? 0x00,
|
|
EnderecoBase = _DispSen?.Dados?.LoRaParametrosBase?.address ?? 0x00,
|
|
PosicaoBase = VariaveisOperacao.PosicaoBase.Clone(),
|
|
UltimoComandoRespondido = VariaveisOperacao.PosicaoBase.Momento,
|
|
};
|
|
|
|
var dadosLivox = LivoxManagerProcess.DadosLeitura?.Clone();
|
|
|
|
var dadosCooler = _Cooler?.GetResumo();
|
|
|
|
OperacaoSensoriamentoLogModel dadosAtualizados = new OperacaoSensoriamentoLogModel()
|
|
{
|
|
Momento = DateTime.Now,
|
|
Modo = Variaveis.OperacaoEmAndamento.Modo,
|
|
Status = Variaveis.OperacaoEmAndamento.Status,
|
|
OperacaoLiberada = Variaveis.OperacaoEmAndamento.OperacaoLiberada,
|
|
OperacaoIniciada = Variaveis.OperacaoEmAndamento.Iniciado,
|
|
Emergencia = Variaveis.OperacaoEmAndamento.Emergencia,
|
|
Pausa = Variaveis.OperacaoEmAndamento.Pausa,
|
|
ErroOperacaoLiberada = Variaveis.OperacaoEmAndamento.ErroOperacaoLiberada,
|
|
StatusOperacao = Variaveis.OperacaoEmAndamento.StatusAtual,
|
|
DataInicio = Variaveis.OperacaoEmAndamento.DataInicio,
|
|
DataFim = Variaveis.OperacaoEmAndamento.DataFim,
|
|
TempoAguardandoSeg = Variaveis.OperacaoEmAndamento.TempoAguardandoSegs,
|
|
TempoDecorridoSeg = Variaveis.OperacaoEmAndamento.TempoDecorridoSegs,
|
|
CanSerialAtivado = CanManager.UseCanSerial,
|
|
IMU = dadosIMU,
|
|
Atuador = dadosAtuador,
|
|
Movimentacao = dadosMovimentacao,
|
|
Direcional = dadosDirecional,
|
|
Bateria = dadosBateria,
|
|
Trajetoria = dadosTrajetoria,
|
|
Gps = dadosGps,
|
|
OperadorVisual = VisualWorkerService.DadosLeitura.Clone(),
|
|
OperadorErvas = WeedWorkerService.DadosLeitura.Clone(),
|
|
Controle = dadosControle,
|
|
DadosPerformance = dadosPerformance,
|
|
DadosLoRa = dadosLora,
|
|
LivoxLidar = dadosLivox,
|
|
ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>(Variaveis.OperacaoEmAndamento.Parametros.ModulosMandatorios),
|
|
ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>(Variaveis.OperacaoEmAndamento.Parametros.ParametrosMandatorios),
|
|
ModulosSaude = HealthWorkerService.ModulosSaude.ToList(),
|
|
DispositivosMapeados = new List<DispositivoDetalhesModel>(SerialService.DispositivosMapeados),
|
|
ModsCalibragem = new Dictionary<T_Code, Dictionary<string, bool>>(Variaveis.OperacaoEmAndamento.ModsCalibragem),
|
|
Logs = Logs != null ? Logs.Where(x => x.Momento >= UltimoRegistroLog).ToList() : new List<OperacaoSensoriamentoLogErrosModel>(),
|
|
CoolerControl = dadosCooler
|
|
};
|
|
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento = dadosAtualizados;
|
|
}
|
|
|
|
public OperacaoSensoriamentoLogModel Clone(bool comSonar = false)
|
|
{
|
|
var vw = OperadorVisual?.Clone();
|
|
if (vw != null)
|
|
vw.CameraFrames = new Dictionary<TipoFrameCamera, OAKCameraFrameModel>();
|
|
var ww = OperadorErvas?.Clone();
|
|
if (ww != null)
|
|
ww.CameraFrames = new Dictionary<TipoFrameCamera, OAKCameraFrameModel>();
|
|
|
|
return new OperacaoSensoriamentoLogModel()
|
|
{
|
|
Modo = Modo,
|
|
Status = Status,
|
|
Momento = Momento,
|
|
ErroOperacaoLiberada = ErroOperacaoLiberada,
|
|
OperacaoLiberada = OperacaoLiberada,
|
|
OperacaoIniciada = OperacaoIniciada,
|
|
Emergencia = Emergencia,
|
|
Pausa = Pausa,
|
|
StatusOperacao = StatusOperacao,
|
|
DataInicio = DataInicio,
|
|
DataFim = DataFim,
|
|
TempoAguardandoSeg = TempoAguardandoSeg,
|
|
TempoDecorridoSeg = TempoDecorridoSeg,
|
|
CanSerialAtivado = CanSerialAtivado,
|
|
Atuador = Atuador?.Clone(),
|
|
Movimentacao = Movimentacao?.Clone(),
|
|
Direcional = Direcional?.Clone(),
|
|
Bateria = Bateria?.Clone(),
|
|
Trajetoria = Trajetoria?.Clone(),
|
|
Gps = Gps?.Clone(),
|
|
OperadorVisual = vw,
|
|
OperadorErvas = ww,
|
|
Controle = Controle?.Clone(),
|
|
DadosPerformance = DadosPerformance?.Clone(),
|
|
IMU = IMU?.Clone(),
|
|
DadosLoRa = DadosLoRa?.Clone(),
|
|
LivoxLidar = LivoxLidar?.Clone(),
|
|
ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>(ModulosMandatorios),
|
|
ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>(ParametrosMandatorios),
|
|
ModulosSaude = new List<ManagerWorkerMessageResponseModulosPendentesModel>(ModulosSaude),
|
|
DispositivosMapeados = new List<DispositivoDetalhesModel>(DispositivosMapeados),
|
|
ModsCalibragem = new Dictionary<T_Code, Dictionary<string, bool>>(ModsCalibragem),
|
|
Logs = new List<OperacaoSensoriamentoLogErrosModel>(Logs ?? new List<OperacaoSensoriamentoLogErrosModel>()),
|
|
UltimoRegistroLog = UltimoRegistroLog,
|
|
CoolerControl = CoolerControl?.Clone(),
|
|
};
|
|
}
|
|
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogImuModel
|
|
{
|
|
public bool Iniciado { get; set; }
|
|
public double InclinacaoLateral { get; set; }
|
|
public double InclinacaoFrontal { get; set; }
|
|
public double Rotacao { get; set; }
|
|
public double RotacaoCorrigida { get; set; }
|
|
|
|
public OperacaoSensoriamentoLogImuModel Clone()
|
|
{
|
|
return new OperacaoSensoriamentoLogImuModel()
|
|
{
|
|
Iniciado = Iniciado,
|
|
InclinacaoLateral = InclinacaoLateral,
|
|
InclinacaoFrontal = InclinacaoFrontal,
|
|
Rotacao = Rotacao,
|
|
RotacaoCorrigida = RotacaoCorrigida,
|
|
};
|
|
}
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogAtuModel
|
|
{
|
|
public int QtdCamerasSolo { get; set; }
|
|
public double CapacidadeReservatorio { get; set; }
|
|
public double HerbicidaConsumido { get; set; }
|
|
public double PercentualErvasTerreno { get; set; }
|
|
public double HerbicidaPorErva { get; set; }
|
|
public bool ErvasNoRadar { get; set; }
|
|
public double PercentualErvasNoRadar { get; set; }
|
|
public double PercentualReservatorio { get; set; }
|
|
public double MassaReservatorio { get; set; }
|
|
public double VolumeReservatorio { get; set; }
|
|
public double PressaoLinha { get; set; }
|
|
public double PressaoLinhaCalc { get; set; }
|
|
public double VazaoInstantanea { get; set; }
|
|
public double VazaoInstantaneaCalc { get; set; }
|
|
public double VazaoMedia { get; set; }
|
|
public double TempoBombaAtuada { get; set; }
|
|
public bool ComandoBomba { get; set; }
|
|
public bool LeituraComandoBomba { get; set; }
|
|
public double LeituraPotenciaBomba { get; set; }
|
|
public double VolumeVazaoMl { get; set; }
|
|
public double AnguloBarraEsquerda { get; set; }
|
|
public double AnguloBarraDireita { get; set; }
|
|
public double AnguloBarraAltura { get; set; }
|
|
public double LPorMetro { get; set; }
|
|
public double LPorMinuto { get; set; }
|
|
public double TempoEstimadoRestanteMinutos { get; set; }
|
|
public double DistanciaEstimadaRestanteMetros { get; set; }
|
|
public Dictionary<string, bool> Iniciados { get; set; }
|
|
public Dictionary<string, (int, int, bool)> Servos { get; set; }
|
|
public List<AtuBicoSensoriamentoLogModel> Bicos { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
|
|
public OperacaoSensoriamentoLogAtuModel Clone()
|
|
{
|
|
return new OperacaoSensoriamentoLogAtuModel()
|
|
{
|
|
QtdCamerasSolo = QtdCamerasSolo,
|
|
CapacidadeReservatorio = CapacidadeReservatorio,
|
|
ErvasNoRadar = ErvasNoRadar,
|
|
PercentualErvasNoRadar = PercentualErvasNoRadar,
|
|
HerbicidaConsumido = HerbicidaConsumido,
|
|
HerbicidaPorErva = HerbicidaPorErva,
|
|
PercentualErvasTerreno = PercentualErvasTerreno,
|
|
PercentualReservatorio = PercentualReservatorio,
|
|
VolumeReservatorio = VolumeReservatorio,
|
|
MassaReservatorio = MassaReservatorio,
|
|
PressaoLinha = PressaoLinha,
|
|
PressaoLinhaCalc = PressaoLinhaCalc,
|
|
VazaoInstantanea = VazaoInstantanea,
|
|
VazaoInstantaneaCalc = VazaoInstantaneaCalc,
|
|
VazaoMedia = VazaoMedia,
|
|
TempoBombaAtuada = TempoBombaAtuada,
|
|
ComandoBomba = ComandoBomba,
|
|
LeituraComandoBomba = LeituraComandoBomba,
|
|
LeituraPotenciaBomba = LeituraPotenciaBomba,
|
|
VolumeVazaoMl = VolumeVazaoMl,
|
|
AnguloBarraEsquerda = AnguloBarraEsquerda,
|
|
AnguloBarraDireita = AnguloBarraDireita,
|
|
AnguloBarraAltura = AnguloBarraAltura,
|
|
Iniciados = new Dictionary<string, bool>(Iniciados ?? new Dictionary<string, bool>()),
|
|
Servos = new Dictionary<string, (int, int, bool)>(Servos ?? new Dictionary<string, (int, int, bool)>()),
|
|
UltimoComandoRespondido = UltimoComandoRespondido,
|
|
LPorMetro = LPorMetro,
|
|
LPorMinuto = LPorMinuto,
|
|
TempoEstimadoRestanteMinutos = TempoEstimadoRestanteMinutos,
|
|
DistanciaEstimadaRestanteMetros = DistanciaEstimadaRestanteMetros,
|
|
Bicos = new List<AtuBicoSensoriamentoLogModel>(Bicos ?? new List<AtuBicoSensoriamentoLogModel>())
|
|
};
|
|
}
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogMovModel
|
|
{
|
|
public double VelocidadeMedia { get; set; }
|
|
public double RPMMedio { get; set; }
|
|
public double TempoMovimentoSegs { get; set; }
|
|
public double DistanciaPercorridaTotal { get; set; }
|
|
public double DistanciaPercorridaParcial { get; set; }
|
|
public double TemperaturaMedia { get; set; }
|
|
public DateTime TempoMovimento
|
|
{
|
|
get
|
|
{
|
|
return new DateTime().AddSeconds(TempoMovimentoSegs);
|
|
}
|
|
}
|
|
public (bool, List<string>) Esq_Status { get; set; }
|
|
public (bool, List<string>) Dir_Status { get; set; }
|
|
public List<OperacaoSensoriamentoLogMovDadosModel> Dados { get; set; }
|
|
|
|
public OperacaoSensoriamentoLogMovModel Clone()
|
|
{
|
|
return new OperacaoSensoriamentoLogMovModel()
|
|
{
|
|
VelocidadeMedia = VelocidadeMedia,
|
|
RPMMedio = RPMMedio,
|
|
TempoMovimentoSegs = TempoMovimentoSegs,
|
|
TemperaturaMedia = TemperaturaMedia,
|
|
Dir_Status = Dir_Status,
|
|
Esq_Status = Esq_Status,
|
|
DistanciaPercorridaParcial = DistanciaPercorridaParcial,
|
|
DistanciaPercorridaTotal = DistanciaPercorridaTotal,
|
|
Dados = new List<OperacaoSensoriamentoLogMovDadosModel>(Dados ?? new List<OperacaoSensoriamentoLogMovDadosModel>())
|
|
};
|
|
}
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogMovDadosModel
|
|
{
|
|
public string Mod_ID { get; set; }
|
|
public byte ID { get; set; }
|
|
public bool Iniciado { get; set; }
|
|
public bool Controlar { get; set; }
|
|
public double RPM_Roda { get; set; }
|
|
public double TemperaturaDriver { get; set; }
|
|
public double Tensao { get; set; }
|
|
public double Corrente_Barramento { get; set; }
|
|
public double Corrente_Motor { get; set; }
|
|
public double Potencia { get; set; }
|
|
public double CicloTrabalho { get; set; }
|
|
public double RPM_Motor { get; set; }
|
|
public double VelocidadeInstantaneaMs { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogDirModel
|
|
{
|
|
public double AnguloMedio { get; set; }
|
|
public (bool, List<string>) Status { get; set; }
|
|
public List<DirSensoriamentoLogModel> Dados { get; set; }
|
|
|
|
public OperacaoSensoriamentoLogDirModel Clone()
|
|
{
|
|
return new OperacaoSensoriamentoLogDirModel()
|
|
{
|
|
AnguloMedio = AnguloMedio,
|
|
Status = Status,
|
|
Dados = new List<DirSensoriamentoLogModel>(Dados ?? new List<DirSensoriamentoLogModel>())
|
|
};
|
|
}
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogBateriaModel
|
|
{
|
|
public bool Iniciado { get; set; }
|
|
public bool BmsLigado { get; set; }
|
|
public double _dt { get; set; }
|
|
public double PercentualBateria { get; set; }
|
|
public double PercentualBateriaConsumida { get; set; }
|
|
public double CorrenteInstantanea { get; set; }
|
|
public double TensaoInstantanea { get; set; }
|
|
public double PotenciaInstantanea { get; set; }
|
|
public double EnergiaConsumida_Wh { get; set; }
|
|
public double WhPorMetro { get; set; }
|
|
public double TempoEstimadoRestanteMinutos { get; set; }
|
|
public double DistanciaEstimadaRestanteMetros { get; set; }
|
|
public double Temperatura { get; set; }
|
|
public List<OperacaoSensoriamentoLogBateriaBarramentoModel> Barramentos { get; set; }
|
|
|
|
public OperacaoSensoriamentoLogBateriaModel Clone()
|
|
{
|
|
return new OperacaoSensoriamentoLogBateriaModel()
|
|
{
|
|
Iniciado = Iniciado,
|
|
BmsLigado = BmsLigado,
|
|
_dt = _dt,
|
|
PercentualBateriaConsumida = PercentualBateriaConsumida,
|
|
PercentualBateria = PercentualBateria,
|
|
CorrenteInstantanea = CorrenteInstantanea,
|
|
TensaoInstantanea = TensaoInstantanea,
|
|
PotenciaInstantanea = PotenciaInstantanea,
|
|
EnergiaConsumida_Wh = EnergiaConsumida_Wh,
|
|
WhPorMetro = WhPorMetro,
|
|
TempoEstimadoRestanteMinutos = TempoEstimadoRestanteMinutos,
|
|
DistanciaEstimadaRestanteMetros = DistanciaEstimadaRestanteMetros,
|
|
Temperatura = Temperatura,
|
|
Barramentos = new List<OperacaoSensoriamentoLogBateriaBarramentoModel>(Barramentos ?? new List<OperacaoSensoriamentoLogBateriaBarramentoModel>())
|
|
};
|
|
}
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogBateriaBarramentoModel
|
|
{
|
|
public string ID { get; set; }
|
|
public bool Iniciado { get; set; }
|
|
public string Descricao { get; set; }
|
|
public double Tensao { get; set; }
|
|
public double Corrente { get; set; }
|
|
public double Potencia { get; set; }
|
|
public double Energia { get; set; }
|
|
public double Temperatura { get; set; }
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogTrajetoriaModel
|
|
{
|
|
public StatusCarroMapa StatusCarro { get; set; }
|
|
public bool TrajetoriaConcluida { get; set; }
|
|
public double ProgressoTrajeto { get; set; }
|
|
public double AnguloCaminho { get; set; }
|
|
public double AnguloMedioCorredor { get; set; }
|
|
public DirecaoCarroRua DirecaoCaminho { get; set; }
|
|
public CorredorTrajetoriaModel CorredorAtual { get; set; }
|
|
public double DistanciaEsquerda { get; set; }
|
|
public double DistanciaDireita { get; set; }
|
|
public double DistanciaTotal { get; set; }
|
|
public double DistanciaPercorrida { get; set; }
|
|
public double DistanciaRestante { get; set; }
|
|
public bool NaMargemDoCorredor { get; set; }
|
|
public bool ManobrandoEntreRuas { get; set; }
|
|
public string TempoEstimadoRestante { get; set; }
|
|
public string TempoEstimadoOperacao { get; set; }
|
|
public PontoTrajetoriaModel ProximoPonto { get; set; }
|
|
public PontoTrajetoriaModel PontoAtual { get; set; }
|
|
public PontoTrajetoriaModel PontoMaisProximo { get; set; }
|
|
|
|
public double ErroOrientacaoAngular { get; set; }
|
|
public double ErroOrientacaoAngularCombinado { get; set; }
|
|
public double ErroOrientacaoAngularCaminho { get; set; }
|
|
public double ErroOrientacaoAngularProximoPonto { get; set; }
|
|
public double ErroLateralAngular { get; set; }
|
|
|
|
public int IdxRuaAtual { get; set; }
|
|
public double PercentualOperacao { get; set; }
|
|
public double PercentualRuaAtual { get; set; }
|
|
public int QtdPontos { get; set; }
|
|
|
|
public GPSModel PrimeiroPontoDentroMapa { get; set; }
|
|
public GPSModel PrimeiroPontoDentroCana { get; set; }
|
|
public double DistanciaErroMapaCana { get; set; }
|
|
|
|
public AutonomiaCorredorModel AutonomiaCooredor { get; set; }
|
|
|
|
public OperacaoSensoriamentoLogTrajetoriaModel Clone()
|
|
{
|
|
return new OperacaoSensoriamentoLogTrajetoriaModel()
|
|
{
|
|
StatusCarro = StatusCarro,
|
|
TrajetoriaConcluida = TrajetoriaConcluida,
|
|
AnguloCaminho = AnguloCaminho,
|
|
AnguloMedioCorredor = AnguloMedioCorredor,
|
|
DirecaoCaminho = DirecaoCaminho,
|
|
DistanciaDireita = DistanciaDireita,
|
|
DistanciaEsquerda = DistanciaEsquerda,
|
|
CorredorAtual = CorredorAtual.Clone(false),
|
|
ProgressoTrajeto = ProgressoTrajeto,
|
|
DistanciaTotal = DistanciaTotal,
|
|
DistanciaPercorrida = DistanciaPercorrida,
|
|
DistanciaRestante = DistanciaRestante,
|
|
NaMargemDoCorredor = NaMargemDoCorredor,
|
|
ManobrandoEntreRuas = ManobrandoEntreRuas,
|
|
TempoEstimadoRestante = TempoEstimadoRestante,
|
|
TempoEstimadoOperacao = TempoEstimadoOperacao,
|
|
ErroLateralAngular = ErroLateralAngular,
|
|
ErroOrientacaoAngularCombinado = ErroOrientacaoAngularCombinado,
|
|
ErroOrientacaoAngular = ErroOrientacaoAngular,
|
|
ErroOrientacaoAngularCaminho = ErroOrientacaoAngularCaminho,
|
|
ErroOrientacaoAngularProximoPonto = ErroOrientacaoAngularProximoPonto,
|
|
ProximoPonto = ProximoPonto.Clone(),
|
|
PontoAtual = PontoAtual.Clone(),
|
|
PontoMaisProximo = PontoMaisProximo.Clone(),
|
|
IdxRuaAtual = IdxRuaAtual,
|
|
PercentualOperacao = PercentualOperacao,
|
|
PercentualRuaAtual = PercentualRuaAtual,
|
|
QtdPontos = QtdPontos,
|
|
PrimeiroPontoDentroCana = PrimeiroPontoDentroCana.Clone(),
|
|
PrimeiroPontoDentroMapa = PrimeiroPontoDentroMapa.Clone(),
|
|
DistanciaErroMapaCana = DistanciaErroMapaCana,
|
|
AutonomiaCooredor = AutonomiaCooredor.Clone()
|
|
};
|
|
}
|
|
}
|
|
|
|
public class DirSensoriamentoLogModel
|
|
{
|
|
public string Mod_ID { get; set; }
|
|
public byte ID { get; set; }
|
|
public bool Iniciado { get; set; }
|
|
public bool Controlar { get; set; }
|
|
public double Angulo_SP { get; set; }
|
|
public double AnguloDriver { get; set; }
|
|
public double AnguloReal { get; set; }
|
|
public double AnguloLeitura { get; set; }
|
|
public double AnguloFolgaCompensar { get; set; }
|
|
public Sentido Sentido_SP { get; set; }
|
|
public Sentido Sentido { get; set; }
|
|
public Sentido SentidoReal { get; set; }
|
|
public double Velocidade { get; set; }
|
|
public double FolgaMecanica { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class MovSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public string Modulo_ID { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public double RPM_SP { get; set; }
|
|
public double RPM_Motor { get; set; }
|
|
public double RPM_Roda { get; set; }
|
|
public double Velocidade { get; set; }
|
|
public Sentido Sentido_SP { get; set; }
|
|
public Sentido Sentido { get; set; }
|
|
public double Temperatura { get; set; }
|
|
public double TemperaturaDriver { get; set; }
|
|
public double Corrente_Motor { get; set; }
|
|
public double Corrente_Barramento { get; set; }
|
|
public double Tensao { get; set; }
|
|
public double Potencia { get; set; }
|
|
public double CicloTrabalho { get; set; }
|
|
public OidCodigoErro CodAlarme { get; set; }
|
|
public bool AlarmeSensores { get; set; }
|
|
public bool AlarmeComando { get; set; }
|
|
public bool EmFreio { get; set; }
|
|
public bool Ativado { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class AtuSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public int QualidadeWifi { get; set; }
|
|
public int LatenciaLoop { get; set; }
|
|
public double MassaReservatorio { get; set; }
|
|
public double PressaoLinha_SP { get; set; }
|
|
public double PressaoLinha { get; set; }
|
|
public double VolumeReservatorio { get; set; }
|
|
public double PercentualReservatorio { get; set; }
|
|
public double PotenciaBomba { get; set; }
|
|
public bool BombaLigada { get; set; }
|
|
public double VazaoFluxoMLpSInstantanea { get; set; }
|
|
public double VazaoFluxoMLpSMedia { get; set; }
|
|
public double VolumeVazaoML { get; set; }
|
|
public int QuantidadeBicos { get; set; }
|
|
public double TempoPulverizadorAtuado { get; set; }
|
|
public List<AtuBicoSensoriamentoLogModel> Bicos { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
}
|
|
|
|
public class AtuBicoSensoriamentoLogModel
|
|
{
|
|
public string ID { get; set; }
|
|
public int Posicao { get; set; }
|
|
public bool Atuado { get; set; }
|
|
public bool Comandar { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public bool StatusBico { get; set; }
|
|
public double MediaNivelFluxo { get; set; }
|
|
public int Atuacoes { get; set; }
|
|
public double TempoAtuado { get; set; }
|
|
public double AnguloAbertura { get; set; }
|
|
public double AnguloControle { get; set; }
|
|
}
|
|
|
|
public class CamSoloSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public CameraCoordenadasFrameModel Leitura { get; set; }
|
|
}
|
|
|
|
public class CamCaminhoSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public Dictionary<string, Color> ClassMap { get; set; }
|
|
public List<System.Drawing.Point> PontosExtremos { get; set; }
|
|
public double Angulo { get; set; }
|
|
public double AnguloEsquerdo { get; set; }
|
|
public double AnguloDireito { get; set; }
|
|
public CameraDeepLabV3PlusModel Leitura { get; set; }
|
|
public bool Inicializado
|
|
{
|
|
get
|
|
{
|
|
return Leitura?.device_data?.Is_Pipeline_Running ?? false;
|
|
}
|
|
}
|
|
public DateTime UltimaMensagemRecebida { get; set; }
|
|
}
|
|
|
|
public class LraSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public bool Conectado { get; set; }
|
|
public bool Configurado { get; set; }
|
|
public byte EnderecoCarro { get; set; }
|
|
public byte EnderecoBase { get; set; }
|
|
public DateTime UltimoComandoRespondido { get; set; }
|
|
public GPSModel PosicaoBase { get; set; }
|
|
|
|
public LraSensoriamentoLogModel Clone()
|
|
{
|
|
return new LraSensoriamentoLogModel()
|
|
{
|
|
Momento = Momento,
|
|
Conectado = Conectado,
|
|
Configurado = Configurado,
|
|
EnderecoCarro = EnderecoCarro,
|
|
EnderecoBase = EnderecoBase,
|
|
UltimoComandoRespondido = UltimoComandoRespondido,
|
|
PosicaoBase = PosicaoBase.Clone()
|
|
};
|
|
}
|
|
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogErrosModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public T_Code Dispositivo { get; set; }
|
|
public string ID { get; set; }
|
|
public StatusModulo Status { get; set; }
|
|
public double Saude { get; set; }
|
|
public string Mensagem { get; set; }
|
|
public string Condicoes { get; set; }
|
|
}
|
|
|
|
}
|