3173 lines
146 KiB
C#
3173 lines
146 KiB
C#
using AgroBase.Comum;
|
|
using AgroBase.Forms;
|
|
using AgroBase.Forms.Operacoes;
|
|
using AgroBase.Models.Modules;
|
|
using AgroBase.Models.Operacoes;
|
|
using AgroBase.Services;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using static AgroBase.Models.Enums;
|
|
using System.Drawing;
|
|
using System.Text;
|
|
using System.Windows.Forms.DataVisualization.Charting;
|
|
using AgroBase.Forms.IHM;
|
|
using OpenHardwareMonitor.Hardware;
|
|
|
|
namespace AgroBase.Models
|
|
{
|
|
public class OperacaoModel
|
|
{
|
|
|
|
public OperacaoModel(ModoOperacao Modo, DispositivosService<AtuadorModel> Atu = null)
|
|
{
|
|
this.Modo = Modo;
|
|
|
|
this.DispAtu = Atu;
|
|
|
|
if (Modo == ModoOperacao.MapaGPS)
|
|
{
|
|
this.Controle = new OperacaoControleModel()
|
|
{
|
|
PIDdirecional = new PIDModel(),
|
|
TiposControle = new List<OperacaoControleTipoModel>()
|
|
{
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Mov,
|
|
DelayEnvioComando = 500,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Dir,
|
|
DelayEnvioComando = 1000,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Atu,
|
|
DelayEnvioComando = 100,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
},
|
|
};
|
|
this.ControleAnterior = new OperacaoControleModel();
|
|
|
|
this.OpMapaGPS.Sensoriamento.AtuacoesPorBico = new List<int>();
|
|
if (DispAtu != null)
|
|
{
|
|
for (int i = 0; i < DispAtu.Dados.QuantidadeBicos; i++)
|
|
{
|
|
this.OpMapaGPS.Sensoriamento.AtuacoesPorBico.Add(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (tmrLogs == null)
|
|
{
|
|
tmrLogs = new System.Timers.Timer() { Interval = 1000, Enabled = false };
|
|
tmrLogs.Elapsed -= TmrLogs_Elapsed;
|
|
tmrLogs.Elapsed += TmrLogs_Elapsed;
|
|
}
|
|
tmrLogs.Start();
|
|
|
|
if (tmrLeituras == null)
|
|
{
|
|
tmrLeituras = new System.Timers.Timer() { Interval = 500, Enabled = false };
|
|
tmrLeituras.Elapsed -= TmrLeituras_Elapsed;
|
|
tmrLeituras.Elapsed += TmrLeituras_Elapsed;
|
|
}
|
|
tmrLeituras.Start();
|
|
|
|
if (computer == null)
|
|
{
|
|
computer = new Computer()
|
|
{
|
|
CPUEnabled = true,
|
|
GPUEnabled = true,
|
|
RAMEnabled = true,
|
|
HDDEnabled = true,
|
|
};
|
|
computer.Open();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public ModoOperacao Modo { get; set; }
|
|
public string Descricao { get; set; }
|
|
public OperacaoMapaGPSModel OpMapaGPS { get; set; } = new OperacaoMapaGPSModel();
|
|
public OperacaoControleModel Controle { get; set; } = new OperacaoControleModel();
|
|
public OperacaoControleModel ControleAnterior { get; set; } = new OperacaoControleModel();
|
|
public DispositivosService<MovimentacaoUnificadaModel> DispMvd { get; set; }
|
|
public DispositivosService<SensoriamentoModel> DispSen { get; set; }
|
|
public DispositivosService<AtuadorModel> DispAtu { get; set; }
|
|
public MapasModel Mapa { get; set; } = new MapasModel();
|
|
public OperacaoSensoriamentoLogModel Sensoriamento { get; set; } = new OperacaoSensoriamentoLogModel();
|
|
public Form frmOperacao { get; set; }
|
|
private StatusOperacao _EtapaAtual;
|
|
private StatusOperacao _EtapaAnteriorParada = StatusOperacao.Parado;
|
|
public bool Emergencia { get; set; } = false;
|
|
public StatusOperacao StatusAtual
|
|
{
|
|
get
|
|
{
|
|
StatusOperacao etapaAtual = _EtapaAtual;
|
|
|
|
// Se a operação não estiver iniciada
|
|
if (!Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
// Etapa atual não é Finalizado, então a etapa é Parametrizando
|
|
if (_EtapaAtual != StatusOperacao.Concluido)
|
|
{
|
|
etapaAtual = StatusOperacao.Parametrizando;
|
|
}
|
|
else
|
|
{
|
|
//etapaAtual = StatusOperacao.NaoIniciado;
|
|
}
|
|
}
|
|
// Operação em andamento
|
|
else
|
|
{
|
|
// Se a operacao atual for manual
|
|
if (Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.Manual)
|
|
{
|
|
etapaAtual = StatusOperacao.EmAndamento;
|
|
}
|
|
// Se o trajeto foi finalizado
|
|
else if (Variaveis.OperacaoEmAndamento.OpMapaGPS.Concluido && _EtapaAtual != StatusOperacao.Concluido)
|
|
{
|
|
etapaAtual = StatusOperacao.Concluido;
|
|
}
|
|
// Etapa atual é finalizada, então finaliza a operação
|
|
else if (_EtapaAtual == StatusOperacao.Concluido)
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.Iniciado && !Variaveis.OperacaoEmAndamento.Finalizando)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.FinalizarOperacao();
|
|
}
|
|
}
|
|
// Se a operação tiver algum item mandatório interrompido
|
|
else if (!Variaveis.OperacaoEmAndamento.OperacaoLiberada)
|
|
{
|
|
// Da primeira vez, salva a etapa atual anterior à parada para possível retomada
|
|
if (etapaAtual != StatusOperacao.Parado)
|
|
{
|
|
_EtapaAnteriorParada = etapaAtual;
|
|
}
|
|
etapaAtual = StatusOperacao.Parado;
|
|
}
|
|
// Se a etapa atual for parado, mas a operação foi liberada, retoma de onde parou
|
|
else if (etapaAtual == StatusOperacao.Parado && Variaveis.OperacaoEmAndamento.OperacaoLiberada)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.TempoAguardando = DateTime.Now;
|
|
etapaAtual = StatusOperacao.Aguardando;
|
|
}
|
|
// Contagem regressiva para iniciar a operação
|
|
else if (Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) > DateTime.Now)
|
|
{
|
|
etapaAtual = StatusOperacao.Aguardando;
|
|
}
|
|
else if (_EtapaAnteriorParada != StatusOperacao.Parado)
|
|
{
|
|
etapaAtual = _EtapaAnteriorParada;
|
|
_EtapaAnteriorParada = StatusOperacao.Parado;
|
|
}
|
|
else
|
|
{
|
|
etapaAtual = StatusOperacao.EmAndamento;
|
|
}
|
|
}
|
|
|
|
|
|
_EtapaAtual = etapaAtual;
|
|
|
|
//_EtapaAtual = StatusOperacao.EmAndamento;
|
|
|
|
return _EtapaAtual;
|
|
}
|
|
}
|
|
public (bool, List<T_Code>) ModulosConectados
|
|
{
|
|
get
|
|
{
|
|
Variaveis.OperacaoEmAndamento.ModulosMandatorios.ForEach(Modulo =>
|
|
{
|
|
Modulo.Conectado = SerialService.DispositivosMapeados.Any(x => x.Dispositivo == Modulo.Dispositivo && x.Conectado);
|
|
});
|
|
|
|
bool _modulosConectados =
|
|
(Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Mandatorio) && Variaveis.OperacaoEmAndamento.ModulosMandatorios.Where(x => x.Mandatorio).All(x => x.Conectado)) ||
|
|
(Variaveis.OperacaoEmAndamento.ModulosMandatorios.All(x => !x.Mandatorio) && Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Conectado));
|
|
|
|
List<T_Code> _modsComFalha = Variaveis.OperacaoEmAndamento.ModulosMandatorios.Where(x => x.Mandatorio && !x.Conectado).Select(x => x.Dispositivo).ToList();
|
|
|
|
return (_modulosConectados, _modsComFalha);
|
|
}
|
|
}
|
|
public bool DispositivosIndividuaisConectados
|
|
{
|
|
get
|
|
{
|
|
bool _dispositivosConectados = true;
|
|
|
|
// Verificação dos motores BLDC
|
|
if (Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Dispositivo == T_Code.Bld && x.Conectado))
|
|
{
|
|
(bool _EsqOperante, List<string> _EsqModsInoperantes) = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosBLD(Direcao.Esquerda);
|
|
(bool _DirOperante, List<string> _DirModsInoperantes) = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosBLD(Direcao.Direita);
|
|
|
|
// Se qualquer lado estiver completamente inoperante, o robô não pode operar corretamente
|
|
if (!_EsqOperante || !_DirOperante)
|
|
{
|
|
_dispositivosConectados = false;
|
|
}
|
|
}
|
|
|
|
// Verificação dos motores MKS
|
|
if (Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Dispositivo == T_Code.Mks && x.Conectado))
|
|
{
|
|
(bool _MksOperante, List<string> _MksModsInoperantes) = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosMKS(Variaveis.OperacaoEmAndamento.Controle.TipoMovimento);
|
|
|
|
if (!_MksOperante)
|
|
{
|
|
_dispositivosConectados = false;
|
|
}
|
|
}
|
|
|
|
// Verificação dos componentes ATU
|
|
if (Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Dispositivo == T_Code.Atu && x.Conectado))
|
|
{
|
|
(bool _AtuOperante, List<string> _AtuModsInoperantes) = Variaveis.OperacaoEmAndamento.DispAtu.Dados.StatusModulosATU();
|
|
|
|
if (!_AtuOperante)
|
|
{
|
|
_dispositivosConectados = false;
|
|
}
|
|
}
|
|
|
|
// Verificação dos componentes SEN
|
|
if (Variaveis.OperacaoEmAndamento.ModulosMandatorios.Any(x => x.Dispositivo == T_Code.Sen && x.Conectado))
|
|
{
|
|
(bool _SenOperante, List<string> _SenModsInoperantes) = Variaveis.OperacaoEmAndamento.DispSen.Dados.StatusModulosSEN();
|
|
|
|
if (!_SenOperante)
|
|
{
|
|
_dispositivosConectados = false;
|
|
}
|
|
}
|
|
|
|
return _dispositivosConectados;
|
|
}
|
|
}
|
|
public bool OperacaoLiberada
|
|
{
|
|
get
|
|
{
|
|
(bool _modsConectados, List<T_Code> _modsComFalha) = Variaveis.OperacaoEmAndamento.ModulosConectados;
|
|
|
|
bool _operacaoLiberada = _modsConectados;
|
|
|
|
if (_operacaoLiberada && Variaveis.OperacaoEmAndamento.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo && x.Mandatorio) && Variaveis.OperacaoEmAndamento.CamerasSolo.Count(x => x.Iniciada) < Variaveis.OperacaoEmAndamento.QuantidadeCamerasSolo) _operacaoLiberada = false;
|
|
if (_operacaoLiberada && Variaveis.OperacaoEmAndamento.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Kinect && x.Mandatorio) && (Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_Kinect == null || !Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_Kinect.Iniciado)) _operacaoLiberada = false;
|
|
if (_operacaoLiberada && Variaveis.OperacaoEmAndamento.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && x.Mandatorio) && !Variaveis.OperacaoEmAndamento.Mapa.mapaService.Carregado) _operacaoLiberada = false;
|
|
if (_operacaoLiberada && Variaveis.OperacaoEmAndamento.ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick && x.Mandatorio && GeneralJoystick.JoystickConectado == null)) _operacaoLiberada = false;
|
|
if (_operacaoLiberada && !Variaveis.OperacaoEmAndamento.DispositivosIndividuaisConectados) _operacaoLiberada = false;
|
|
|
|
if (frmInstancial.frmPrincipal.chbDebugMode.Checked) _operacaoLiberada = true;
|
|
|
|
if (Variaveis.OperacaoEmAndamento.Emergencia) _operacaoLiberada = false;
|
|
|
|
return _operacaoLiberada;
|
|
}
|
|
}
|
|
public string ErroOperacaoLiberada
|
|
{
|
|
get
|
|
{
|
|
string MensagemErro = "Para iniciar a operação " + Enum.GetName(typeof(ModoOperacao), Modo) +
|
|
", é necessário que todos os módulos mandatórios estejam devidamente conectados ao equipamento, ou pelo menos um dos módulos:\r\n";
|
|
ModulosMandatorios.ForEach(Modulo =>
|
|
{
|
|
MensagemErro += Enum.GetName(typeof(T_Code), Modulo.Dispositivo) + ": ( " + (Modulo.Conectado ? "OK" : " ") + " ) - Mandatório: " + (Modulo.Mandatorio ? "Sim" : "Não") + "\r\n";
|
|
});
|
|
return MensagemErro;
|
|
}
|
|
}
|
|
public bool Iniciado { get; set; }
|
|
public bool Simulando { get; set; } = false;
|
|
public bool Finalizando { get; set; } = false;
|
|
public long TimestampInicio { get; set; }
|
|
public long TimestampFim { get; set; }
|
|
public TimeSpan Tempo
|
|
{
|
|
get
|
|
{
|
|
return TimeSpan.FromTicks(Variaveis.OperacaoEmAndamento.Iniciado ? ((Variaveis.OperacaoEmAndamento.TimestampFim > 0 ? Variaveis.OperacaoEmAndamento.TimestampFim : DateTime.Now.Ticks) - Variaveis.OperacaoEmAndamento.TimestampInicio) : 0);
|
|
}
|
|
}
|
|
public DateTime TempoAguardando { get; set; }
|
|
|
|
public List<OperacaoModulosMandatoriosModel> ModulosMandatorios { get; set; } = new List<OperacaoModulosMandatoriosModel>();
|
|
public List<OperacaoParametrosMandatoriosModel> ParametrosMandatorios { get; set; } = new List<OperacaoParametrosMandatoriosModel>();
|
|
public List<GPSModel> GPSTrajetoria { get; set; } = new List<GPSModel>();
|
|
public List<List<GPSModel>> GPSTrajetoriaRua { get; set; } = new List<List<GPSModel>>();
|
|
public double CapacidadeReservatorio { get; set; } = 30;
|
|
public int QuantidadeCamerasSolo { get; set; } = 2;
|
|
public List<CameraSoloModel> CamerasSolo { get; set; } = new List<CameraSoloModel>();
|
|
public CameraCaminhoModel CameraCaminhoKinect { get; set; }
|
|
public int TempoIniciarOperacao { get; set; } = 25;
|
|
public string ID { get; set; }
|
|
public static double tmrLogsInterval
|
|
{
|
|
get
|
|
{
|
|
return tmrLogs.Interval;
|
|
}
|
|
set
|
|
{
|
|
tmrLogs.Interval = value;
|
|
}
|
|
}
|
|
private static System.Timers.Timer tmrLogs = null;
|
|
private static System.Timers.Timer tmrLeituras = null;
|
|
public Chart chartGraficos = new Chart();
|
|
private static Computer computer;
|
|
public string PerformanceStr
|
|
{
|
|
get
|
|
{
|
|
return FuncoesGlobais.MontarStringPerformance(
|
|
Sensoriamento.GPU_load,
|
|
Sensoriamento.CPU_load,
|
|
Sensoriamento.RAM_usage,
|
|
Sensoriamento.GPU_temp,
|
|
Sensoriamento.CPU_temp
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
#region PARAMETRIZACAO
|
|
|
|
public bool SalvarParametrizacaoOperacao(string descricao, string capacidade, string pressao, string duracao, string percentual, string angulo, string velocidadeMp, string velocidadeServas, string velocidadeCervas)
|
|
{
|
|
if (string.IsNullOrEmpty(descricao))
|
|
{
|
|
MessageBox.Show("Preencha a descrição para identificação da operação!", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return false;
|
|
}
|
|
|
|
double.TryParse(capacidade, out double capacidadeReservatorio);
|
|
double.TryParse(pressao, out double pressaoLinha);
|
|
int.TryParse(duracao, out int duracaoAtuacao);
|
|
int.TryParse(percentual, out int percentualAtuacao);
|
|
int.TryParse(angulo, out int anguloMaximo);
|
|
int.TryParse(velocidadeMp, out int velocidadeMovimento);
|
|
double.TryParse(velocidadeServas, out double velocidadeSemErvas);
|
|
double.TryParse(velocidadeCervas, out double velocidadeComErvas);
|
|
|
|
OperacaoParametrosModel Parametros = new OperacaoParametrosModel()
|
|
{
|
|
Modo = Variaveis.OperacaoEmAndamento.Modo,
|
|
Descricao = descricao,
|
|
AtuCapacidadeReservatorio = capacidadeReservatorio,
|
|
AtuDuracaoAtuacao = duracaoAtuacao,
|
|
AtuPercentualDeteccaoVertical = percentualAtuacao,
|
|
AtuPressaoLinha = pressaoLinha,
|
|
DirAnguloMaximo = anguloMaximo,
|
|
DirVelocidadeMovimento = velocidadeMovimento,
|
|
MovVelocidadeCErvas = velocidadeComErvas,
|
|
MovVelocidadeSErvas = velocidadeSemErvas,
|
|
ModulosMandatorios = Variaveis.OperacaoEmAndamento.ModulosMandatorios,
|
|
Mapa = Variaveis.OperacaoEmAndamento.Mapa
|
|
};
|
|
Parametros.Mapa.lblMapa = null;
|
|
Parametros.Mapa.pnlMapa = null;
|
|
Parametros.Mapa.chromiumWebBrowser = null;
|
|
Parametros.Mapa.mapaService.pythonProcess = null;
|
|
|
|
string ParametrosJson = JsonConvert.SerializeObject(Parametros, Formatting.None);
|
|
SaveFileDialog saveFileDialog = new SaveFileDialog();
|
|
saveFileDialog.Filter = "Arquivo de Operação (*.opr)|*.opr";
|
|
saveFileDialog.DefaultExt = "opr";
|
|
saveFileDialog.AddExtension = true;
|
|
saveFileDialog.InitialDirectory = Variaveis.CaminhoSistema + Variaveis.CaminhoOperacoes;
|
|
if (saveFileDialog.ShowDialog() == DialogResult.OK)
|
|
{
|
|
string filePath = saveFileDialog.FileName;
|
|
|
|
File.WriteAllText(filePath, ParametrosJson, Encoding.UTF8);
|
|
|
|
MessageBox.Show("Operação salva com sucesso!", "Sucesso", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public (bool, List<string>) CarregarParametrizacaoOperacao(Panel pnlMapa, Label lblMapa, string opPath = "")
|
|
{
|
|
string path = Variaveis.CaminhoSistema + Variaveis.CaminhoOperacoes + MapasVariaveisModel.NomeArquivoMapaInterativoSaida;
|
|
|
|
OpenFileDialog openFileDialog = new OpenFileDialog();
|
|
openFileDialog.Filter = "Arquivo de Operação (*.opr)|*.opr";
|
|
openFileDialog.DefaultExt = "opr";
|
|
openFileDialog.AddExtension = true;
|
|
openFileDialog.InitialDirectory = Variaveis.CaminhoSistema + Variaveis.CaminhoOperacoes;
|
|
if (!string.IsNullOrEmpty(opPath) || openFileDialog.ShowDialog() == DialogResult.OK)
|
|
{
|
|
string filePath = !string.IsNullOrEmpty(opPath) ? opPath : openFileDialog.FileName;
|
|
|
|
string ParametrosJson = File.ReadAllText(filePath, Encoding.UTF8);
|
|
|
|
var Parametros = JsonConvert.DeserializeObject<OperacaoParametrosModel>(ParametrosJson);
|
|
|
|
Variaveis.OperacaoEmAndamento = CarregarParametrosOperacaoPadrao(Parametros.Modo);
|
|
|
|
OperacaoControleModel controle = new OperacaoControleModel()
|
|
{
|
|
RPM_Max = Convert.ToInt32(MovimentacaoModel.CalculaRPMVelocidade(Parametros.MovVelocidadeSErvas)),
|
|
RPM_Min = Convert.ToInt32(MovimentacaoModel.CalculaRPMVelocidade(Parametros.MovVelocidadeCErvas)),
|
|
Angulo_Max = Parametros.DirAnguloMaximo,
|
|
Angulo_Min = Parametros.DirAnguloMaximo * -1,
|
|
VelocidadeMP = Parametros.DirVelocidadeMovimento,
|
|
TempoAtuacao = Parametros.AtuDuracaoAtuacao,
|
|
PercentualInicioPulverizacao = Parametros.AtuPercentualDeteccaoVertical / 100.0,
|
|
PressaoLinha = Parametros.AtuPressaoLinha,
|
|
Angulo = 0,
|
|
Direcao = Direcao.Parado,
|
|
PercentualVelocidadeSP = 0,
|
|
PIDdirecional = new PIDModel(),
|
|
TiposControle = Variaveis.OperacaoEmAndamento.Controle.TiposControle.ToList()
|
|
};
|
|
|
|
Variaveis.OperacaoEmAndamento.ModulosMandatorios = Parametros.ModulosMandatorios.ToList();
|
|
Variaveis.OperacaoEmAndamento.CapacidadeReservatorio = Parametros.AtuCapacidadeReservatorio;
|
|
Variaveis.OperacaoEmAndamento.Controle = controle;
|
|
Variaveis.OperacaoEmAndamento.Descricao = Parametros.Descricao;
|
|
|
|
List<string> ruasSelecionadas = new List<string>();
|
|
if (Parametros.Mapa.mapaService.DadosMapa != null)
|
|
{
|
|
ruasSelecionadas = Parametros.Mapa.RuasPercorrer.ToList();
|
|
string geoJson = JsonConvert.SerializeObject(Parametros.Mapa.mapaService.DadosMapa, Formatting.None);
|
|
File.WriteAllText(path, geoJson, Encoding.UTF8);
|
|
Variaveis.OperacaoEmAndamento.Mapa = Parametros.Mapa;
|
|
|
|
/*Panel pnlMapa = FuncoesGlobais.FindControlRecursive<Panel>(Variaveis.OperacaoEmAndamento.frmOperacao, "pnlMapa");
|
|
Label lblMapa = FuncoesGlobais.FindControlRecursive<Label>(Variaveis.OperacaoEmAndamento.frmOperacao, "lblMapaCarregado");*/
|
|
Variaveis.OperacaoEmAndamento.Mapa.pnlMapa = pnlMapa;
|
|
Variaveis.OperacaoEmAndamento.Mapa.lblMapa = lblMapa;
|
|
|
|
Variaveis.OperacaoEmAndamento.Mapa.btnCarregar_Click(new object(), new EventArgs(), path);
|
|
}
|
|
|
|
return (true, ruasSelecionadas);
|
|
}
|
|
else
|
|
{
|
|
return (false, new List<string>());
|
|
}
|
|
}
|
|
|
|
public string TempoEstimadoOperacao(double velocidadeSemErvas, double velocidadeComErvas)
|
|
{
|
|
double velocidadeDirecionamento = velocidadeSemErvas * 0.6;
|
|
|
|
// Conversão de velocidades para m/s
|
|
double velocidadeSemErvasMs = (velocidadeSemErvas * 1000) / 3600;
|
|
double velocidadeComErvasMs = (velocidadeComErvas * 1000) / 3600;
|
|
double velocidadeTrajetoriaMs = (velocidadeDirecionamento * 1000) / 3600;
|
|
|
|
// Supondo que metade do percurso tem ervas e a outra metade não tem
|
|
double distanciaSemErvas = Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal * VariaveisOperacao.PercentualSemErvas;
|
|
double distanciaComErvas = Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal * VariaveisOperacao.PercentualComErvas;
|
|
double distanciaTrajetoria = Variaveis.OperacaoEmAndamento.Mapa.DistanciaExtraTrajetoria;
|
|
|
|
// Tempo em segundos para cada parte do percurso
|
|
double tempoSemErvas = distanciaSemErvas / velocidadeSemErvasMs;
|
|
double tempoComErvas = distanciaComErvas / velocidadeComErvasMs;
|
|
double tempoDirecionamento = distanciaTrajetoria / velocidadeTrajetoriaMs;
|
|
|
|
double tempoManobras = Variaveis.OperacaoEmAndamento.Mapa.RuasPercorrer.Count() * VariaveisOperacao.TempoManobra;
|
|
|
|
// Tempo total em segundos
|
|
double tempoTotalSegundos = tempoSemErvas + tempoComErvas + tempoDirecionamento + tempoManobras;
|
|
|
|
// Conversão para horas, minutos e segundos
|
|
TimeSpan tempoTotal = TimeSpan.FromSeconds(tempoTotalSegundos);
|
|
|
|
return $"{tempoTotal.Hours:D2}:{tempoTotal.Minutes:D2}:{tempoTotal.Seconds:D2}";
|
|
}
|
|
|
|
public string TempoEstimadoRestante()
|
|
{
|
|
// Velocidades em RPM
|
|
double velocidadeSemErvas = MovimentacaoModel.CalculaVelocidadeRPM(Variaveis.OperacaoEmAndamento.Controle.RPM_Max);
|
|
double velocidadeComErvas = MovimentacaoModel.CalculaVelocidadeRPM(Variaveis.OperacaoEmAndamento.Controle.RPM_Min);
|
|
double velocidadeDirecionamento = velocidadeSemErvas * 0.6;
|
|
|
|
// Conversão de velocidades para m/s
|
|
double velocidadeSemErvasMs = (velocidadeSemErvas * 1000) / 3600;
|
|
double velocidadeComErvasMs = (velocidadeComErvas * 1000) / 3600;
|
|
double velocidadeTrajetoriaMs = (velocidadeDirecionamento * 1000) / 3600;
|
|
|
|
// Distâncias (em metros)
|
|
double distanciaTotal = (Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal + Variaveis.OperacaoEmAndamento.Mapa.DistanciaExtraTrajetoria);
|
|
double distanciaDirecionamento = Variaveis.OperacaoEmAndamento.Mapa.DistanciaExtraTrajetoria;
|
|
double distanciaPercorrida = GPSService.DistanciaDoTrecho(Variaveis.OperacaoEmAndamento.GPSTrajetoria);
|
|
double distanciaRestante = distanciaTotal - distanciaPercorrida;
|
|
|
|
// Variáveis para armazenar o tempo restante para cada parte
|
|
double tempoRestanteDirecionamento = 0;
|
|
|
|
// Se o robô ainda estiver na fase de direcionamento
|
|
if (distanciaPercorrida < distanciaDirecionamento)
|
|
{
|
|
// Calcula o tempo restante apenas para a fase de direcionamento
|
|
double distanciaDirecionamentoRestante = distanciaDirecionamento - distanciaPercorrida;
|
|
tempoRestanteDirecionamento = distanciaDirecionamentoRestante / velocidadeTrajetoriaMs;
|
|
distanciaRestante = Variaveis.OperacaoEmAndamento.Mapa.DistanciaTotal;
|
|
}
|
|
|
|
// Calcular a distância restante sem ervas e com ervas
|
|
double distanciaSemErvasRestante = distanciaRestante * VariaveisOperacao.PercentualSemErvas;
|
|
|
|
double distanciaComErvasRestante = distanciaRestante * VariaveisOperacao.PercentualComErvas;
|
|
|
|
// Calcular o tempo restante para as áreas sem ervas e com ervas
|
|
double tempoRestanteSemErvas = distanciaSemErvasRestante / velocidadeSemErvasMs;
|
|
double tempoRestanteComErvas = distanciaComErvasRestante / velocidadeComErvasMs;
|
|
|
|
// Tempo restante para as manobras
|
|
double tempoRestanteManobras = Variaveis.OperacaoEmAndamento.Mapa.TrajetoriaProjetada.Count() * VariaveisOperacao.TempoManobra;
|
|
|
|
// Tempo total restante em segundos
|
|
double tempoTotalRestanteSegundos = tempoRestanteDirecionamento + tempoRestanteSemErvas + tempoRestanteComErvas + tempoRestanteManobras;
|
|
|
|
// Conversão para horas, minutos e segundos
|
|
TimeSpan tempoTotalRestante = TimeSpan.FromSeconds(tempoTotalRestanteSegundos);
|
|
|
|
return $"{tempoTotalRestante.Hours:D2}:{tempoTotalRestante.Minutes:D2}:{tempoTotalRestante.Seconds:D2}";
|
|
}
|
|
|
|
|
|
|
|
public static OperacaoModel CarregarParametrosOperacaoPadrao(ModoOperacao Modo)
|
|
{
|
|
var SenConectado = (DispositivosService<SensoriamentoModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Sen);
|
|
var AtuConectado = (DispositivosService<AtuadorModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Atu);
|
|
var MvdConectado = (DispositivosService<MovimentacaoUnificadaModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Mvd);
|
|
|
|
tmrLogs.Stop();
|
|
|
|
OperacaoModel OperacaoCarregar = new OperacaoModel(Modo)
|
|
{
|
|
Iniciado = false,
|
|
TimestampInicio = 0,
|
|
TimestampFim = 0,
|
|
DispAtu = AtuConectado,
|
|
DispSen = SenConectado,
|
|
DispMvd = MvdConectado,
|
|
Sensoriamento = new OperacaoSensoriamentoLogModel(),
|
|
};
|
|
|
|
|
|
switch (Modo)
|
|
{
|
|
case ModoOperacao.Manual:
|
|
//OperacaoCarregar.frmOperacao = (Form)Activator.CreateInstance(Variaveis.OperacaoEmAndamento.OpManual.frmOperacao.GetType());
|
|
OperacaoCarregar.frmOperacao = new frmOperacaoManual();
|
|
OperacaoCarregar.Controle = new OperacaoControleModel()
|
|
{
|
|
RPM_Max = 100,
|
|
RPM_Min = 15,
|
|
Angulo_Max = 25,
|
|
Angulo_Min = -25,
|
|
VelocidadeMP = 75,
|
|
TiposControle = new List<OperacaoControleTipoModel>()
|
|
{
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Mov,
|
|
DelayEnvioComando = 10,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Dir,
|
|
DelayEnvioComando = 10,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Atu,
|
|
DelayEnvioComando = 10,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
}
|
|
},
|
|
};
|
|
OperacaoCarregar.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
|
|
{
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Bld,
|
|
Mandatorio = false
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Mks,
|
|
Mandatorio = false
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Atu,
|
|
Mandatorio = false
|
|
}
|
|
};
|
|
OperacaoCarregar.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
|
|
{
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.Joystick,
|
|
Mandatorio = false,
|
|
}
|
|
};
|
|
//OperacaoCarregar.Sensoriamento.SonarFrontal_old = new SonarModel(FuncoesGlobais.FindControlRecursive<PictureBox>(OperacaoCarregar.frmOperacao, "picSonar"));
|
|
break;
|
|
case ModoOperacao.MapaGPS:
|
|
//OperacaoCarregar.frmOperacao = (Form)Activator.CreateInstance(Variaveis.OperacaoEmAndamento.OpMapaGPS.frmOperacao.GetType());
|
|
OperacaoCarregar.frmOperacao = new frmOperacaoMapaGPS();
|
|
OperacaoCarregar.ControleAnterior = new OperacaoControleModel();
|
|
OperacaoCarregar.Controle = new OperacaoControleModel()
|
|
{
|
|
RPM_Max = 100,
|
|
RPM_Min = 15,
|
|
Angulo_Max = 30,
|
|
Angulo_Min = -30,
|
|
VelocidadeMP = 50,
|
|
TiposControle = new List<OperacaoControleTipoModel>()
|
|
{
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Mov,
|
|
DelayEnvioComando = 500,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Dir,
|
|
DelayEnvioComando = 1000,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
new OperacaoControleTipoModel()
|
|
{
|
|
Tipo = T_Code.Atu,
|
|
DelayEnvioComando = 500,
|
|
Comandos = new List<string>(),
|
|
UltimoComando = DateTime.Now
|
|
},
|
|
},
|
|
};
|
|
OperacaoCarregar.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
|
|
{
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Bld,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Mks,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Atu,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Gps,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Sen,
|
|
Mandatorio = false,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Wit,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Pzm,
|
|
Mandatorio = true,
|
|
}
|
|
};
|
|
OperacaoCarregar.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
|
|
{
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.CameraSolo,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.Kinect,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.Mapa,
|
|
Mandatorio = true,
|
|
}
|
|
};
|
|
OperacaoCarregar.OpMapaGPS.Sensoriamento = new OperacaoMapaGPSSensoriamentoModel();
|
|
if (OperacaoCarregar.DispAtu != null)
|
|
{
|
|
for (int i = 0; i < OperacaoCarregar.DispAtu.Dados.QuantidadeBicos; i++)
|
|
{
|
|
OperacaoCarregar.OpMapaGPS.Sensoriamento.AtuacoesPorBico.Add(0);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
OperacaoCarregar.AtualizaListaCameras(null, new List<Panel>(), false);
|
|
|
|
if (OperacaoCarregar.DispSen != null && OperacaoCarregar.DispSen.Dados.Conectado)
|
|
{
|
|
OperacaoCarregar.DispSen.Dados.Sinaleiros.ForEach(x => x.Comportamento = VariaveisEquipamento.ComportamentoPorStatus(StatusOperacao.NaoIniciado));
|
|
|
|
OperacaoCarregar.DispSen.Dados.Sinaleiros.First(x => x.ID == (Modo == ModoOperacao.Manual ? "LEDMN" : "LEDAT")).Comportamento.statusLED = StatusLED.Aceso;
|
|
OperacaoCarregar.DispSen.Dados.Sinaleiros.First(x => x.ID == "LEDOP").Comportamento = VariaveisEquipamento.ComportamentoPorStatus();
|
|
|
|
|
|
//OperacaoCarregar.DispSen.Dados.Sinaleiros.ForEach(x => OperacaoCarregar.DispSen.AdicionarMensagemFila(OperacaoCarregar.DispSen.Dados.Modulo_ID, x.ProtocoloComando(), true, false));
|
|
foreach (var Sinaleiro in OperacaoCarregar.DispSen.Dados.Sinaleiros)
|
|
{
|
|
GeneralJoystick.EnviarComandoSensoriamento(S_Code.sLED, Sinaleiro.ID, Sinaleiro.Comportamento);
|
|
}
|
|
}
|
|
|
|
OperacaoCarregar.Controle.Angulo = OperacaoCarregar.Controle.Angulo_Max;
|
|
OperacaoCarregar.Controle.PercentualVelocidadeSP = OperacaoCarregar.Controle.PercentualVelocidadeMin;
|
|
|
|
return OperacaoCarregar;
|
|
}
|
|
|
|
public static void SalvarOperacaoPersonalizada(OperacaoModel Operacao)
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.MapaGPS)
|
|
{
|
|
Operacao.OpMapaGPS.frmOperacaoNome = Operacao.OpMapaGPS.frmOperacao.Name;
|
|
Form frm = Operacao.OpMapaGPS.frmOperacao;
|
|
|
|
Operacao.OpMapaGPS.frmOperacao = null;
|
|
|
|
//File.WriteAllText("operacao" + Enum.GetName(typeof(ModoOperacao), Operacao.Modo) + ".opr", JsonConvert.SerializeObject(Operacao));
|
|
|
|
Operacao.OpMapaGPS.frmOperacao = frm;
|
|
}
|
|
|
|
}
|
|
|
|
public static OperacaoModel CarregarOperacaoPersonalizada(string nomeArquivo)
|
|
{
|
|
string modoOpStr = nomeArquivo.Split('\\')[nomeArquivo.Split('\\').Length - 1].Replace("operacao", "").Split('.')[0];
|
|
ModoOperacao modo = (ModoOperacao)Enum.Parse(typeof(ModoOperacao), modoOpStr);
|
|
return CarregarParametrosOperacaoPadrao(modo);
|
|
|
|
OperacaoModel Operacao = new OperacaoModel(modo);
|
|
if (!File.Exists(nomeArquivo))
|
|
{
|
|
Operacao = CarregarParametrosOperacaoPadrao(modo);
|
|
SalvarOperacaoPersonalizada(Operacao);
|
|
}
|
|
|
|
var operacaoText = File.ReadAllText(nomeArquivo);
|
|
Operacao = JsonConvert.DeserializeObject<OperacaoModel>(operacaoText);
|
|
|
|
Type tipoDoForm = Type.GetType(Operacao.OpMapaGPS.frmOperacaoNome);
|
|
if (tipoDoForm != null)
|
|
{
|
|
Operacao.OpMapaGPS.frmOperacao = (Form)Activator.CreateInstance(tipoDoForm);
|
|
}
|
|
|
|
return Operacao;
|
|
}
|
|
|
|
|
|
public async Task IniciarOperacao(OperacaoControleModel controle = null, bool DaIHM = true)
|
|
{
|
|
Iniciado = true;
|
|
Simulando = false;
|
|
TimestampInicio = DateTime.Now.Ticks;
|
|
TempoAguardando = DateTime.Now;
|
|
TimestampFim = 0;
|
|
Mapa.IdxRuaAtual = 0;
|
|
if (DispMvd != null)
|
|
{
|
|
DispMvd.Dados.DistanciaPercorridaOperacao = 0;
|
|
DispMvd.Dados.TempoEmAtividade = 0;
|
|
}
|
|
Sensoriamento.DistanciaPercorrida = new List<double>();
|
|
if (Modo == ModoOperacao.MapaGPS)
|
|
{
|
|
OpMapaGPS.Sensoriamento = new OperacaoMapaGPSSensoriamentoModel();
|
|
if (DispAtu != null)
|
|
{
|
|
DispAtu.Dados.BombaPressurizadora.BombaAtuada = false;
|
|
for (int i = 0; i < DispAtu.Dados.QuantidadeBicos; i++)
|
|
{
|
|
OpMapaGPS.Sensoriamento.AtuacoesPorBico.Add(0);
|
|
DispAtu.Dados.BicosPulverizadores[i].Atuado = false;
|
|
}
|
|
DispAtu.Dados.VolumeVazaoML = 0;
|
|
}
|
|
Controle.PIDdirecional = new PIDModel()
|
|
{
|
|
LimiteSaida = Controle.Angulo_Max,
|
|
SetPoint = 0,
|
|
Kp = 1.0,
|
|
Ki = 0.1,
|
|
Kd = 0.01,
|
|
};
|
|
if (controle != null)
|
|
{
|
|
Controle = controle;
|
|
}
|
|
}
|
|
GPSTrajetoria = new List<GPSModel>();
|
|
ID = (new DateTime(TimestampInicio)).ToString("dd_MM_yyyy_HH_mm_ss");
|
|
idxLog = 0;
|
|
|
|
Directory.CreateDirectory(Variaveis.CaminhoOperacoes + ID + "/");
|
|
|
|
await RealizarCalibracaoInicialAsync();
|
|
|
|
Mapa.ReiniciarTrajetoriaDinamica();
|
|
Mapa.GerarTrajetoriaDinamica();
|
|
}
|
|
|
|
public void FinalizarOperacao()
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Finalizando = true;
|
|
|
|
if (!Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.CamerasSolo.ForEach(Camera =>
|
|
{
|
|
Camera.DesligarCamera();
|
|
});
|
|
Variaveis.OperacaoEmAndamento.CameraCaminhoKinect.DesligarCamera();
|
|
}
|
|
|
|
PararCarroOperacaoInterrompida();
|
|
|
|
if (Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombaPressurizadora.Inicializado)
|
|
{
|
|
GeneralJoystick.EnviarComandoAtuador(S_Code.sBMB, false);
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.Iniciado = false;
|
|
Variaveis.OperacaoEmAndamento.TimestampFim = DateTime.Now.Ticks;
|
|
|
|
//tmrLogs.Stop();
|
|
//tmrParametrizacao.Start();
|
|
|
|
if (!Variaveis.OperacaoEmAndamento.Simulando)
|
|
{
|
|
SalvarLogs(false);
|
|
}
|
|
|
|
AtualizarSinaleiroOperacao();
|
|
|
|
Variaveis.OperacaoEmAndamento.Finalizando = false;
|
|
}
|
|
|
|
public async Task RealizarCalibracaoInicialAsync()
|
|
{
|
|
if (DispAtu != null)
|
|
{
|
|
// Ligar bomba
|
|
if (DispAtu.Dados.BombaPressurizadora.Inicializado)
|
|
{
|
|
GeneralJoystick.EnviarComandoAtuador(S_Code.sBMB, true);
|
|
|
|
await Task.Delay(5000);
|
|
}
|
|
|
|
// Testar os bicos
|
|
for (int i = 0; i < DispAtu.Dados.QuantidadeBicos; i++)
|
|
{
|
|
var Bico = DispAtu.Dados.BicosPulverizadores[i];
|
|
if (Bico.Inicializado)
|
|
{
|
|
GeneralJoystick.EnviarComandoAtuador(S_Code.sBIC, true, Bico.ID);
|
|
|
|
await Task.Delay(500);
|
|
|
|
GeneralJoystick.EnviarComandoAtuador(S_Code.sBIC, false, Bico.ID);
|
|
}
|
|
}
|
|
|
|
await Task.Delay(1000);
|
|
}
|
|
|
|
if (KinectService.Iniciado)
|
|
{
|
|
KinectService.RecalibrarSubdivisoes();
|
|
}
|
|
}
|
|
|
|
|
|
public void IniciarSimulacao()
|
|
{
|
|
Iniciado = true;
|
|
Simulando = true;
|
|
TimestampInicio = DateTime.Now.Ticks;
|
|
TempoAguardando = DateTime.Now;
|
|
TimestampFim = 0;
|
|
Mapa.IdxRuaAtual = 0;
|
|
if (DispMvd != null)
|
|
{
|
|
DispMvd.Dados.DistanciaPercorridaOperacao = 0;
|
|
DispMvd.Dados.TempoEmAtividade = 0;
|
|
}
|
|
Sensoriamento.DistanciaPercorrida = new List<double>();
|
|
if (Modo == ModoOperacao.MapaGPS)
|
|
{
|
|
OpMapaGPS.Sensoriamento = new OperacaoMapaGPSSensoriamentoModel();
|
|
if (DispAtu != null)
|
|
{
|
|
DispAtu.Dados.BombaPressurizadora.BombaAtuada = false;
|
|
for (int i = 0; i < DispAtu.Dados.QuantidadeBicos; i++)
|
|
{
|
|
OpMapaGPS.Sensoriamento.AtuacoesPorBico.Add(0);
|
|
DispAtu.Dados.BicosPulverizadores[i].Atuado = false;
|
|
}
|
|
DispAtu.Dados.VolumeVazaoML = 0;
|
|
}
|
|
Controle.PIDdirecional = new PIDModel()
|
|
{
|
|
LimiteSaida = Controle.Angulo_Max,
|
|
SetPoint = 0,
|
|
Kp = 1.0,
|
|
Ki = 0.1,
|
|
Kd = 0.01,
|
|
};
|
|
}
|
|
GPSTrajetoria = new List<GPSModel>();
|
|
|
|
Mapa.ReiniciarTrajetoriaDinamica();
|
|
Mapa.GerarTrajetoriaDinamica();
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region CAMERAS
|
|
|
|
public void AtualizaListaCameras(Panel pnlCameraCaminho, List<Panel> pnlCameraSolo, bool Iniciar)
|
|
{
|
|
if (DispSen == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var listaCameras = CameraService.AtualizaListaCameras().Values.ToArray();
|
|
|
|
CamerasSolo.Clear();
|
|
for (int i = 0; i < QuantidadeCamerasSolo; i++)
|
|
{
|
|
string CamNome = "Cam_Solo_" + i.ToString();
|
|
CameraSoloModel CameraSolo = CameraSolo = new CameraSoloModel()
|
|
{
|
|
ID = "S" + i.ToString(),
|
|
Nome = CamNome,
|
|
Posicao = CamerasSolo.Count(),
|
|
ArquivoLeitura = "ervas_" + CamNome + ".json",
|
|
browser = null,
|
|
camera = new CameraService(),
|
|
CameraSelecionada = DispSen.Dados.CameraID_Solo[i],
|
|
combo = new ComboBox(),
|
|
MaxLeituras = 10,
|
|
VideoPorta = (VariaveisPortas.CameraSolo + CamerasSolo.Count()).ToString(),
|
|
VideoUrl = "green_objects_" + CamNome,
|
|
MqttTopico = "green_objects_" + CamNome,
|
|
};
|
|
CamerasSolo.Add(CameraSolo);
|
|
CameraSolo.camera.selectedCamera = listaCameras.ToList().IndexOf(CameraSolo.CameraSelecionada);
|
|
if (CameraSolo.camera.selectedCamera > 0 && Iniciar)
|
|
{
|
|
CameraSolo.panel = pnlCameraSolo[i];
|
|
IniciarCameraSolo(CameraSolo);
|
|
}
|
|
}
|
|
|
|
var cameraCaminho = new CameraCaminhoModel()
|
|
{
|
|
ID = "C",
|
|
Nome = "Cam_Caminho",
|
|
ArquivoLeitura = "leitura_ruas.json",
|
|
browser = null,
|
|
camera = new CameraService(),
|
|
MaxLeituras = 1,
|
|
Angulo = 0,
|
|
AnguloDireito = 0,
|
|
AnguloEsquerdo = 0,
|
|
Leitura = new CameraDeepLabV3PlusModel(),
|
|
PontosExtremos = new List<System.Drawing.Point>()
|
|
};
|
|
CameraCaminhoKinect = cameraCaminho;
|
|
CameraCaminhoKinect.camera.selectedCamera = KinectService.Iniciado ? 1 : 0;
|
|
if (CameraCaminhoKinect.camera.selectedCamera > 0 && Iniciar)
|
|
{
|
|
CameraCaminhoKinect.panel = pnlCameraCaminho;
|
|
IniciarCameraCaminho(CameraCaminhoKinect);
|
|
}
|
|
}
|
|
|
|
public void IniciarCameraSolo(CameraSoloModel CameraSolo)
|
|
{
|
|
DesligarCameraSolo(CameraSolo);
|
|
|
|
if (CameraSolo.camera.selectedCamera > 0)
|
|
{
|
|
CameraSolo.camera.IniciarCamera(
|
|
DispAtu.Dados.ScriptDeteccaoErvas,
|
|
new string[] {
|
|
CameraSolo.MaxLeituras.ToString(),
|
|
CameraSolo.VideoPorta,
|
|
CameraSolo.VideoUrl,
|
|
CameraSolo.ArquivoLeitura,
|
|
"1",
|
|
CameraSolo.MqttTopico
|
|
},
|
|
CameraSolo.VideoPorta,
|
|
CameraSolo.VideoUrl,
|
|
CameraSolo.MqttTopico,
|
|
CameraSolo.tmrProcesso
|
|
);
|
|
}
|
|
else
|
|
{
|
|
Console.Write("Camera " + CameraSolo.Nome + " não foi configurada!");
|
|
}
|
|
}
|
|
|
|
public void DesligarCameraSolo(CameraSoloModel CameraSolo)
|
|
{
|
|
CameraSolo.DesligarCamera();
|
|
}
|
|
|
|
public void IniciarCameraCaminho(CameraCaminhoModel cameraCaminho)
|
|
{
|
|
DesligarCameraCaminho(cameraCaminho);
|
|
|
|
if (cameraCaminho.camera.selectedCamera > 0)
|
|
{
|
|
cameraCaminho.InicializarCamera();
|
|
cameraCaminho.camera.IniciarCamera(
|
|
PythonService.ScriptStreetDetector,
|
|
new string[] {
|
|
CamerasVaraiveisModel.TopicoRecebimentoBitmap,
|
|
CamerasVaraiveisModel.TopicoEnvioBitmap,
|
|
},
|
|
cameraCaminho.VideoPorta,
|
|
cameraCaminho.VideoUrl,
|
|
CamerasVaraiveisModel.TopicoRecebimentoBitmap,
|
|
cameraCaminho.tmrProcesso
|
|
);
|
|
}
|
|
}
|
|
|
|
public void DesligarCameraCaminho(CameraCaminhoModel cameraCaminho)
|
|
{
|
|
cameraCaminho.DesligarCamera();
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
#region CONTROLE DA OPERACAO
|
|
|
|
public void AtualizarDadosControle(bool ForcarEnvio)
|
|
{
|
|
DateTime Agora = DateTime.Now;
|
|
|
|
var _Controle = Variaveis.OperacaoEmAndamento.Controle;
|
|
var _ControleAnterior = Variaveis.OperacaoEmAndamento.ControleAnterior;
|
|
|
|
OperacaoControleTipoModel ControleMov = _Controle.TiposControle != null ? _Controle.TiposControle.FirstOrDefault(x => x.Tipo == T_Code.Mov) : null;
|
|
OperacaoControleTipoModel ControleDir = _Controle.TiposControle != null ? _Controle.TiposControle.FirstOrDefault(x => x.Tipo == T_Code.Dir) : null;
|
|
OperacaoControleTipoModel ControleAtu = _Controle.TiposControle != null ? _Controle.TiposControle.FirstOrDefault(x => x.Tipo == T_Code.Atu) : null;
|
|
|
|
if (ControleMov != null && _Controle.RPM_SP != _ControleAnterior.RPM_SP && (Agora - ControleMov.UltimoComando).TotalMilliseconds > ControleMov.DelayEnvioComando)
|
|
{
|
|
// Enviar comando MOV
|
|
var Protocolos = EnviarProtocoloComando(Variaveis.OperacaoEmAndamento.DispMvd, T_Code.Mov, ForcarEnvio);
|
|
ControleMov.UltimoComando = Agora;
|
|
ControleMov.Comandos.AddRange(Protocolos);
|
|
|
|
_ControleAnterior.PercentualVelocidadeSP = _Controle.PercentualVelocidadeSP;
|
|
}
|
|
if (ControleDir != null && Convert.ToInt32(_Controle.Angulo) != Convert.ToInt32(_ControleAnterior.Angulo) && (Agora - ControleDir.UltimoComando).TotalMilliseconds > ControleDir.DelayEnvioComando)
|
|
{
|
|
// Enviar comando DIR
|
|
var Protocolos = EnviarProtocoloComando(Variaveis.OperacaoEmAndamento.DispMvd, T_Code.Dir, ForcarEnvio);
|
|
ControleDir.UltimoComando = Agora;
|
|
ControleDir.Comandos.AddRange(Protocolos);
|
|
|
|
_ControleAnterior.Angulo = _Controle.Angulo;
|
|
}
|
|
if (ControleAtu != null && !_Controle.BicosAtuados.Select(x => x.Atuado).SequenceEqual(_ControleAnterior.BicosAtuados.Select(x => x.Atuado)) && (Agora - ControleAtu.UltimoComando).TotalMilliseconds > ControleAtu.DelayEnvioComando)
|
|
{
|
|
// Enviar comando ATU
|
|
var Protocolos = EnviarProtocoloComando(Variaveis.OperacaoEmAndamento.DispAtu, T_Code.Atu, ForcarEnvio);
|
|
ControleAtu.UltimoComando = Agora;
|
|
ControleAtu.Comandos.AddRange(Protocolos);
|
|
|
|
_ControleAnterior.BicosAtuados = new List<AtuadorBicoModel>();
|
|
foreach (var bico in _Controle.BicosAtuados)
|
|
{
|
|
_ControleAnterior.BicosAtuados.Add(bico.Clone());
|
|
}
|
|
}
|
|
|
|
AtualizarDadosOperacao();
|
|
}
|
|
|
|
public List<string> EnviarProtocoloComando(IDispositivosService Dispositivo, T_Code Tipo, bool ForcarEnvio)
|
|
{
|
|
if (Dispositivo == null || !Iniciado)
|
|
{
|
|
return new List<string>();
|
|
}
|
|
|
|
var _Controle = Variaveis.OperacaoEmAndamento.Controle;
|
|
var _ControleAnterior = Variaveis.OperacaoEmAndamento.ControleAnterior;
|
|
|
|
if (Tipo == T_Code.Mov)
|
|
{
|
|
if (_Controle.RPM_SP == 0)
|
|
{
|
|
_Controle.Direcao = Direcao.Parado;
|
|
}
|
|
else
|
|
{
|
|
if (_Controle.RPM_SP < 0)
|
|
{
|
|
_Controle.PercentualVelocidadeSP *= -1;
|
|
_Controle.Direcao = Direcao.Tras;
|
|
}
|
|
else
|
|
{
|
|
_Controle.Direcao = Direcao.Frente;
|
|
}
|
|
}
|
|
}
|
|
else if (Tipo == T_Code.Dir)
|
|
{
|
|
if (_Controle.Angulo < 0)
|
|
{
|
|
_Controle.Angulo *= -1;
|
|
if (_ControleAnterior.Angulo < _Controle.Angulo)
|
|
{
|
|
_Controle.Direcao = Direcao.Parado;
|
|
}
|
|
else
|
|
{
|
|
_Controle.Direcao = Direcao.Esquerda;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_ControleAnterior.Angulo > _Controle.Angulo)
|
|
{
|
|
_Controle.Direcao = Direcao.Parado;
|
|
}
|
|
else
|
|
{
|
|
_Controle.Direcao = Direcao.Direita;
|
|
}
|
|
}
|
|
}
|
|
|
|
GeneralJoystick.EnviaComandoMotor(
|
|
_Controle.Direcao == Direcao.Frente ? Keys.Up :
|
|
_Controle.Direcao == Direcao.Tras ? Keys.Down :
|
|
_Controle.Direcao == Direcao.Esquerda ? Keys.Left :
|
|
_Controle.Direcao == Direcao.Direita ? Keys.Right :
|
|
Keys.Escape, Tipo, ForcarEnvio);
|
|
|
|
/*var Protocolos =
|
|
Tipo == T_Code.Mov ? ((MovimentacaoUnificadaModel)Dispositivo.Dados).Modulos.Select(x => new { Mod_ID = x.Modulo_ID, Protocolo = x.MovMotor.ProtocoloComando(Controle.Direcao) }) :
|
|
Tipo == T_Code.Dir ? ((MovimentacaoUnificadaModel)Dispositivo.Dados).Modulos.Select(x => new { Mod_ID = x.Modulo_ID, Protocolo = x.DirMotor.ProtocoloComando(Controle.Direcao) }) :
|
|
Tipo == T_Code.Atu ? ((AtuadorModel)Dispositivo.Dados).BicosPulverizadores.Select(x => new { Mod_ID = ((AtuadorModel)Dispositivo.Dados).Modulo_ID, Protocolo = x.ProtocoloComando() }) :
|
|
null;
|
|
foreach (var Protocolo in Protocolos)
|
|
{
|
|
Dispositivo.AdicionarMensagemFila(Protocolo.Mod_ID, Protocolo.Protocolo, true, false);
|
|
}
|
|
return Protocolos.Select(x => x.Protocolo).ToList();
|
|
*/
|
|
|
|
var Protocolos = new List<string>()
|
|
{
|
|
Tipo.ToString() + ";" + _Controle.Direcao.ToString() + ";" + _Controle.RPM_SP.ToString() + ";" + _Controle.Angulo.ToString()
|
|
};
|
|
|
|
return Protocolos;
|
|
}
|
|
|
|
private void AtualizarDadosOperacao()
|
|
{
|
|
var Mapa = Variaveis.OperacaoEmAndamento.Mapa;
|
|
DirecaoCarroRua direcaoCarro = OpMapaGPS.ReferencialRuaGPS.Direcao;
|
|
try
|
|
{
|
|
if (!Mapa.mapaService.Carregado || Mapa.DistanciaTotal == 0)
|
|
{
|
|
Sensoriamento.ProgressoTrajeto = 0;
|
|
}
|
|
else
|
|
{
|
|
Sensoriamento.ProgressoTrajeto = Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaPercorrida.Sum() / Mapa.DistanciaTotal * 100;
|
|
}
|
|
|
|
if (!Mapa.mapaService.Carregado || Mapa.IdxRuaAtual >= Mapa.TrajetoriaProjetada.Count() || (direcaoCarro != DirecaoCarroRua.Ida && direcaoCarro != DirecaoCarroRua.Volta))
|
|
{
|
|
Sensoriamento.ProgressoRua = 0;
|
|
}
|
|
else if (direcaoCarro == DirecaoCarroRua.Ida)
|
|
{
|
|
Sensoriamento.ProgressoRua = (
|
|
(double)Mapa.IdxPontoAproximadoRua /
|
|
(double)(Mapa.TrajetoriaProjetada[0].Count() - 1)
|
|
) * 100;
|
|
}
|
|
else if (direcaoCarro == DirecaoCarroRua.Volta)
|
|
{
|
|
Sensoriamento.ProgressoRua = (
|
|
(double)(Mapa.TrajetoriaProjetada[0].Count() - 1 - Mapa.IdxPontoAproximadoRua) /
|
|
(double)(Mapa.TrajetoriaProjetada[0].Count() - 1)
|
|
) * 100;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Erro ao definir progresso do trajeto: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
public void AtualizarControleAtuadores()
|
|
{
|
|
Controle.BicosAtuados = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BicosPulverizadores;
|
|
}
|
|
|
|
private void TmrLeituras_Elapsed(object sender, EventArgs e)
|
|
{
|
|
((System.Timers.Timer)sender).Stop();
|
|
|
|
if (Variaveis.IsAgroMonitor)
|
|
{
|
|
((System.Timers.Timer)sender).Start();
|
|
return;
|
|
}
|
|
|
|
AtualizarDadosPerformance();
|
|
|
|
if (!Variaveis.OperacaoEmAndamento.OperacaoLiberada && Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
PararCarroOperacaoInterrompida();
|
|
|
|
((System.Timers.Timer)sender).Start();
|
|
return;
|
|
}
|
|
|
|
if (Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.CamerasSolo.Where(x => x.Iniciada).ToList().ForEach(CameraSolo =>
|
|
{
|
|
try
|
|
{
|
|
AtualizaLeituraCameraSolo(CameraSolo);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Erro ao ler dados da câmera do solo (" + CameraSolo.Nome + "): " + ex.Message);
|
|
}
|
|
});
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.ErvasNoRadar = Variaveis.OperacaoEmAndamento.CamerasSolo.Sum(x => x.ErvasNoRadar);
|
|
|
|
try
|
|
{
|
|
AtualizaLeituraCameraCaminho();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Erro ao ler dados da câmera do caminho: " + ex.Message);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.AtualizarRuasSelecionadas();
|
|
}
|
|
|
|
try
|
|
{
|
|
AtualizarGrafico();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
|
|
if (!Variaveis.OperacaoEmAndamento.Simulando || true)
|
|
{
|
|
AtualizaInformacoesControleOperacao();
|
|
}
|
|
|
|
((System.Timers.Timer)sender).Start();
|
|
}
|
|
|
|
private void AtualizaLeituraCameraSolo(CameraSoloModel CameraSolo)
|
|
{
|
|
if (CameraSolo.camera._mqttTopico != null && CameraSolo.camera._mqttTopico.Mensagens.Any(x => x.Momento > CameraSolo.camera.IniciadoEm))
|
|
{
|
|
try
|
|
{
|
|
var Mensagem = CameraSolo.camera._mqttTopico.Mensagens.LastOrDefault(x => x.Momento > CameraSolo.camera.IniciadoEm);
|
|
if (Mensagem != null)
|
|
{
|
|
CameraSolo.Leitura = JsonConvert.DeserializeObject<CameraCoordenadasFrameModel>(Mensagem.Mensagem);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
var Atuador = Variaveis.OperacaoEmAndamento.DispAtu;
|
|
|
|
int BicosPorCamera = Atuador.Dados.QuantidadeBicos / CamerasSolo.Count();
|
|
var Verdes = CameraSolo.Leitura.objetos.ToList();
|
|
int intervaloPorBico = Convert.ToInt32(CameraSolo.Leitura.x_max) / BicosPorCamera;
|
|
int inicioBarraPulverizadora = Convert.ToInt32(CameraSolo.Leitura.y_max * (1 - Controle.PercentualInicioPulverizacao));
|
|
|
|
List<bool> BicosAnteriores = new List<bool>();
|
|
// Inicialize todos os bicos como inativos antes de verificar os objetos verdes
|
|
for (int i = 0; i < BicosPorCamera; i++)
|
|
{
|
|
int iBico = i + (CameraSolo.Posicao * BicosPorCamera);
|
|
BicosAnteriores.Add(Atuador.Dados.BicosPulverizadores[iBico].Atuado ? true : false);
|
|
Atuador.Dados.BicosPulverizadores[iBico].Atuado = false;
|
|
}
|
|
|
|
foreach (var verde in Verdes)
|
|
{
|
|
// Calcule a posição final (y + altura) do objeto verde
|
|
int posicaoFinalVerdeY = verde.y + verde.altura;
|
|
if (posicaoFinalVerdeY > inicioBarraPulverizadora)
|
|
{
|
|
// Calcule a posição final (x + largura) do objeto verde
|
|
int posicaoFinalVerdeX = verde.x + verde.largura;
|
|
|
|
// Para cada objeto verde, verifique se ele está dentro do intervalo de algum bico e atue-o
|
|
for (int i = 0; i < BicosPorCamera; i++)
|
|
{
|
|
// Determina o intervalo no eixo x para o bico atual
|
|
int limiteInferior = intervaloPorBico * i;
|
|
int limiteSuperior = limiteInferior + intervaloPorBico;
|
|
|
|
// Verifica se o objeto 'verde' está dentro do intervalo deste bico
|
|
// A condição foi ajustada para verificar se qualquer parte do objeto verde cruza com o intervalo do bico
|
|
if (verde.x < limiteSuperior && posicaoFinalVerdeX > limiteInferior)
|
|
{
|
|
int iBico = i + (CameraSolo.Posicao * BicosPorCamera);
|
|
Atuador.Dados.BicosPulverizadores[iBico].Atuado = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CameraSolo.ErvasNoRadar = Verdes.Count();
|
|
|
|
for (int i = 0; i < BicosPorCamera; i++)
|
|
{
|
|
int iBico = i + (CameraSolo.Posicao * BicosPorCamera);
|
|
if (Atuador.Dados.BicosPulverizadores[iBico].Atuado && BicosAnteriores[i] != Atuador.Dados.BicosPulverizadores[iBico].Atuado)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AtuacoesPorBico[iBico]++;
|
|
}
|
|
}
|
|
|
|
AtualizaInformacoesControleOperacao();
|
|
}
|
|
}
|
|
|
|
private void AtualizaLeituraCameraCaminho()
|
|
{
|
|
try
|
|
{
|
|
var cameraCaminho = Variaveis.OperacaoEmAndamento.CameraCaminhoKinect;
|
|
|
|
if (cameraCaminho == null || !cameraCaminho.Iniciada)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var MqttTopico = Variaveis.MqttService.Topicos.FirstOrDefault(x => x.Topico == CamerasVaraiveisModel.TopicoRecebimentoBitmap);
|
|
if (MqttTopico != null && MqttTopico.Mensagens.Any(x => x.Momento > cameraCaminho.camera.IniciadoEm))
|
|
{
|
|
try
|
|
{
|
|
var Mensagem = MqttTopico.Mensagens.LastOrDefault(x => x.Momento > cameraCaminho.camera.IniciadoEm);
|
|
if (Mensagem != null)
|
|
{
|
|
cameraCaminho.Leitura = JsonConvert.DeserializeObject<CameraDeepLabV3PlusModel>(Mensagem.Mensagem);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
}
|
|
// Atualizar representação gráfica do resultado da leitura do caminho
|
|
//pnlCaminho.Invalidate();
|
|
|
|
if (cameraCaminho.PontosExtremos.Any())
|
|
{
|
|
double esq_CA = cameraCaminho.PontosExtremos[2].X - cameraCaminho.PontosExtremos[1].X;
|
|
double esq_CO = cameraCaminho.PontosExtremos[1].Y - cameraCaminho.PontosExtremos[2].Y;
|
|
double esq_AG = Math.Atan(esq_CO / esq_CA) * (180 / Math.PI);
|
|
|
|
double dir_CA = cameraCaminho.PontosExtremos[4].X - cameraCaminho.PontosExtremos[3].X;
|
|
double dir_CO = cameraCaminho.PontosExtremos[4].Y - cameraCaminho.PontosExtremos[3].Y;
|
|
double dir_AG = Math.Atan(dir_CO / dir_CA) * (180 / Math.PI);
|
|
|
|
cameraCaminho.Angulo = dir_AG - esq_AG;
|
|
cameraCaminho.AnguloDireito = dir_AG;
|
|
cameraCaminho.AnguloEsquerdo = esq_AG;
|
|
}
|
|
else
|
|
{
|
|
cameraCaminho.Angulo = 0;
|
|
cameraCaminho.AnguloDireito = 0;
|
|
cameraCaminho.AnguloEsquerdo = 0;
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AnguloRuaCamera = cameraCaminho.Angulo;
|
|
|
|
// Atualizar angulo de inclinação calculado através do modelo de IA para reconhecimento do caminho
|
|
//pnlAnguloCamera.Invalidate();
|
|
|
|
AtualizaInformacoesControleOperacao();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Erro ao receber dados da Camera Caminho: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private void AtualizaInformacoesControleOperacao()
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.Modo != ModoOperacao.Manual)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.OpMapaGPS.CalculaDadosMovimentacaoAutonoma();
|
|
Variaveis.OperacaoEmAndamento.AtualizarControleAtuadores();
|
|
Variaveis.OperacaoEmAndamento.AtualizarDadosControle(false);
|
|
}
|
|
}
|
|
|
|
private void AtualizarGrafico()
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.DispMvd == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MvdMotorMOVSensorimanetoGrafico Log = null;
|
|
|
|
// Primeiro, coletar todos os logs alinhados por índice em uma lista de tuplas (index, moduloLog)
|
|
var Logs = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos
|
|
.Where(x => x.MovMotor.Inicializado)
|
|
.SelectMany(m => m.MovMotor.LogGrafico.Select((log, index) => new { Index = index, Log = log }))
|
|
.GroupBy(x => x.Index) // Agrupa por índice
|
|
.OrderBy(g => g.Key) // Ordena pelos índices (opcional, mas ajuda na leitura)
|
|
.Select(g => new MvdMotorMOVSensorimanetoGrafico()
|
|
{
|
|
// Calcula a média de cada propriedade no grupo
|
|
Momento = new DateTime((long)g.Average(x => x.Log.Momento.Ticks)),
|
|
Velocidade = g.Average(x => x.Log.Velocidade),
|
|
RPM_Motor = Convert.ToInt32(g.Average(x => x.Log.RPM_Motor)),
|
|
RPM_Roda = Convert.ToInt32(g.Average(x => x.Log.RPM_Roda)),
|
|
RPM_SP = Convert.ToInt32(g.Average(x => x.Log.RPM_SP)),
|
|
Temperatura = g.Average(x => x.Log.Temperatura),
|
|
Tensao = g.Average(x => x.Log.Tensao),
|
|
})
|
|
.ToList();
|
|
|
|
if (Logs.Count > 0)
|
|
{
|
|
Log = Logs.Last();
|
|
}
|
|
|
|
double Minimo = 0;
|
|
double Maximo = 0;
|
|
|
|
Chart chart = Variaveis.OperacaoEmAndamento.chartGraficos;
|
|
Func<bool> funcAttGrafico = new Func<bool>(() =>
|
|
{
|
|
try
|
|
{
|
|
if (chart.IsDisposed)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
chart.Titles.Clear();
|
|
chart.Titles.Add("Acompanhamento");
|
|
//var Logs = (Motor.LogGrafico.Count > MovimentacaoModel.LogsManter ? Motor.LogGrafico.Skip(Math.Max(0, Motor.LogGrafico.Count - MovimentacaoModel.LogsManter)).Take(MovimentacaoModel.LogsManter).ToList() : Motor.LogGrafico).Where(log => log.Modulo_ID == Modulo.Modulo_ID).ToList();
|
|
chart.Series.Clear();
|
|
List<string> Momentos = Logs.Select(x => x.Momento.ToString("mm:ss:fff")).ToList();
|
|
|
|
var serieVelocidade = new Series("Velocidade: " + (Log != null ? Log.Velocidade : 0));
|
|
serieVelocidade.Points.DataBindXY(Momentos, Logs.Select(x => x.Velocidade).ToList());
|
|
serieVelocidade.ChartType = SeriesChartType.Line;
|
|
chart.Series.Add(serieVelocidade);
|
|
Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.Velocidade) < Minimo ? Logs.Min(x => x.Velocidade) : Minimo;
|
|
Maximo = !Logs.Any() ? 0 : Logs.Min(x => x.Velocidade) > Maximo ? Logs.Min(x => x.Velocidade) : Maximo;
|
|
|
|
var serieRPMsp = new Series("RPM SP: " + (Log != null ? Log.RPM_SP : 0));
|
|
serieRPMsp.Points.DataBindXY(Momentos, Logs.Select(x => x.RPM_SP).ToList());
|
|
serieRPMsp.ChartType = SeriesChartType.Spline;
|
|
chart.Series.Add(serieRPMsp);
|
|
Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.RPM_SP) < Minimo ? Logs.Min(x => x.RPM_SP) : Minimo;
|
|
Maximo = !Logs.Any() ? 0 : Logs.Max(x => x.RPM_SP) > Maximo ? Logs.Max(x => x.RPM_SP) : Maximo;
|
|
|
|
var serieRPM = new Series("RPM Roda: " + (Log != null ? Log.RPM_Roda : 0));
|
|
serieRPM.Points.DataBindXY(Momentos, Logs.Select(x => x.RPM_Roda).ToList());
|
|
serieRPM.ChartType = SeriesChartType.Spline;
|
|
chart.Series.Add(serieRPM);
|
|
Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.RPM_Roda) < Minimo ? Logs.Min(x => x.RPM_Roda) : Minimo;
|
|
Maximo = !Logs.Any() ? 0 : Logs.Max(x => x.RPM_Roda) > Maximo ? Logs.Max(x => x.RPM_Roda) : Maximo;
|
|
|
|
var serieMotor = new Series("RPM Motor: " + (Log != null ? Log.RPM_Motor : 0));
|
|
serieMotor.Points.DataBindXY(Momentos, Logs.Select(x => x.RPM_Motor).ToList());
|
|
serieMotor.ChartType = SeriesChartType.Spline;
|
|
chart.Series.Add(serieMotor);
|
|
Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.RPM_Motor) < Minimo ? Logs.Min(x => x.RPM_Motor) : Minimo;
|
|
Maximo = !Logs.Any() ? 0 : Logs.Max(x => x.RPM_Motor) > Maximo ? Logs.Max(x => x.RPM_Motor) : Maximo;
|
|
|
|
var serieTemperatura = new Series("Temperatura: " + (Log != null ? Log.Temperatura : 0));
|
|
serieTemperatura.Points.DataBindXY(Momentos, Logs.Select(x => x.Temperatura).ToList());
|
|
serieTemperatura.ChartType = SeriesChartType.Line;
|
|
chart.Series.Add(serieTemperatura);
|
|
Minimo = !Logs.Any() ? 0 : Logs.Min(x => x.Temperatura) < Minimo ? Logs.Min(x => x.Temperatura) : Minimo;
|
|
Maximo = !Logs.Any() ? 0 : Logs.Max(x => x.Temperatura) > Maximo ? Logs.Max(x => x.Temperatura) : Maximo;
|
|
|
|
foreach (var legend in chart.Legends)
|
|
{
|
|
legend.Docking = Docking.Bottom;
|
|
}
|
|
|
|
if (chart.ChartAreas.Any())
|
|
{
|
|
chart.ChartAreas[0].AxisY.Minimum = Minimo - 5;
|
|
chart.ChartAreas[0].AxisY.Maximum = Maximo + 5;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Erro ao atualizar gráficos da operação: " + ex.Message);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
FuncoesGlobais.ExecutarMetodoComVerificacaoCrossThread(chart, funcAttGrafico);
|
|
}
|
|
|
|
public void ExecutaComandoDaBase(OperacaoControleBaseModel controleBase)
|
|
{
|
|
Emergencia = controleBase.Emergencia;
|
|
|
|
if (Emergencia)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Salvar estado anterior
|
|
double oldPercentualVelocidade = Controle.PercentualVelocidadeSP;
|
|
double oldAngulo = Controle.Angulo;
|
|
double oldVelocidadeMP = Controle.VelocidadeMP;
|
|
TipoMovimentoDirecional oldTipoMovimento = Controle.TipoMovimento;
|
|
|
|
// Atualizar estado atual com os valores do controleBase
|
|
Controle.PercentualVelocidadeSP = controleBase.PercentualVelocidadeSP;
|
|
Controle.Angulo = controleBase.AnguloMP;
|
|
Controle.VelocidadeMP = controleBase.VelocidadeMP;
|
|
Controle.TipoMovimento = controleBase.TipoMovimento;
|
|
|
|
// Enviar comando
|
|
GeneralJoystick.EnviaComandoMotor(controleBase.Tecla, controleBase.Dispositivo, true);
|
|
|
|
// Restaurar estado anterior
|
|
Controle.PercentualVelocidadeSP = oldPercentualVelocidade;
|
|
Controle.Angulo = oldAngulo;
|
|
Controle.VelocidadeMP = oldVelocidadeMP;
|
|
Controle.TipoMovimento = oldTipoMovimento;
|
|
}
|
|
|
|
private void PararCarroOperacaoInterrompida()
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Controle.PercentualVelocidadeSP = 0; // Velocidade Zero (parado)
|
|
Variaveis.OperacaoEmAndamento.Controle.Angulo = 0; // Angulo Zero (direcional reto)
|
|
Variaveis.OperacaoEmAndamento.Controle.BicosAtuados.ForEach(x => x.Atuado = false); // Bicos desatuados
|
|
AtualizarDadosControle(true);
|
|
Variaveis.OperacaoEmAndamento.Controle.TiposControle.ForEach(x => x.UltimaDirecao = Direcao.Parado);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CALCULAR PERFORMANCE
|
|
|
|
DateTime UltimaLeituraPerformance = DateTime.Now;
|
|
|
|
public void AtualizarDadosPerformance()
|
|
{
|
|
if (DateTime.Now > UltimaLeituraPerformance.AddSeconds(1))
|
|
{
|
|
UltimaLeituraPerformance = DateTime.Now;
|
|
|
|
float? cpuLoad = null;
|
|
float? gpuLoad = null;
|
|
float? hddLoad = null;
|
|
float? ramUsage = null;
|
|
float? cpuTemp = null;
|
|
float? gpuTemp = null;
|
|
|
|
foreach (var hardwareItem in computer.Hardware)
|
|
{
|
|
hardwareItem.Update();
|
|
|
|
if (hardwareItem.HardwareType == HardwareType.CPU)
|
|
{
|
|
foreach (var sensor in hardwareItem.Sensors)
|
|
{
|
|
if (sensor.SensorType == SensorType.Load && sensor.Name == "CPU Total")
|
|
{
|
|
cpuLoad = sensor.Value;
|
|
}
|
|
if (sensor.SensorType == SensorType.Temperature && sensor.Name == "CPU Package")
|
|
{
|
|
cpuTemp = sensor.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hardwareItem.HardwareType == HardwareType.GpuNvidia || hardwareItem.HardwareType == HardwareType.GpuAti)
|
|
{
|
|
foreach (var sensor in hardwareItem.Sensors)
|
|
{
|
|
if (sensor.SensorType == SensorType.Load && sensor.Name == "GPU Core")
|
|
{
|
|
gpuLoad = sensor.Value;
|
|
}
|
|
if (sensor.SensorType == SensorType.Temperature && sensor.Name == "GPU Core")
|
|
{
|
|
gpuTemp = sensor.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hardwareItem.HardwareType == HardwareType.RAM)
|
|
{
|
|
foreach (var sensor in hardwareItem.Sensors)
|
|
{
|
|
if (sensor.SensorType == SensorType.Load && sensor.Name == "Memory")
|
|
{
|
|
ramUsage = sensor.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hardwareItem.HardwareType == HardwareType.HDD)
|
|
{
|
|
foreach (var sensor in hardwareItem.Sensors)
|
|
{
|
|
if (sensor.SensorType == SensorType.Load && sensor.Name == "Used Space")
|
|
{
|
|
hddLoad = sensor.Value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Variaveis.OperacaoEmAndamento.Sensoriamento != null)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.CPU_load = cpuLoad;
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.GPU_load = gpuLoad;
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.HDD_load = hddLoad;
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.RAM_usage = ramUsage;
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.CPU_temp = cpuTemp;
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.GPU_temp = gpuTemp;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region REGISTRO DE LOGS
|
|
|
|
private int idxLog = 0;
|
|
|
|
private void TmrLogs_Elapsed(object sender, EventArgs e)
|
|
{
|
|
((System.Timers.Timer)sender).Stop();
|
|
|
|
if (Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
SalvarLogs(false);
|
|
}
|
|
|
|
AtualizarSinaleiroOperacao();
|
|
|
|
((System.Timers.Timer)sender).Start();
|
|
}
|
|
|
|
public void SalvarLogs(bool Fim)
|
|
{
|
|
if (!string.IsNullOrEmpty(Variaveis.OperacaoEmAndamento.ID))
|
|
{
|
|
DateTime Agora = DateTime.Now;
|
|
|
|
OperacaoSensoriamentoLogModel logGeral = new OperacaoSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
BateriaConsumida = Variaveis.OperacaoEmAndamento.Sensoriamento.BateriaConsumida,
|
|
DistanciaDireita = Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaDireita,
|
|
DistanciaEsquerda = Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaEsquerda,
|
|
DistanciaPercorrida = new List<double>(Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaPercorrida),
|
|
AnguloCarroBussola = Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloCarroBussola,
|
|
TempoMovimento = Variaveis.OperacaoEmAndamento.DispMvd.Dados.TempoEmAtividade,
|
|
StatusCarro = Variaveis.OperacaoEmAndamento.OpMapaGPS.ReferencialRuaGPS.StatusAtual,
|
|
ErvasIdentificadas = Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AtuacoesPorBico.Sum(),
|
|
ErvasNoRadar = Variaveis.OperacaoEmAndamento.Sensoriamento.ErvasNoRadar,
|
|
HerbicidaConsumido = Variaveis.OperacaoEmAndamento.Sensoriamento.HerbicidaConsumido,
|
|
HerbicidaPorErva = Variaveis.OperacaoEmAndamento.Sensoriamento.HerbicidaPorErva,
|
|
ProgressoTrajeto = Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoTrajeto,
|
|
ProgressoRua = Variaveis.OperacaoEmAndamento.Sensoriamento.ProgressoRua,
|
|
Direcao = Variaveis.OperacaoEmAndamento.OpMapaGPS.ReferencialRuaGPS.Direcao,
|
|
AnguloRua = Variaveis.OperacaoEmAndamento.Mapa.AnguloCaminho,
|
|
DentroDaRua = Variaveis.OperacaoEmAndamento.Mapa.DentroDaRua,
|
|
IdxPontoAproximadoRua = Variaveis.OperacaoEmAndamento.Mapa.IdxPontoAproximadoRua,
|
|
IdxRuaAtual = Variaveis.OperacaoEmAndamento.Mapa.IdxRuaAtual,
|
|
AnguloDif = Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloDif,
|
|
TipoMovimento = Variaveis.OperacaoEmAndamento.Controle.TipoMovimento,
|
|
Temperatura = Variaveis.OperacaoEmAndamento.Sensoriamento.Temperatura,
|
|
Altitude = Variaveis.OperacaoEmAndamento.Sensoriamento.Altitude,
|
|
InclinacaoX = Variaveis.OperacaoEmAndamento.Sensoriamento.InclinacaoX,
|
|
InclinacaoY = Variaveis.OperacaoEmAndamento.Sensoriamento.InclinacaoY,
|
|
InclinacaoZ = Variaveis.OperacaoEmAndamento.Sensoriamento.InclinacaoZ,
|
|
Pressao = Variaveis.OperacaoEmAndamento.Sensoriamento.Pressao,
|
|
AnguloRuaCamera = Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloRuaCamera,
|
|
CPU_load = Variaveis.OperacaoEmAndamento.Sensoriamento.CPU_load,
|
|
GPU_load = Variaveis.OperacaoEmAndamento.Sensoriamento.GPU_load,
|
|
HDD_load = Variaveis.OperacaoEmAndamento.Sensoriamento.HDD_load,
|
|
RAM_usage = Variaveis.OperacaoEmAndamento.Sensoriamento.RAM_usage,
|
|
CPU_temp = Variaveis.OperacaoEmAndamento.Sensoriamento.CPU_temp,
|
|
GPU_temp = Variaveis.OperacaoEmAndamento.Sensoriamento.GPU_temp,
|
|
OperacaoLiberada = Variaveis.OperacaoEmAndamento.OperacaoLiberada,
|
|
Dir_Status = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosMKS(Variaveis.OperacaoEmAndamento.Controle.TipoMovimento),
|
|
MovEsq_Status = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosBLD(Direcao.Esquerda),
|
|
MovDir_Status = Variaveis.OperacaoEmAndamento.DispMvd.Dados.StatusModulosBLD(Direcao.Direita),
|
|
};
|
|
SalvarLog("operacao", logGeral, Fim);
|
|
|
|
GPSModel logGps = new GPSModel()
|
|
{
|
|
Momento = Agora,
|
|
Inicializado = GPSService.Iniciado,
|
|
DataHora = GPSService.UltimaLeitura.DataHora,
|
|
Altitude = GPSService.UltimaLeitura.Altitude,
|
|
DirecaoTrecho = GPSService.UltimaLeitura.DirecaoTrecho,
|
|
idxRua = GPSService.UltimaLeitura.idxRua,
|
|
Latitude = GPSService.UltimaLeitura.Latitude,
|
|
Longitude = GPSService.UltimaLeitura.Longitude,
|
|
NumeroSatelites = GPSService.UltimaLeitura.NumeroSatelites,
|
|
Orientacao = GPSService.UltimaLeitura.Orientacao,
|
|
PrecisaoHorizontal = GPSService.UltimaLeitura.PrecisaoHorizontal,
|
|
Velocidade = GPSService.UltimaLeitura.Velocidade
|
|
};
|
|
SalvarLog(T_Code.Gps.ToString(), logGps, Fim);
|
|
|
|
Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.ForEach(Modulo =>
|
|
{
|
|
MovSensoriamentoLogModel logMov = new MovSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Modulo_ID = Modulo.Modulo_ID,
|
|
Inicializado = Modulo.MovMotor.BLD_Inicializado,
|
|
RPM_SP = Modulo.MovMotor.RPM_SP,
|
|
RPM_Motor = Modulo.MovMotor.RPM_Motor,
|
|
RPM_Roda = Modulo.MovMotor.RPM_Roda,
|
|
Corrente = Modulo.MovMotor.Corrente,
|
|
Temperatura = Modulo.MovMotor.Temperatura,
|
|
TemperaturaDriver = Modulo.MovMotor.TemperaturaDriver,
|
|
Tensao = Modulo.MovMotor.Tensao,
|
|
Sentido_SP = Modulo.MovMotor.Sentido_SP,
|
|
Sentido = Modulo.MovMotor.Sentido,
|
|
Velocidade = Modulo.MovMotor.VelocidadeInstantanea,
|
|
CodAlarme = Modulo.MovMotor.CodigoAlarme,
|
|
EmFreio = Modulo.MovMotor.Freio,
|
|
Ativado = Modulo.MovMotor.Ligado,
|
|
};
|
|
SalvarLog(T_Code.Mov.ToString(), logMov, false);
|
|
|
|
DirSensoriamentoLogModel logDir = new DirSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Modulo_ID = Modulo.Modulo_ID,
|
|
Inicializado = Modulo.DirMotor.MKS_Inicializado,
|
|
Angulo = Modulo.DirMotor.Angulo,
|
|
Angulo_SP = Modulo.DirMotor.Angulo_SP,
|
|
Controlar = Modulo.DirMotor.Comandar,
|
|
Sentido_SP = Modulo.MovMotor.Sentido_SP,
|
|
Sentido = Modulo.MovMotor.Sentido,
|
|
Velocidade = Modulo.MovMotor.VelocidadeInstantanea,
|
|
};
|
|
SalvarLog(T_Code.Dir.ToString(), logDir, false);
|
|
});
|
|
|
|
AtuSensoriamentoLogModel logAtu = new AtuSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Inicializado = Variaveis.OperacaoEmAndamento.DispAtu.Dados.Conectado,
|
|
MassaReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.MassaReservatorio,
|
|
PercentualReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.PercentualReservatorio,
|
|
VolumeReservatorio = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VolumeReservatorio,
|
|
//PressaoLinha_SP = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombaPressurizadora.PressaoSP,
|
|
PressaoLinha_SP = Variaveis.OperacaoEmAndamento.Controle.PressaoLinha,
|
|
PressaoLinha = Variaveis.OperacaoEmAndamento.DispAtu.Dados.PressaoLinha,
|
|
PotenciaBomba = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BombaPressurizadora.Potencia,
|
|
VazaoFluxoMLpS = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VazaoFluxoMLpS,
|
|
VolumeVazaoML = Variaveis.OperacaoEmAndamento.DispAtu.Dados.VolumeVazaoML,
|
|
QuantidadeBicos = Variaveis.OperacaoEmAndamento.DispAtu.Dados.QuantidadeBicos,
|
|
Bicos = Variaveis.OperacaoEmAndamento.DispAtu.Dados.BicosPulverizadores.Select(Bico => new AtuBicoSensoriamentoLogModel()
|
|
{
|
|
ID = Bico.ID,
|
|
Inicializado = Bico.Inicializado,
|
|
Comandar = Bico.Comandar,
|
|
Atuado = Bico.Atuado,
|
|
MediaNivelFluxo = Bico.MediaNivelFluxo,
|
|
Posicao = Bico.Posicao,
|
|
StatusBico = Bico.StatusBico,
|
|
Atuacoes = Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AtuacoesPorBico.Count > Bico.Posicao ? Variaveis.OperacaoEmAndamento.OpMapaGPS.Sensoriamento.AtuacoesPorBico[Bico.Posicao] : 0,
|
|
}).ToList()
|
|
};
|
|
SalvarLog(T_Code.Atu.ToString(), logAtu, false);
|
|
|
|
SenSensoriamentoLogModel logSen = new SenSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Inicializado = Variaveis.OperacaoEmAndamento.DispSen.Dados.Conectado,
|
|
Barramento3v3Corrente = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB3V" && x.Inicializado && x.Leituras != null && x.Leituras.Count() > 0)?.Leituras?[0] ?? -1,
|
|
Barramento3v3Tensao = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB3V" && x.Inicializado && x.Leituras != null && x.Leituras.Count() > 1)?.Leituras?[1] ?? -1,
|
|
Barramento5vCorrente = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB5V" && x.Inicializado && x.Leituras != null && x.Leituras.Count() > 0)?.Leituras?[0] ?? -1,
|
|
Barramento5vTensao = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB5V" && x.Inicializado && x.Leituras != null && x.Leituras.Count() > 1)?.Leituras?[1] ?? -1,
|
|
Barramento7v2Corrente = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB7V2" && x.Inicializado && x.Leituras != null && x.Leituras.Count() > 0)?.Leituras?[0] ?? -1,
|
|
Barramento7v2Tensao = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB7V2" && x.Inicializado && x.Leituras != null && x.Leituras.Count() > 1)?.Leituras?[1] ?? -1,
|
|
Barramento12vCorrente = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB12V" && x.Inicializado && x.Leituras != null && x.Leituras.Count() > 0)?.Leituras?[0] ?? -1,
|
|
Barramento12vTensao = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB12V" && x.Inicializado && x.Leituras != null && x.Leituras.Count() > 1)?.Leituras?[1] ?? -1,
|
|
OrientacaoMagnetica = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "SMAG" && x.Inicializado && x.Leituras != null && x.Leituras.Count() > 0)?.Leituras?[0] ?? -1,
|
|
StatusSinaleiroMN = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDMN" && x.Inicializado)?.StatusLED ?? StatusLED.Apagado,
|
|
StatusSinaleiroAT = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDAT" && x.Inicializado)?.StatusLED ?? StatusLED.Apagado,
|
|
StatusSinaleiroOP = Variaveis.OperacaoEmAndamento.DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDOP" && x.Inicializado)?.StatusLED ?? StatusLED.Apagado,
|
|
StatusReleLoRa = Variaveis.OperacaoEmAndamento.DispSen.Dados.Reles.FirstOrDefault(x => x.ID == "RLLRA" && x.Inicializado)?.StatusLeitura ?? Estado.Desligado,
|
|
AnguloFreioET = Variaveis.OperacaoEmAndamento.DispSen.Dados.Servos.FirstOrDefault(x => x.ID == "FRO_ET" && x.Inicializado)?._AnguloLeitura ?? -1,
|
|
AnguloFreioEF = Variaveis.OperacaoEmAndamento.DispSen.Dados.Servos.FirstOrDefault(x => x.ID == "FRO_EF" && x.Inicializado)?._AnguloLeitura ?? -1,
|
|
AnguloFreioDT = Variaveis.OperacaoEmAndamento.DispSen.Dados.Servos.FirstOrDefault(x => x.ID == "FRO_DT" && x.Inicializado)?._AnguloLeitura ?? -1,
|
|
AnguloFreioDF = Variaveis.OperacaoEmAndamento.DispSen.Dados.Servos.FirstOrDefault(x => x.ID == "FRO_DF" && x.Inicializado)?._AnguloLeitura ?? -1,
|
|
};
|
|
SalvarLog(T_Code.Sen.ToString(), logSen, false);
|
|
|
|
PzmSensoriamentoLogModel logPzm = new PzmSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Inicializado = PZEMService.Iniciado,
|
|
DataHora = PZEMService.UltimaLeitura.DataHora,
|
|
Tensao = PZEMService.UltimaLeitura.Tensao,
|
|
Corrente = PZEMService.UltimaLeitura.Corrente,
|
|
Potencia = PZEMService.UltimaLeitura.Potencia,
|
|
Energia = PZEMService.UltimaLeitura.Energia,
|
|
AlarmeTensaoMin = PZEMService.UltimaLeitura.AlarmeTensaoMin,
|
|
AlarmeTensaoMax = PZEMService.UltimaLeitura.AlarmeTensaoMax
|
|
};
|
|
SalvarLog(T_Code.Pzm.ToString(), logPzm, Fim);
|
|
|
|
WitSensoriamentoLogModel logWit = new WitSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Inicializado = WT901CService.Iniciado,
|
|
DataHora = WT901CService.DadosLeitura.DataHora,
|
|
AccM = WT901CService.DadosLeitura.AccM,
|
|
Altitude = WT901CService.DadosLeitura.Altitude,
|
|
AngleX = WT901CService.DadosLeitura.AngleX,
|
|
AngleY = WT901CService.DadosLeitura.AngleY,
|
|
AngleZ = WT901CService.DadosLeitura.AngleZ,
|
|
AsM = WT901CService.DadosLeitura.AsM,
|
|
HM = WT901CService.DadosLeitura.HM,
|
|
Pressao = WT901CService.DadosLeitura.Pressao,
|
|
Temperatura = WT901CService.DadosLeitura.Temperatura
|
|
};
|
|
SalvarLog(T_Code.Wit.ToString(), logWit, Fim);
|
|
|
|
UltrasonicA05Model logA05 = new UltrasonicA05Model()
|
|
{
|
|
Momento = Agora,
|
|
Endereco = UltrasonicA05Service.slaveAddress,
|
|
U1 = UltrasonicA05Service.DadosLeitura.U1,
|
|
U2 = UltrasonicA05Service.DadosLeitura.U2,
|
|
U3 = UltrasonicA05Service.DadosLeitura.U3,
|
|
U4 = UltrasonicA05Service.DadosLeitura.U4,
|
|
};
|
|
SalvarLog(T_Code.A05.ToString(), logA05, Fim);
|
|
|
|
SalvarLogKinect(Agora);
|
|
|
|
SalvarLogCameras(Agora).ConfigureAwait(false);
|
|
|
|
string ArquivoOp = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/data.lgop";
|
|
if (!File.Exists(ArquivoOp))
|
|
{
|
|
var data = new OperacaoDadosModel()
|
|
{
|
|
id = Variaveis.OperacaoEmAndamento.ID,
|
|
operacao = "operacao",
|
|
gps = T_Code.Gps.ToString(),
|
|
dir = T_Code.Dir.ToString(),
|
|
mov = T_Code.Mov.ToString(),
|
|
atu = T_Code.Atu.ToString(),
|
|
sen = T_Code.Sen.ToString(),
|
|
pzm = T_Code.Pzm.ToString(),
|
|
wit = T_Code.Wit.ToString(),
|
|
a05 = T_Code.A05.ToString(),
|
|
knt = T_Code.Knt.ToString(),
|
|
caminho = Variaveis.OperacaoEmAndamento.CameraCaminhoKinect.Nome,
|
|
soloE = Variaveis.OperacaoEmAndamento.CamerasSolo[0].Nome,
|
|
soloD = Variaveis.OperacaoEmAndamento.CamerasSolo[1].Nome
|
|
};
|
|
File.WriteAllText(ArquivoOp, JsonConvert.SerializeObject(data));
|
|
}
|
|
|
|
Variaveis.OperacaoEmAndamento.idxLog++;
|
|
|
|
|
|
if (Variaveis.OperacaoEmAndamento.idxLog % 2 == 0)
|
|
{
|
|
LoRaService.EnviarDadosParaBase();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void SalvarLog<T>(string Arquivo, T Objeto, bool Fim)
|
|
{
|
|
var Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID;
|
|
if (!Directory.Exists(Caminho))
|
|
{
|
|
Directory.CreateDirectory(Caminho);
|
|
}
|
|
|
|
Caminho += "/" + Arquivo + ".json";
|
|
string jsonLog = JsonConvert.SerializeObject(Objeto, Formatting.None);
|
|
|
|
if (!File.Exists(Caminho))
|
|
{
|
|
File.WriteAllText(Caminho, "[" + jsonLog);
|
|
}
|
|
else
|
|
{
|
|
File.AppendAllText(Caminho, "," + jsonLog + (Fim ? "]" : ""));
|
|
}
|
|
}
|
|
|
|
private async Task SalvarLogCameras(DateTime Agora)
|
|
{
|
|
var cameraCaminho = Variaveis.OperacaoEmAndamento.CameraCaminhoKinect;
|
|
|
|
var Cameras = Variaveis.OperacaoEmAndamento.CamerasSolo.Select(x => new
|
|
{
|
|
tipo = typeof(CamSoloSensoriamentoLogModel),
|
|
nome = x.Nome,
|
|
browser = x.browser,
|
|
})
|
|
.Union(new[] {
|
|
new {
|
|
tipo = typeof(CamCaminhoSensoriamentoLogModel),
|
|
nome = cameraCaminho.Nome,
|
|
browser = cameraCaminho.browser,
|
|
}
|
|
})
|
|
.ToList();
|
|
|
|
|
|
foreach (var Camera in Cameras)
|
|
{
|
|
string Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/" + Camera.nome;
|
|
if (!Directory.Exists(Caminho))
|
|
{
|
|
Directory.CreateDirectory(Caminho);
|
|
}
|
|
|
|
Caminho += "/" + Variaveis.OperacaoEmAndamento.idxLog + ".jpg";
|
|
Bitmap frame = null;
|
|
|
|
if (Camera.tipo == typeof(CamSoloSensoriamentoLogModel))
|
|
{
|
|
var leitura = Variaveis.OperacaoEmAndamento.CamerasSolo.First(x => x.Nome == Camera.nome).Leitura;
|
|
CamSoloSensoriamentoLogModel logCam = new CamSoloSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Leitura = new CameraCoordenadasFrameModel()
|
|
{
|
|
timestamp = leitura.timestamp,
|
|
x_max = leitura.x_max,
|
|
y_max = leitura.y_max,
|
|
objetos = leitura.objetos.ToArray(),
|
|
}
|
|
};
|
|
SalvarLog(Camera.nome, logCam, false);
|
|
|
|
frame = await FuncoesGlobais.GetBrowserImage(Camera.browser);
|
|
}
|
|
else if (Camera.tipo == typeof(CamCaminhoSensoriamentoLogModel))
|
|
{
|
|
var leitura = cameraCaminho.Leitura;
|
|
CamCaminhoSensoriamentoLogModel logCam = new CamCaminhoSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
ClassMap = new Dictionary<string, Color>(cameraCaminho.ClassMap),
|
|
PontosExtremos = new List<System.Drawing.Point>(cameraCaminho.PontosExtremos),
|
|
Angulo = cameraCaminho.Angulo,
|
|
AnguloDireito = cameraCaminho.AnguloDireito,
|
|
AnguloEsquerdo = cameraCaminho.AnguloEsquerdo,
|
|
Leitura = new CameraDeepLabV3PlusModel()
|
|
{
|
|
timestamp = leitura.timestamp,
|
|
Classes = leitura.Classes.Select(x => new CameraDeepLabV3PlusClasseModel()
|
|
{
|
|
Classe = x.Classe,
|
|
Contornos = x.Contornos.ToArray(),
|
|
})
|
|
.ToList()
|
|
}
|
|
};
|
|
SalvarLog(Camera.nome, logCam, false);
|
|
|
|
if (cameraCaminho.camera._mqttTopico != null && cameraCaminho.camera._mqttTopico.Mensagens.Any())
|
|
{
|
|
string message = cameraCaminho.camera._mqttTopico.Mensagens[cameraCaminho.camera._mqttTopico.Mensagens.Count() - 1].Mensagem;
|
|
frame = cameraCaminho.ExtraiImagemDaMensagem(message);
|
|
}
|
|
}
|
|
|
|
FuncoesGlobais.SalvarImagemComprimida(frame, Caminho);
|
|
}
|
|
}
|
|
|
|
private void SalvarLogKinect(DateTime Agora)
|
|
{
|
|
KinectModel logKnt = new KinectModel()
|
|
{
|
|
Momento = Agora,
|
|
AccW = KinectService.Leitura.AccW,
|
|
AccX = KinectService.Leitura.AccX,
|
|
AccY = KinectService.Leitura.AccY,
|
|
AccZ = KinectService.Leitura.AccZ,
|
|
AnguloElevacao = KinectService.Leitura.AnguloElevacao,
|
|
Colisao = KinectService.Leitura.Colisao,
|
|
DistanciaDaDireita = KinectService.Leitura.DistanciaDaDireita,
|
|
DistanciaDaEsquerda = KinectService.Leitura.DistanciaDaEsquerda,
|
|
Obstaculos = new List<Obstaculo>(KinectService.Leitura.Obstaculos),
|
|
Subdivisoes = new List<Subdivisao>(KinectService.Parametros.Subdivisoes),
|
|
Pitch = KinectService.Leitura.Pitch,
|
|
Roll = KinectService.Leitura.Roll,
|
|
VelX = KinectService.Leitura.VelX,
|
|
VelY = KinectService.Leitura.VelY,
|
|
VelZ = KinectService.Leitura.VelZ,
|
|
Yaw = KinectService.Leitura.Yaw,
|
|
UltimoCalculo = KinectService.Leitura.UltimoCalculo
|
|
};
|
|
SalvarLog(T_Code.Knt.ToString(), logKnt, false);
|
|
|
|
string Caminho = Variaveis.CaminhoOperacoes + Variaveis.OperacaoEmAndamento.ID + "/" + T_Code.Knt.ToString();
|
|
if (!Directory.Exists(Caminho))
|
|
{
|
|
Directory.CreateDirectory(Caminho);
|
|
}
|
|
|
|
string rgb = Caminho + "/rgb_" + Variaveis.OperacaoEmAndamento.idxLog + ".jpg";
|
|
string heat = Caminho + "/heat_" + Variaveis.OperacaoEmAndamento.idxLog + ".jpg";
|
|
|
|
lock (KinectService._lockBitmapRGB)
|
|
{
|
|
FuncoesGlobais.SalvarImagemComprimida(KinectService.bitmapRGB, rgb);
|
|
}
|
|
lock (KinectService._lockBitmapHeat)
|
|
{
|
|
FuncoesGlobais.SalvarImagemComprimida(KinectService.bitmapHeat, heat);
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
public void AtualizarSinaleiroOperacao()
|
|
{
|
|
if (DispSen != null && DispSen.Dados.Conectado && !frmDiagnosticos.Diagnosticando)
|
|
{
|
|
var ledOP = DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDOP");
|
|
var ledAT = DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDAT");
|
|
var ledMN = DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDMN");
|
|
|
|
var comportamento = VariaveisEquipamento.ComportamentoPorStatus();
|
|
if (!ledOP.Comportamento.Equals(comportamento))
|
|
{
|
|
GeneralJoystick.EnviarComandoSensoriamento(S_Code.sLED, ledOP.ID, comportamento);
|
|
}
|
|
|
|
var statusLedAt = Modo == ModoOperacao.MapaGPS ? StatusLED.Aceso : StatusLED.Apagado;
|
|
if (!ledAT.Comportamento.statusLED.Equals(statusLedAt))
|
|
{
|
|
ledAT.Comportamento.statusLED = statusLedAt;
|
|
GeneralJoystick.EnviarComandoSensoriamento(S_Code.sLED, ledAT.ID, ledAT.Comportamento);
|
|
}
|
|
|
|
var statusLedMn = Modo == ModoOperacao.Manual ? StatusLED.Aceso : StatusLED.Apagado;
|
|
if (!ledMN.Comportamento.statusLED.Equals(statusLedMn))
|
|
{
|
|
ledMN.Comportamento.statusLED = statusLedMn;
|
|
GeneralJoystick.EnviarComandoSensoriamento(S_Code.sLED, ledMN.ID, ledMN.Comportamento);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void AbrirForm()
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.OperacaoLiberada)
|
|
{
|
|
/*frmOperacao = (Form)Activator.CreateInstance((
|
|
Modo == ModoOperacao.Manual ? Variaveis.OperacaoEmAndamento.OpManual.frmOperacao :
|
|
Modo == ModoOperacao.MapaGPS ? Variaveis.OperacaoEmAndamento.OpMapaGPS.frmOperacao :
|
|
new Form()
|
|
).GetType());*/
|
|
frmOperacao =
|
|
Modo == ModoOperacao.Manual ? new frmOperacaoManual() :
|
|
Modo == ModoOperacao.MapaGPS ? new frmOperacaoMapaGPS() :
|
|
new Form();
|
|
//Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old = new SonarModel(FuncoesGlobais.FindControlRecursive<PictureBox>(frmOperacao, "picSonar"));
|
|
frmOperacao.Show();
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show(Variaveis.OperacaoEmAndamento.ErroOperacaoLiberada, "Conexão de módulos pendentes", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
}
|
|
}
|
|
|
|
public string TextoFormOperacao(string ModoNome)
|
|
{
|
|
var statusAtual = Variaveis.OperacaoEmAndamento.StatusAtual;
|
|
|
|
if (statusAtual == StatusOperacao.Parametrizando)
|
|
{
|
|
return "Operação " + ModoNome + " - Parametrização";
|
|
}
|
|
else if (statusAtual == StatusOperacao.Aguardando)
|
|
{
|
|
return "Operação " + ModoNome + " - Iniciando em " + (Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) - DateTime.Now).TotalSeconds.ToString("0") + " segundo" + ((Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) - DateTime.Now).TotalSeconds < 1 ? "" : "s") + "...";
|
|
}
|
|
else if (statusAtual == StatusOperacao.Concluido)
|
|
{
|
|
return "Operação " + ModoNome + " - Concluída";
|
|
}
|
|
else if (statusAtual == StatusOperacao.EmAndamento)
|
|
{
|
|
return "Operação " + ModoNome + " - Em andamento";
|
|
}
|
|
else
|
|
{
|
|
return "Operação " + ModoNome;
|
|
}
|
|
}
|
|
|
|
#region CODIGOS DE FALHAS
|
|
|
|
public ulong RetornaCodigoFalha()
|
|
{
|
|
ulong Cod = 0x00;
|
|
|
|
var _modsMandatorios = Variaveis.OperacaoEmAndamento.ModulosMandatorios.Where(x => x.Mandatorio).ToList();
|
|
var _parametrosMandatorios = Variaveis.OperacaoEmAndamento.ParametrosMandatorios;
|
|
var _sensoriamento = Variaveis.OperacaoEmAndamento.Sensoriamento;
|
|
var _dispMVD = Variaveis.OperacaoEmAndamento.DispMvd;
|
|
var _dispATU = Variaveis.OperacaoEmAndamento.DispAtu;
|
|
var _dispSEN = Variaveis.OperacaoEmAndamento.DispSen;
|
|
|
|
bool _emergencia = Variaveis.OperacaoEmAndamento.Emergencia;
|
|
bool _operacaoIniciada = Variaveis.OperacaoEmAndamento.Iniciado;
|
|
bool _operacaoLiberada = Variaveis.OperacaoEmAndamento.OperacaoLiberada;
|
|
(bool _modulosConectados, List<T_Code> modsComFalha) = Variaveis.OperacaoEmAndamento.ModulosConectados;
|
|
|
|
bool _camerasSoloConectadas =
|
|
!_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo) ||
|
|
_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo && !x.Mandatorio) ||
|
|
(_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo && x.Mandatorio) &&
|
|
Variaveis.OperacaoEmAndamento.CamerasSolo.Count(y => y.Iniciada) == Variaveis.OperacaoEmAndamento.QuantidadeCamerasSolo);
|
|
|
|
bool _kinectConectado =
|
|
!_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Kinect) ||
|
|
_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Kinect && !x.Mandatorio) ||
|
|
(_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Kinect && x.Mandatorio) &&
|
|
(_sensoriamento.SonarFrontal_Kinect != null && _sensoriamento.SonarFrontal_Kinect.Iniciado));
|
|
|
|
bool _mapaIniciado =
|
|
!_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa) ||
|
|
_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && !x.Mandatorio) ||
|
|
(_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && x.Mandatorio) &&
|
|
Variaveis.OperacaoEmAndamento.Mapa.mapaService.Carregado);
|
|
|
|
bool _joystickConectado =
|
|
!_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick) ||
|
|
_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick && !x.Mandatorio) ||
|
|
(_parametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick && x.Mandatorio) &&
|
|
GeneralJoystick.JoystickConectado != null);
|
|
|
|
(bool _atuOperante, List<string> atuModsFalha) = _dispATU.Dados.StatusModulosATU();
|
|
(bool _senOperante, List<string> senModsFalha) = _dispSEN.Dados.StatusModulosSEN();
|
|
(bool _dirOperante, List<string> dirModsFalha) = _dispMVD.Dados.StatusModulosMKS(Variaveis.OperacaoEmAndamento.Controle.TipoMovimento);
|
|
(bool _movEsqOperante, List<string> movEsqModsFalha) = _dispMVD.Dados.StatusModulosBLD(Direcao.Esquerda);
|
|
(bool _movDirOperante, List<string> movDirModsFalha) = _dispMVD.Dados.StatusModulosBLD(Direcao.Direita);
|
|
|
|
bool _nivelBateriaEstavel =
|
|
!_modsMandatorios.Any(x => x.Dispositivo == T_Code.Pzm) ||
|
|
(_modsMandatorios.Any(x => x.Dispositivo == T_Code.Pzm) &&
|
|
!modsComFalha.Any(x => x == T_Code.Pzm) &&
|
|
_sensoriamento.PorcentagemBateria > VariaveisEquipamento.PercentualTensaoBateriaMin);
|
|
|
|
var _sensorMassa = _dispATU.Dados.Sensores.FirstOrDefault(x => x.Componente == S_Code.sMAS);
|
|
bool _nivelReservatorioEstavel =
|
|
!_modsMandatorios.Any(x => x.Dispositivo == T_Code.Atu) ||
|
|
(_modsMandatorios.Any(x => x.Dispositivo == T_Code.Atu) &&
|
|
!modsComFalha.Any(x => x == T_Code.Atu) &&
|
|
!atuModsFalha.Contains(_sensorMassa.ID) &&
|
|
_dispATU.Dados.PercentualReservatorio > VariaveisEquipamento.PercentualReservatorioMin);
|
|
|
|
var _sensorPressao = _dispATU.Dados.Sensores.FirstOrDefault(x => x.Componente == S_Code.sPRS);
|
|
bool _pressaoLinhaEstavel =
|
|
!_modsMandatorios.Any(x => x.Dispositivo == T_Code.Atu) ||
|
|
(_modsMandatorios.Any(x => x.Dispositivo == T_Code.Atu) &&
|
|
!modsComFalha.Any(x => x == T_Code.Atu) &&
|
|
!atuModsFalha.Contains(_sensorPressao.ID) &&
|
|
_dispATU.Dados.PressaoLinha >= (Variaveis.OperacaoEmAndamento.Controle.PressaoLinha *
|
|
VariaveisEquipamento.PercentualToleranciaPressaoLinha) &&
|
|
_dispATU.Dados.PressaoLinha <= (Variaveis.OperacaoEmAndamento.Controle.PressaoLinha *
|
|
(1 + VariaveisEquipamento.PercentualToleranciaPressaoLinha)));
|
|
|
|
// Verificação de condições operacionais
|
|
if (_emergencia)
|
|
Cod |= 0x01; // Bit 0: Emergência ativada
|
|
if (!_operacaoIniciada)
|
|
Cod |= 0x02; // Bit 1: Operação não iniciada
|
|
if (!_operacaoLiberada)
|
|
Cod |= 0x04; // Bit 2: Operação não liberada
|
|
|
|
// Verificação de conexões dos módulos principais
|
|
if (!_modulosConectados)
|
|
Cod |= 0x08; // Bit 3: Módulos desconectados
|
|
if (!_camerasSoloConectadas)
|
|
Cod |= 0x10; // Bit 4: Câmeras de solo não conectadas
|
|
if (!_kinectConectado)
|
|
Cod |= 0x20; // Bit 5: Kinect não conectado
|
|
if (!_mapaIniciado)
|
|
Cod |= 0x40; // Bit 6: Mapa não iniciado
|
|
if (!_joystickConectado)
|
|
Cod |= 0x80; // Bit 7: Joystick não conectado
|
|
|
|
// Verificação de estado operacional de módulos principais
|
|
if (!_atuOperante)
|
|
Cod |= 0x100; // Bit 8: Atuador inoperante
|
|
if (!_senOperante)
|
|
Cod |= 0x200; // Bit 9: Sensoriamento inoperante
|
|
if (!_dirOperante)
|
|
Cod |= 0x400; // Bit 10: Direcional inoperante
|
|
if (!_movEsqOperante)
|
|
Cod |= 0x800; // Bit 11: Movimentação Esquerda inoperante
|
|
if (!_movDirOperante)
|
|
Cod |= 0x1000; // Bit 12: Movimentação Direita inoperante
|
|
|
|
// Verificação de falhas específicas em `modsComFalha`
|
|
foreach (var modFalha in modsComFalha)
|
|
{
|
|
switch (modFalha)
|
|
{
|
|
case T_Code.Mov:
|
|
Cod |= 0x2000; // Bit 13: Falha no Módulo de Movimento
|
|
break;
|
|
case T_Code.Dir:
|
|
Cod |= 0x4000; // Bit 14: Falha no Módulo de Direção
|
|
break;
|
|
case T_Code.Sen:
|
|
Cod |= 0x8000; // Bit 15: Falha no Módulo de Sensores
|
|
break;
|
|
case T_Code.Atu:
|
|
Cod |= 0x10000; // Bit 16: Falha no Módulo ATU
|
|
break;
|
|
case T_Code.Gps:
|
|
Cod |= 0x20000; // Bit 17: Falha no Módulo GPS
|
|
break;
|
|
case T_Code.Pzm:
|
|
Cod |= 0x40000; // Bit 18: Falha no Módulo PZM
|
|
break;
|
|
case T_Code.Lra:
|
|
Cod |= 0x80000; // Bit 19: Falha no Módulo LRA
|
|
break;
|
|
case T_Code.Wit:
|
|
Cod |= 0x100000; // Bit 20: Falha no Módulo WIT
|
|
break;
|
|
case T_Code.Bld:
|
|
Cod |= 0x200000; // Bit 21: Falha no Módulo BLDC
|
|
break;
|
|
case T_Code.Mvd:
|
|
Cod |= 0x400000; // Bit 22: Falha no Módulo MVD
|
|
break;
|
|
case T_Code.Mbs:
|
|
Cod |= 0x800000; // Bit 23: Falha no Módulo MBS
|
|
break;
|
|
case T_Code.Mks:
|
|
Cod |= 0x1000000; // Bit 24: Falha no Módulo MKS
|
|
break;
|
|
case T_Code.Cam:
|
|
Cod |= 0x2000000; // Bit 25: Falha no Módulo de Câmera
|
|
break;
|
|
case T_Code.Knt:
|
|
Cod |= 0x4000000; // Bit 26: Falha no Módulo Kinect
|
|
break;
|
|
case T_Code.A05:
|
|
Cod |= 0x8000000; // Bit 27: Falha no Módulo A05
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Verificação de `atuModsFalha`
|
|
foreach (var falha in atuModsFalha)
|
|
{
|
|
switch (falha)
|
|
{
|
|
case "B01":
|
|
Cod |= 0x10000000; // Bit 28: Falha no atuador B01
|
|
break;
|
|
case "B02":
|
|
Cod |= 0x20000000; // Bit 29: Falha no atuador B02
|
|
break;
|
|
case "B03":
|
|
Cod |= 0x40000000; // Bit 30: Falha no atuador B03
|
|
break;
|
|
case "B04":
|
|
Cod |= 0x80000000; // Bit 31: Falha no atuador B04
|
|
break;
|
|
case "BOMBA":
|
|
Cod |= 0x100000000; // Bit 32: Falha na BOMBA
|
|
break;
|
|
case "FLXLN":
|
|
Cod |= 0x200000000; // Bit 33: Falha no atuador FLXLN
|
|
break;
|
|
case "MASRS":
|
|
Cod |= 0x400000000; // Bit 34: Falha no atuador MASRS
|
|
break;
|
|
case "PRSLN":
|
|
Cod |= 0x800000000; // Bit 35: Falha no atuador PRSLN
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Verificação de `senModsFalha`
|
|
foreach (var falha in senModsFalha)
|
|
{
|
|
switch (falha)
|
|
{
|
|
case "LEDMN":
|
|
Cod |= 0x1000000000; // Bit 36: Falha no LED MN
|
|
break;
|
|
case "LEDAT":
|
|
Cod |= 0x2000000000; // Bit 37: Falha no LED AT
|
|
break;
|
|
case "LEDOP":
|
|
Cod |= 0x4000000000; // Bit 38: Falha no LED OP
|
|
break;
|
|
case "TMVET":
|
|
Cod |= 0x8000000000; // Bit 39: Falha no TMV Esquerda Traseira
|
|
break;
|
|
case "TMVEF":
|
|
Cod |= 0x10000000000; // Bit 40: Falha no TMV Esquerda Frontal
|
|
break;
|
|
case "TMVDT":
|
|
Cod |= 0x20000000000; // Bit 41: Falha no TMV Direita Traseira
|
|
break;
|
|
case "TMVDF":
|
|
Cod |= 0x40000000000; // Bit 42: Falha no TMV Direita Frontal
|
|
break;
|
|
case "AB5V":
|
|
Cod |= 0x80000000000; // Bit 43: Falha no sensor AB 5V
|
|
break;
|
|
case "AB12V":
|
|
Cod |= 0x100000000000; // Bit 44: Falha no sensor AB 12V
|
|
break;
|
|
case "TBAT":
|
|
Cod |= 0x200000000000; // Bit 45: Falha na Temperatura da Bateria
|
|
break;
|
|
case "RLLRA":
|
|
Cod |= 0x400000000000; // Bit 46: Falha no sensor RLLRA
|
|
break;
|
|
case "FRO_ET":
|
|
Cod |= 0x800000000000; // Bit 47: Falha no sensor FRO Esquerda Traseira
|
|
break;
|
|
case "FRO_EF":
|
|
Cod |= 0x1000000000000; // Bit 48: Falha no sensor FRO Esquerda Frontal
|
|
break;
|
|
case "FRO_DT":
|
|
Cod |= 0x2000000000000; // Bit 49: Falha no sensor FRO Direita Traseira
|
|
break;
|
|
case "FRO_DF":
|
|
Cod |= 0x4000000000000; // Bit 50: Falha no sensor FRO Direita Frontal
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Verificação de `dirModsFalha`
|
|
foreach (var falha in dirModsFalha)
|
|
{
|
|
switch (falha)
|
|
{
|
|
case "ET":
|
|
Cod |= 0x8000000000000; // Bit 51: Falha na direção Esquerda Traseira
|
|
break;
|
|
case "EF":
|
|
Cod |= 0x10000000000000; // Bit 52: Falha na direção Esquerda Frontal
|
|
break;
|
|
case "DT":
|
|
Cod |= 0x20000000000000; // Bit 53: Falha na direção Direita Traseira
|
|
break;
|
|
case "DF":
|
|
Cod |= 0x40000000000000; // Bit 54: Falha na direção Direita Frontal
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Verificação de `movEsqModsFalha`
|
|
foreach (var falha in movEsqModsFalha)
|
|
{
|
|
switch (falha)
|
|
{
|
|
case "ET":
|
|
Cod |= 0x80000000000000; // Bit 55: Falha no motor Esquerda Traseira
|
|
break;
|
|
case "EF":
|
|
Cod |= 0x100000000000000; // Bit 56: Falha no motor Esquerda Frontal
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Verificação de `movDirModsFalha`
|
|
foreach (var falha in movDirModsFalha)
|
|
{
|
|
switch (falha)
|
|
{
|
|
case "DT":
|
|
Cod |= 0x200000000000000; // Bit 57: Falha no motor Direita Traseira
|
|
break;
|
|
case "DF":
|
|
Cod |= 0x400000000000000; // Bit 58: Falha no motor Direita Frontal
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Verificação de condições de bateria e reservatório
|
|
if (!_nivelBateriaEstavel)
|
|
Cod |= 0x800000000000000; // Bit 59: Nível da bateria abaixo do mínimo
|
|
if (!_nivelReservatorioEstavel)
|
|
Cod |= 0x1000000000000000; // Bit 60: Nível do reservatório abaixo do mínimo
|
|
if (!_pressaoLinhaEstavel)
|
|
Cod |= 0x2000000000000000; // Bit 61: Pressão da linha fora dos parâmetros
|
|
|
|
return Cod;
|
|
}
|
|
|
|
public static string DescricaoCodigoFalha(ulong codigo)
|
|
{
|
|
Dictionary<string, List<string>> erros = new Dictionary<string, List<string>>()
|
|
{
|
|
{ "Equipamento", new List<string>() },
|
|
{ "Parâmetros", new List<string>() },
|
|
{ "Módulos", new List<string>() },
|
|
{ "Atuador", new List<string>() },
|
|
{ "Direcional", new List<string>() },
|
|
{ "Movimentação", new List<string>() },
|
|
{ "Sensoriamento", new List<string>() },
|
|
{ "Operação", new List<string>() },
|
|
};
|
|
|
|
// Verificação de condições operacionais
|
|
if ((codigo & 0x01) != 0)
|
|
erros["Equipamento"].Add("Emergência ativado.");
|
|
if ((codigo & 0x02) != 0)
|
|
erros["Operação"].Add("Operação não iniciada.");
|
|
if ((codigo & 0x04) != 0)
|
|
erros["Operação"].Add("Operação não liberada.");
|
|
|
|
// Verificação de conexões dos módulos principais
|
|
if ((codigo & 0x08) != 0)
|
|
erros["Módulos"].Add("Um ou mais módulos principais desconectados.");
|
|
if ((codigo & 0x10) != 0)
|
|
erros["Parâmetros"].Add("Uma ou mais câmeras de solo não conectadas.");
|
|
if ((codigo & 0x20) != 0)
|
|
erros["Parâmetros"].Add("Sonar Frontal não conectado.");
|
|
if ((codigo & 0x40) != 0)
|
|
erros["Parâmetros"].Add("Mapa da operação não caregado.");
|
|
if ((codigo & 0x80) != 0)
|
|
erros["Parâmetros"].Add("Joystick não conectado.");
|
|
|
|
// Verificação de estado operacional de módulos principais
|
|
if ((codigo & 0x100) != 0)
|
|
erros["Módulos"].Add("Atuador inoperante.");
|
|
if ((codigo & 0x200) != 0)
|
|
erros["Módulos"].Add("Sensoriamento inoperante.");
|
|
if ((codigo & 0x400) != 0)
|
|
erros["Módulos"].Add("Direcional inoperante.");
|
|
if ((codigo & 0x800) != 0)
|
|
erros["Módulos"].Add("Movimentação Esquerdo inoperante.");
|
|
if ((codigo & 0x1000) != 0)
|
|
erros["Módulos"].Add("Movimentação Direito inoperante.");
|
|
|
|
// Verificação de falhas específicas em `modsComFalha`
|
|
if ((codigo & 0x2000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Movimentação.");
|
|
if ((codigo & 0x4000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Direcional.");
|
|
if ((codigo & 0x8000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Sensoriamento.");
|
|
if ((codigo & 0x10000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Atuador.");
|
|
if ((codigo & 0x20000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de GPS.");
|
|
if ((codigo & 0x40000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Monitoramento de Bateria.");
|
|
if ((codigo & 0x80000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Comunicação.");
|
|
if ((codigo & 0x100000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Orientação.");
|
|
if ((codigo & 0x200000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Movimentação BLD.");
|
|
if ((codigo & 0x400000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Movimentação Unificada.");
|
|
if ((codigo & 0x800000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Modbus.");
|
|
if ((codigo & 0x1000000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Direcional MKS.");
|
|
if ((codigo & 0x2000000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Câmeras.");
|
|
if ((codigo & 0x4000000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Sonar Frontal.");
|
|
if ((codigo & 0x8000000) != 0)
|
|
erros["Módulos"].Add("Falha no Módulo de Ultrassom.");
|
|
|
|
// Verificação de `atuModsFalha`
|
|
if ((codigo & 0x10000000) != 0)
|
|
erros["Atuador"].Add("Falha no atuador Bico Pulverizador B01.");
|
|
if ((codigo & 0x20000000) != 0)
|
|
erros["Atuador"].Add("Falha no atuador Bico Pulverizador B02.");
|
|
if ((codigo & 0x40000000) != 0)
|
|
erros["Atuador"].Add("Falha no atuador Bico Pulverizador B03.");
|
|
if ((codigo & 0x80000000) != 0)
|
|
erros["Atuador"].Add("Falha no atuador Bico Pulverizador B04.");
|
|
if ((codigo & 0x100000000) != 0)
|
|
erros["Atuador"].Add("Falha na Bomba Pressurizadora.");
|
|
if ((codigo & 0x200000000) != 0)
|
|
erros["Atuador"].Add("Falha no sensor de Fluxo/Vazão.");
|
|
if ((codigo & 0x400000000) != 0)
|
|
erros["Atuador"].Add("Falha no sensor de Massa/Volume.");
|
|
if ((codigo & 0x800000000) != 0)
|
|
erros["Atuador"].Add("Falha no sensor de Pressão da linha.");
|
|
|
|
// Verificação de `senModsFalha`
|
|
if ((codigo & 0x1000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no Sinaleiro Modo Manual.");
|
|
if ((codigo & 0x2000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no Sinaleiro Modo Automático.");
|
|
if ((codigo & 0x4000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no Sinaleiro Status da Operação.");
|
|
if ((codigo & 0x8000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sensor de Temperatura Motor Esquerdo Traseira.");
|
|
if ((codigo & 0x10000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sensor de Temperatura Motor Esquerdo Frontal.");
|
|
if ((codigo & 0x20000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sensor de Temperatura Motor Direito Traseira.");
|
|
if ((codigo & 0x40000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sensor de Temperatura Motor Direito Frontal.");
|
|
if ((codigo & 0x80000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sensor de Tensão e Corrente no barramento 5V.");
|
|
if ((codigo & 0x100000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sensor de Tensão e Corrente no barramento 12V.");
|
|
if ((codigo & 0x200000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sensor de Temperatura da Bateria.");
|
|
if ((codigo & 0x400000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no Relé controlador do módulo de Comunicação.");
|
|
if ((codigo & 0x800000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sistema de freio Esquerdo Traseira.");
|
|
if ((codigo & 0x1000000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sistema de freio Esquerdo Frontal.");
|
|
if ((codigo & 0x2000000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sistema de freio Direito Traseira.");
|
|
if ((codigo & 0x4000000000000) != 0)
|
|
erros["Sensoriamento"].Add("Falha no sistema de freio Direito Frontal.");
|
|
|
|
// Verificação de `dirModsFalha`
|
|
if ((codigo & 0x8000000000000) != 0)
|
|
erros["Direcional"].Add("Falha no Motor Direcional Esquerdo Traseira.");
|
|
if ((codigo & 0x10000000000000) != 0)
|
|
erros["Direcional"].Add("Falha no Motor Direcional Esquerdo Frontal.");
|
|
if ((codigo & 0x20000000000000) != 0)
|
|
erros["Direcional"].Add("Falha no Motor Direcional Direito Traseira.");
|
|
if ((codigo & 0x40000000000000) != 0)
|
|
erros["Direcional"].Add("Falha no Motor Direcional Direito Frontal.");
|
|
|
|
// Verificação de `movEsqModsFalha`
|
|
if ((codigo & 0x80000000000000) != 0)
|
|
erros["Movimentação"].Add("Falha no Motor Movimentação Esquerdo Traseira.");
|
|
if ((codigo & 0x100000000000000) != 0)
|
|
erros["Movimentação"].Add("Falha no Motor Movimentação Esquerdo Frontal.");
|
|
|
|
// Verificação de `movDirModsFalha`
|
|
if ((codigo & 0x200000000000000) != 0)
|
|
erros["Movimentação"].Add("Falha no Motor Movimentação Direito Traseira.");
|
|
if ((codigo & 0x400000000000000) != 0)
|
|
erros["Movimentação"].Add("Falha no Motor Movimentação Direito Frontal.");
|
|
|
|
// Verificação de condições de bateria e reservatório
|
|
if ((codigo & 0x800000000000000) != 0)
|
|
erros["Operação"].Add("Nível da bateria abaixo do mínimo.");
|
|
if ((codigo & 0x1000000000000000) != 0)
|
|
erros["Operação"].Add("Nível do reservatório abaixo do mínimo.");
|
|
if ((codigo & 0x2000000000000000) != 0)
|
|
erros["Operação"].Add("Pressão da linha fora dos parâmetros.");
|
|
|
|
// Retorna a lista de erros como uma string única
|
|
var resultado = new StringBuilder();
|
|
foreach (var categoria in erros)
|
|
{
|
|
if (categoria.Value.Count > 0)
|
|
{
|
|
resultado.AppendLine($"{categoria.Key}:");
|
|
resultado.AppendLine(string.Join(", ", categoria.Value));
|
|
}
|
|
}
|
|
|
|
return resultado.Length > 0 ? resultado.ToString() : "Nenhuma falha detectada.";
|
|
}
|
|
|
|
public static void PopularTreeView(TreeView treeView, ulong codigoFalhas)
|
|
{
|
|
// Limpar o TreeView antes de adicionar novos nós
|
|
treeView.Nodes.Clear();
|
|
|
|
// Obtenha a descrição das falhas com base no código atual
|
|
string descricao = DescricaoCodigoFalha(codigoFalhas);
|
|
|
|
// Quebra a descrição em linhas, separando os tópicos e subitens
|
|
string[] linhas = descricao.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
|
|
|
|
TreeNode topicoAtual = null;
|
|
|
|
// Iterar sobre as linhas geradas pela descrição
|
|
foreach (string linha in linhas)
|
|
{
|
|
// Identificar se é um novo tópico (assumimos que tem dois pontos ':' no fim)
|
|
if (linha.EndsWith(":"))
|
|
{
|
|
// Criar um novo nó principal para o tópico
|
|
topicoAtual = new TreeNode(linha.TrimEnd(':'));
|
|
treeView.Nodes.Add(topicoAtual);
|
|
}
|
|
else if (topicoAtual != null && !string.IsNullOrWhiteSpace(linha))
|
|
{
|
|
// Adicionar sub-nós (falhas específicas) ao tópico atual
|
|
string[] topicos = linha.Split(new[] { ',' }, StringSplitOptions.None);
|
|
topicoAtual.Nodes.AddRange(topicos.Select(x => new TreeNode(x.Trim())).ToArray());
|
|
}
|
|
}
|
|
|
|
// Expandir todos os nós para melhor visualização
|
|
treeView.ExpandAll();
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
|
|
public class OperacaoControleModel
|
|
{
|
|
public int RPM_Max { get; set; } = 100;
|
|
public int RPM_Min { get; set; } = 15;
|
|
public double Angulo_Max { get; set; } = 30;
|
|
public double Angulo_Min { get; set; } = -30;
|
|
public double VelocidadeMP { get; set; } = 50;
|
|
|
|
public double Angulo { get; set; } = 0;
|
|
public int RPM_SP
|
|
{
|
|
get
|
|
{
|
|
return Convert.ToInt32(VariaveisEquipamento.RPM_Max_Roda * (PercentualVelocidadeSP / 100.0));
|
|
}
|
|
}
|
|
public int RPM_Motor
|
|
{
|
|
get
|
|
{
|
|
return Convert.ToInt32(RPM_SP * VariaveisEquipamento.RelacaoRPM);
|
|
}
|
|
}
|
|
public double PercentualVelocidadeSP { get; set; } = 0.0;
|
|
public double PercentualVelocidadeMin
|
|
{
|
|
get
|
|
{
|
|
return FuncoesMatematicas.Map(RPM_Min, 0, VariaveisEquipamento.RPM_Max_Roda, 0, 100);
|
|
}
|
|
}
|
|
public double PercentualVelocidadeMax
|
|
{
|
|
get
|
|
{
|
|
return FuncoesMatematicas.Map(RPM_Max, 0, VariaveisEquipamento.RPM_Max_Roda, 0, 100);
|
|
}
|
|
}
|
|
public Direcao Direcao { get; set; } = Direcao.Parado;
|
|
private TipoMovimentoDirecional _tipoMovimento;
|
|
public TipoMovimentoDirecional TipoMovimento
|
|
{
|
|
get
|
|
{
|
|
return _tipoMovimento;
|
|
}
|
|
set
|
|
{
|
|
var DispMvd = Variaveis.OperacaoEmAndamento.DispMvd;
|
|
if (DispMvd != null)
|
|
{
|
|
switch (value)
|
|
{
|
|
case TipoMovimentoDirecional.RodasDianteiras:
|
|
DispMvd.Dados.Modulos.ForEach(x =>
|
|
{
|
|
x.MovMotor.Comandar = true;
|
|
x.DirMotor.Comandar = x.Modulo_ID.Contains("F");
|
|
});
|
|
break;
|
|
case TipoMovimentoDirecional.RodasTraseiras:
|
|
DispMvd.Dados.Modulos.ForEach(x =>
|
|
{
|
|
x.MovMotor.Comandar = true;
|
|
x.DirMotor.Comandar = x.Modulo_ID.Contains("T");
|
|
});
|
|
break;
|
|
default:
|
|
DispMvd.Dados.Modulos.ForEach(x =>
|
|
{
|
|
x.MovMotor.Comandar = true;
|
|
x.DirMotor.Comandar = true;
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
_tipoMovimento = value;
|
|
}
|
|
}
|
|
|
|
public double PercentualInicioPulverizacao { get; set; } = 0.3;
|
|
public List<AtuadorBicoModel> BicosAtuados { get; set; } = new List<AtuadorBicoModel>();
|
|
public int TempoAtuacao { get; set; } = 500;
|
|
public double PressaoLinha { get; set; } = 85;
|
|
|
|
public List<OperacaoControleTipoModel> TiposControle { get; set; }
|
|
public PIDModel PIDdirecional { get; set; } = new PIDModel();
|
|
}
|
|
|
|
public class OperacaoControleTipoModel
|
|
{
|
|
public T_Code Tipo { get; set; }
|
|
public int DelayEnvioComando { get; set; }
|
|
public DateTime UltimoComando { get; set; }
|
|
public List<string> Comandos { get; set; }
|
|
public Direcao UltimaDirecao { get; set; } = Direcao.Parado;
|
|
}
|
|
|
|
public class OperacaoModulosMandatoriosModel
|
|
{
|
|
public T_Code Dispositivo { get; set; }
|
|
public bool Mandatorio { get; set; }
|
|
public bool Utilizar { get; set; }
|
|
public bool Conectado { get; set; }
|
|
}
|
|
|
|
public class OperacaoParametrosMandatoriosModel
|
|
{
|
|
public ParametrosOperacao Parametro { get; set; }
|
|
public bool Mandatorio { get; set; }
|
|
public bool Utilizar { get; set; }
|
|
public bool Pronto { get; set; }
|
|
}
|
|
|
|
public class OperacaoControleBaseModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public Keys Tecla { get; set; }
|
|
public T_Code Dispositivo { get; set; }
|
|
public double PercentualVelocidadeSP { get; set; }
|
|
public double AnguloMP { get; set; }
|
|
public double VelocidadeMP { get; set; }
|
|
public bool Emergencia { get; set; }
|
|
public TipoMovimentoDirecional TipoMovimento { get; set; }
|
|
}
|
|
|
|
|
|
public class OperacaoDadosModel
|
|
{
|
|
public string id { get; set; }
|
|
public string operacao { get; set; }
|
|
public string gps { get; set; }
|
|
public string dir { get; set; }
|
|
public string mov { get; set; }
|
|
public string atu { get; set; }
|
|
public string sen { get; set; }
|
|
public string pzm { get; set; }
|
|
public string wit { get; set; }
|
|
public string knt { get; set; }
|
|
public string a05 { get; set; }
|
|
public string caminho { get; set; }
|
|
public string soloE { get; set; }
|
|
public string soloD { get; set; }
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public ulong CodigoFalha
|
|
{
|
|
get
|
|
{
|
|
return Variaveis.OperacaoEmAndamento.RetornaCodigoFalha();
|
|
}
|
|
}
|
|
public double VelocidadeMedia
|
|
{
|
|
get
|
|
{
|
|
return Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Average(x => x.MovMotor.VelocidadeInstantanea);
|
|
}
|
|
}
|
|
public double PorcentagemBateria
|
|
{
|
|
get
|
|
{
|
|
if (PZEMService.Iniciado)
|
|
{
|
|
return FuncoesMatematicas.Map(PZEMService.UltimaLeitura.Tensao, PZEMService.TensaoMinima, PZEMService.TensaoMaxima, 0.0, 100.0);
|
|
}
|
|
else
|
|
{
|
|
return 0.0;
|
|
}
|
|
}
|
|
}
|
|
public double BateriaConsumida { get; set; } = 0;
|
|
public List<double> DistanciaPercorrida { get; set; } = new List<double>();
|
|
public double DistanciaEsquerda { get; set; } = 0;
|
|
public double DistanciaDireita { get; set; } = 0;
|
|
public double AnguloCarroGPS
|
|
{
|
|
get
|
|
{
|
|
int PontosConsiderarAngulo = 2;
|
|
double Angulo = 0;
|
|
|
|
int Indice = Variaveis.OperacaoEmAndamento.Mapa.mapaService.MapaUrl != "" ? Variaveis.OperacaoEmAndamento.Mapa.IdxRuaAtual : 0;
|
|
|
|
try
|
|
{
|
|
double somaAngulo = 0;
|
|
var Pontos = !Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua.Any() || Indice >= Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua.Count() ? new List<GPSModel>() :
|
|
Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua[Indice].Count > PontosConsiderarAngulo ?
|
|
Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua[Indice].OrderByDescending(x => x.DataHora).Take(PontosConsiderarAngulo).ToList() :
|
|
Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua[Indice].OrderByDescending(x => x.DataHora).ToList();
|
|
Pontos = Pontos.OrderBy(x => x.DataHora).ToList();
|
|
for (int i = 0; i < Pontos.Count() - 1; i++)
|
|
{
|
|
somaAngulo += GPSService.CalcularOrientacao(Pontos[i], Pontos[i + 1]);
|
|
}
|
|
double mediaAngulo = somaAngulo / (Pontos.Count() - 1);
|
|
|
|
Angulo = (!(mediaAngulo >= 0 || mediaAngulo <= 0)) ? 0 : mediaAngulo;
|
|
}
|
|
catch
|
|
{
|
|
Angulo = 0;
|
|
}
|
|
|
|
return Angulo;
|
|
}
|
|
}
|
|
public double AnguloCarroBussola { get; set; } = 0;
|
|
public double AnguloCarro
|
|
{
|
|
get
|
|
{
|
|
if (
|
|
WT901CService.Iniciado ||
|
|
(Variaveis.OperacaoEmAndamento.DispSen._Porta.IsOpen && Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.Any(x => x.Componente == S_Code.sMAG && x.Inicializado))
|
|
)
|
|
{
|
|
return AnguloCarroBussola;
|
|
}
|
|
else
|
|
{
|
|
return AnguloCarroGPS;
|
|
}
|
|
}
|
|
}
|
|
public KinectModel SonarFrontal_Kinect
|
|
{
|
|
get
|
|
{
|
|
if (KinectService.Iniciado)
|
|
{
|
|
return KinectService.Leitura;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
public SonarModel SonarFrontal_old { get; set; }
|
|
public double TempoMovimento { get;set; }
|
|
public StatusOperacao StatusOperacao
|
|
{
|
|
get
|
|
{
|
|
return Variaveis.OperacaoEmAndamento.StatusAtual;
|
|
}
|
|
}
|
|
public StatusCarroMapa StatusCarro { get; set; }
|
|
public int ErvasNoRadar { get; set; } = 0;
|
|
public double HerbicidaConsumido { get; set; } = 0;
|
|
public double HerbicidaPorErva { get; set; } = 0;
|
|
public int ErvasIdentificadas { get; set; } = 0;
|
|
public double ProgressoTrajeto { get; set; } = 0;
|
|
public double ProgressoRua { get; set; } = 0;
|
|
public double AnguloRua { get; set; } = 0;
|
|
public double AnguloRuaCamera { get; set; } = 0;
|
|
public double AnguloDif { get; set; } = 0;
|
|
public DirecaoCarroRua Direcao { get; set; } = DirecaoCarroRua.Parado;
|
|
public bool DentroDaRua { get; set; } = false;
|
|
public int IdxPontoAproximadoRua { get; set; } = 0;
|
|
public int IdxRuaAtual { get; set; } = 0;
|
|
public double InclinacaoX { get; set; } = 0;
|
|
public double InclinacaoY { get; set; } = 0;
|
|
public double InclinacaoZ { get; set; } = 0;
|
|
public double Temperatura { get; set; } = 0;
|
|
public double Pressao { get; set; } = 0;
|
|
public double Altitude { get; set; } = 0;
|
|
public TipoMovimentoDirecional TipoMovimento { get; set; }
|
|
public float? CPU_load { get; set; }
|
|
public float? GPU_load { get; set; }
|
|
public float? HDD_load { get; set; }
|
|
public float? RAM_usage { get; set; }
|
|
public float? CPU_temp { get; set; }
|
|
public float? GPU_temp { get; set; }
|
|
public bool OperacaoLiberada { get; set; }
|
|
public (bool, List<string>) MovEsq_Status { get; set; }
|
|
public (bool, List<string>) MovDir_Status { get; set; }
|
|
public (bool, List<string>) Dir_Status { get; set; }
|
|
public double PercentualErvasTerreno
|
|
{
|
|
get
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.Tempo.TotalMilliseconds == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
double p = Math.Round((Variaveis.OperacaoEmAndamento.DispAtu.Dados.TempoAtuado / Variaveis.OperacaoEmAndamento.Tempo.TotalMilliseconds) * 100, 2);
|
|
return p;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class PzmSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public DateTime DataHora { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public double Tensao { get; set; }
|
|
public double Corrente { get; set; }
|
|
public double Potencia { get; set; }
|
|
public double Energia { get; set; }
|
|
public bool AlarmeTensaoMax { get; set; }
|
|
public bool AlarmeTensaoMin { get; set; }
|
|
}
|
|
|
|
public class WitSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public DateTime DataHora { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public double AccM { get; set; }
|
|
public double AsM { get; set; }
|
|
public double AngleX { get; set; }
|
|
public double AngleY { get; set; }
|
|
public double AngleZ { get; set; }
|
|
public double HM { get; set; }
|
|
public double Temperatura { get; set; }
|
|
public double Pressao { get; set; }
|
|
public double Altitude { get; set; }
|
|
}
|
|
|
|
public class DirSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public string Modulo_ID { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public bool Controlar { get; set; }
|
|
public double Angulo_SP { get; set; }
|
|
public double Angulo { get; set; }
|
|
public Sentido Sentido_SP { get; set; }
|
|
public Sentido Sentido { get; set; }
|
|
public double Velocidade { get; set; }
|
|
}
|
|
|
|
public class MovSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public string Modulo_ID { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public double RPM_SP { get; set; }
|
|
public double RPM_Motor { get; set; }
|
|
public double RPM_Roda { get; set; }
|
|
public double Velocidade { get; set; }
|
|
public Sentido Sentido_SP { get; set; }
|
|
public Sentido Sentido { get; set; }
|
|
public double Temperatura { get; set; }
|
|
public double TemperaturaDriver { get; set; }
|
|
public double Corrente { get; set; }
|
|
public double Tensao { get; set; }
|
|
public int CodAlarme { get; set; }
|
|
public bool EmFreio { get; set; }
|
|
public bool Ativado { get; set; }
|
|
}
|
|
|
|
public class AtuSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public bool Inicializado { 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 double VazaoFluxoMLpS { get; set; }
|
|
public double VolumeVazaoML { get; set; }
|
|
public int QuantidadeBicos { get; set; }
|
|
public List<AtuBicoSensoriamentoLogModel> Bicos { get; set; }
|
|
}
|
|
|
|
public class AtuBicoSensoriamentoLogModel
|
|
{
|
|
public string ID { get; set; }
|
|
public int Posicao { get; set; }
|
|
public bool Atuado { get; set; }
|
|
public bool Comandar { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public bool StatusBico { get; set; }
|
|
public double MediaNivelFluxo { get; set; }
|
|
public int Atuacoes { get; set; }
|
|
}
|
|
|
|
public class SenSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public double Barramento3v3Tensao { get; set; }
|
|
public double Barramento3v3Corrente { get; set; }
|
|
public double Barramento5vTensao { get; set; }
|
|
public double Barramento5vCorrente { get; set; }
|
|
public double Barramento7v2Tensao { get; set; }
|
|
public double Barramento7v2Corrente { get; set; }
|
|
public double Barramento12vTensao { get; set; }
|
|
public double Barramento12vCorrente { get; set; }
|
|
public double OrientacaoMagnetica { get; set; }
|
|
public StatusLED StatusSinaleiroMN { get; set; }
|
|
public StatusLED StatusSinaleiroAT { get; set; }
|
|
public StatusLED StatusSinaleiroOP { get; set; }
|
|
public Estado StatusReleLoRa { get; set; }
|
|
public int AnguloFreioET { get; set; }
|
|
public int AnguloFreioEF { get; set; }
|
|
public int AnguloFreioDT { get; set; }
|
|
public int AnguloFreioDF { 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; }
|
|
}
|
|
|
|
}
|