833 lines
35 KiB
C#
833 lines
35 KiB
C#
using AgroBase.Comum;
|
|
using AgroBase.Forms;
|
|
using AgroBase.Forms.Operacoes;
|
|
using AgroBase.Models.Modules;
|
|
using AgroBase.Models.Operacoes;
|
|
using AgroBase.Services;
|
|
using CefSharp.DevTools.Network;
|
|
using Emgu.CV.CvEnum;
|
|
using Newtonsoft.Json;
|
|
using OpenTK.Graphics.ES11;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using static AgroBase.Models.Enuns;
|
|
|
|
namespace AgroBase.Models
|
|
{
|
|
public class OperacaoModel
|
|
{
|
|
public OperacaoModel(ModoOperacao Modo, DispositivosService<MovimentacaoModel> Mov = null, DispositivosService<DirecionalModel> Dir = null, DispositivosService<AtuadorModel> Atu = null)
|
|
{
|
|
this.Modo = Modo;
|
|
|
|
this.DispMov = Mov;
|
|
this.DispDir = Dir;
|
|
this.DispAtu = Atu;
|
|
|
|
if (Modo == ModoOperacao.MapaGPS)
|
|
{
|
|
this.OpMapaGPS.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.OpMapaGPS.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 (!this.tmrLogs.Enabled)
|
|
{
|
|
this.tmrLogs.Tick -= TmrLogs_Tick;
|
|
this.tmrLogs.Tick += TmrLogs_Tick;
|
|
this.tmrLogs.Start();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public ModoOperacao Modo { get; set; }
|
|
public OperacaoMapaGPSModel OpMapaGPS { get; set; } = new OperacaoMapaGPSModel();
|
|
public OperacaoManualModel OpManual { get; set; } = new OperacaoManualModel();
|
|
public DispositivosService<SensoriamentoModel> DispSen { get; set; }
|
|
public DispositivosService<MovimentacaoModel> DispMov { get; set; }
|
|
public DispositivosService<DirecionalModel> DispDir { get; set; }
|
|
public DispositivosService<AtuadorModel> DispAtu { get; set; }
|
|
public MapasModel Mapa { get; set; } = new MapasModel();
|
|
public OperacaoSensoriamentoModel Sensoriamento { get; set; }
|
|
public Form frmOperacao { get; set; }
|
|
private StatusOperacao _EtapaAtual;
|
|
private StatusOperacao _EtapaAnteriorParada = StatusOperacao.Parado;
|
|
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;
|
|
}
|
|
}
|
|
// 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;
|
|
}
|
|
// 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;
|
|
}
|
|
// Etapa atual é finalizada, então finaliza a operação
|
|
else if (_EtapaAtual == StatusOperacao.Concluido)
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.Iniciado)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.FinalizarOperacao();
|
|
}
|
|
}
|
|
// 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 ModulosConectados
|
|
{
|
|
get
|
|
{
|
|
ModulosMandatorios.ForEach(Modulo =>
|
|
{
|
|
if (Modulo.Dispositivo == T_Code.Gps)
|
|
{
|
|
Modulo.Conectado = GPSService.PortaGPS != null && GPSService.PortaGPS.IsOpen;
|
|
}
|
|
else
|
|
{
|
|
Modulo.Conectado = Variaveis.DispositivosConectados.Any(x => x.Dispositivo == Modulo.Dispositivo && x._Porta.IsOpen);
|
|
}
|
|
});
|
|
|
|
bool _modulosConectados =
|
|
(ModulosMandatorios.Where(x => x.Mandatorio).All(x => x.Conectado) && ModulosMandatorios.Any(x => x.Mandatorio)) ||
|
|
(ModulosMandatorios.All(x => !x.Mandatorio) && ModulosMandatorios.Any(x => x.Conectado));
|
|
|
|
|
|
return _modulosConectados;
|
|
}
|
|
}
|
|
public bool OperacaoLiberada
|
|
{
|
|
get
|
|
{
|
|
bool _operacaoLiberada = ModulosConectados;
|
|
if (ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo && x.Mandatorio) && CamerasSolo.Count(x => x.Iniciada) < QuantidadeCamerasSolo) _operacaoLiberada = false;
|
|
if (ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraCaminho && x.Mandatorio) && (CameraCaminho == null || !CameraCaminho.Iniciada)) _operacaoLiberada = false;
|
|
if (ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && x.Mandatorio) && !Mapa.mapaService.Carregado) _operacaoLiberada = false;
|
|
if (ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick && x.Mandatorio && GeneralJoystick.JoystickConectado == null)) _operacaoLiberada = false;
|
|
|
|
if (frmInstancial.frmPrincipal.chbDebugMode.Checked) _operacaoLiberada = true;
|
|
|
|
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 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<OperacaoSensoriamentoModel> Logs { get; set; } = new List<OperacaoSensoriamentoModel>();
|
|
public List<GPSModel> GPSTrajetoria { get; set; } = new List<GPSModel>();
|
|
public List<List<GPSModel>> GPSTrajetoriaRua { get; set; } = new List<List<GPSModel>>();
|
|
public DirecaoCarroRua DirecaoCaminho
|
|
{
|
|
get
|
|
{
|
|
DirecaoCarroRua direcaoCaminho = Mapa.IdxRuaAtual % 2 == 0 ? DirecaoCarroRua.Ida : DirecaoCarroRua.Volta;
|
|
return direcaoCaminho;
|
|
}
|
|
}
|
|
public int QuantidadeCamerasSolo { get; set; } = 2;
|
|
public List<CameraSoloModel> CamerasSolo { get; set; } = new List<CameraSoloModel>();
|
|
public CameraCaminhoModel CameraCaminho { get; set; }
|
|
public int TempoIniciarOperacao { get; set; } = 25;
|
|
public string ID { get; set; }
|
|
public Timer tmrLogs = new Timer() { Interval = 5000 };
|
|
|
|
|
|
public static OperacaoModel CarregarParametrosOperacaoPadrao(ModoOperacao Modo)
|
|
{
|
|
var SenConectado = (DispositivosService<SensoriamentoModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Sen);
|
|
var MovConectado = (DispositivosService<MovimentacaoModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Mov);
|
|
var DirConectado = (DispositivosService<DirecionalModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Dir);
|
|
var AtuConectado = (DispositivosService<AtuadorModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Atu);
|
|
|
|
Variaveis.OperacaoEmAndamento.tmrLogs.Stop();
|
|
|
|
OperacaoModel OperacaoCarregar = new OperacaoModel(Modo)
|
|
{
|
|
Iniciado = false,
|
|
TimestampInicio = 0,
|
|
TimestampFim = 0,
|
|
DispAtu = AtuConectado,
|
|
DispDir = DirConectado,
|
|
DispMov = MovConectado,
|
|
DispSen = SenConectado,
|
|
Logs = new List<OperacaoSensoriamentoModel>(),
|
|
Sensoriamento = new OperacaoSensoriamentoModel(),
|
|
};
|
|
|
|
|
|
switch (Modo)
|
|
{
|
|
case ModoOperacao.Manual:
|
|
OperacaoCarregar.frmOperacao = (Form)Activator.CreateInstance(Variaveis.OperacaoEmAndamento.OpManual.frmOperacao.GetType());
|
|
OperacaoCarregar.OpManual.Controle = new OperacaoControleModel()
|
|
{
|
|
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
|
|
},
|
|
},
|
|
};
|
|
OperacaoCarregar.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
|
|
{
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Mov,
|
|
Mandatorio = false,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Dir,
|
|
Mandatorio = false,
|
|
},
|
|
};
|
|
OperacaoCarregar.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
|
|
{
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.Joystick,
|
|
Mandatorio = false,
|
|
}
|
|
};
|
|
OperacaoCarregar.Sensoriamento.SonarFrontal = new SonarModel(FuncoesGlobais.FindControlRecursive<PictureBox>(OperacaoCarregar.frmOperacao, "picSonar"));
|
|
break;
|
|
case ModoOperacao.MapaGPS:
|
|
OperacaoCarregar.frmOperacao = (Form)Activator.CreateInstance(Variaveis.OperacaoEmAndamento.OpMapaGPS.frmOperacao.GetType());
|
|
OperacaoCarregar.Logs = new List<OperacaoSensoriamentoModel>();
|
|
OperacaoCarregar.OpMapaGPS.ControleAnterior = new OperacaoControleModel();
|
|
OperacaoCarregar.OpMapaGPS.Controle = new OperacaoControleModel()
|
|
{
|
|
RPM_Max = 45,
|
|
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.Mov,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Dir,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Atu,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Gps,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoModulosMandatoriosModel()
|
|
{
|
|
Dispositivo = T_Code.Sen,
|
|
Mandatorio = false,
|
|
}
|
|
};
|
|
OperacaoCarregar.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
|
|
{
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.CameraSolo,
|
|
Mandatorio = true,
|
|
},
|
|
new OperacaoParametrosMandatoriosModel()
|
|
{
|
|
Parametro = ParametrosOperacao.CameraCaminho,
|
|
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;
|
|
}
|
|
|
|
if (OperacaoCarregar.DispSen != null && OperacaoCarregar.DispSen.Dados.Conectado)
|
|
{
|
|
OperacaoCarregar.DispSen.Dados.Sinaleiros.ForEach(x => x.Comportamento = Variaveis.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 = Variaveis.ComportamentoPorStatus();
|
|
|
|
|
|
OperacaoCarregar.DispSen.Dados.Sinaleiros.ForEach(x => OperacaoCarregar.DispSen.AdicionarMensagemFila(x.ProtocoloComando()));
|
|
}
|
|
|
|
|
|
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 void IniciarOperacao(OperacaoControleModel controle = null, bool DaIHM = true)
|
|
{
|
|
Iniciado = true;
|
|
TimestampInicio = DateTime.Now.Ticks;
|
|
TempoAguardando = DateTime.Now;
|
|
TimestampFim = 0;
|
|
Mapa.IdxRuaAtual = 0;
|
|
if (DispMov != null)
|
|
{
|
|
DispMov.Dados.DistanciaPercorridaOperacao = 0;
|
|
DispMov.Dados.TempoEmAtividade = 0;
|
|
}
|
|
if (DispDir != null)
|
|
{
|
|
DispDir.Dados.Motores.ForEach(x =>
|
|
{
|
|
x.Referenciado = false;
|
|
x.Referenciando = false;
|
|
});
|
|
}
|
|
Sensoriamento.DistanciaPercorrida = new List<double>();
|
|
if (Modo == ModoOperacao.MapaGPS)
|
|
{
|
|
OpMapaGPS.Sensoriamento = new OperacaoMapaGPSSensoriamentoModel();
|
|
OpMapaGPS.Logs = new List<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;
|
|
}
|
|
OpMapaGPS.Controle.PIDdirecional = new PIDModel()
|
|
{
|
|
LimiteSaida = OpMapaGPS.Controle.Angulo_Max,
|
|
SetPoint = 0,
|
|
Kp = 1.0,
|
|
Ki = 0.1,
|
|
Kd = 0.01,
|
|
};
|
|
if (controle != null)
|
|
{
|
|
OpMapaGPS.Controle = controle;
|
|
}
|
|
}
|
|
Logs = new List<OperacaoSensoriamentoModel>();
|
|
GPSTrajetoria = new List<GPSModel>();
|
|
ID = (new DateTime(TimestampInicio)).ToString("dd_MM_yyyy_HH_mm_ss");
|
|
|
|
Directory.CreateDirectory(Variaveis.CaminhoOperacoes + ID + "/");
|
|
|
|
GPSService.IniciarRecepcaoDados();
|
|
|
|
//Controle = new OperacaoControleModel();
|
|
//ControleAnterior = new OperacaoControleModel();
|
|
|
|
|
|
//tmrParametrizacao.Stop();
|
|
|
|
RealizarCalibracaoInicialAsync().ConfigureAwait(false);
|
|
}
|
|
|
|
public void FinalizarOperacao()
|
|
{
|
|
if (Modo == ModoOperacao.MapaGPS)
|
|
{
|
|
OpMapaGPS.Controle.Angulo = 0;
|
|
OpMapaGPS.Controle.RPM = 0;
|
|
OpMapaGPS.AtualizarDadosControle();
|
|
}
|
|
if (DispAtu.Dados.BombaPressurizadora.Inicializado)
|
|
{
|
|
DispAtu.Dados.BombaPressurizadora.BombaAtuada = false;
|
|
string Protocolo = DispAtu.Dados.BombaPressurizadora.ProtocoloComando();
|
|
DispAtu.AdicionarMensagemFila(Protocolo);
|
|
}
|
|
|
|
Iniciado = false;
|
|
TimestampFim = DateTime.Now.Ticks;
|
|
|
|
//tmrLogs.Stop();
|
|
//tmrParametrizacao.Start();
|
|
|
|
SalvarLog(true);
|
|
|
|
GPSService.PararRecepcaoDados();
|
|
|
|
AtualizarSinaleiroOperacao();
|
|
}
|
|
|
|
public async Task RealizarCalibracaoInicialAsync()
|
|
{
|
|
if (DispAtu != null)
|
|
{
|
|
// Ligar bomba
|
|
if (DispAtu.Dados.BombaPressurizadora.Inicializado)
|
|
{
|
|
DispAtu.Dados.BombaPressurizadora.BombaAtuada = true;
|
|
string Protocolo = DispAtu.Dados.BombaPressurizadora.ProtocoloComando();
|
|
DispAtu.AdicionarMensagemFila(Protocolo);
|
|
}
|
|
|
|
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)
|
|
{
|
|
Bico.Atuado = true;
|
|
DispAtu.AdicionarMensagemFila(Bico.ProtocoloComando());
|
|
|
|
await Task.Delay(1000);
|
|
|
|
Bico.Atuado = false;
|
|
DispAtu.AdicionarMensagemFila(Bico.ProtocoloComando());
|
|
}
|
|
}
|
|
|
|
await Task.Delay(1000);
|
|
}
|
|
|
|
// Referenciar o direcional
|
|
if (DispDir != null)
|
|
{
|
|
foreach (var Motor in DispDir.Dados.Motores)
|
|
{
|
|
DispDir.AdicionarMensagemFila(Motor.ProtocoloComando(Direcao.Parado, true));
|
|
|
|
while (Motor.Referenciando)
|
|
{
|
|
await Task.Delay(500);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SalvarLog(bool Fim)
|
|
{
|
|
if (!string.IsNullOrEmpty(ID))
|
|
{
|
|
Logs.Add(new OperacaoSensoriamentoModel()
|
|
{
|
|
Momento = DateTime.Now,
|
|
BateriaConsumida = Sensoriamento.BateriaConsumida,
|
|
DistanciaDireita = Sensoriamento.DistanciaDireita,
|
|
DistanciaEsquerda = Sensoriamento.DistanciaEsquerda,
|
|
DistanciaPercorrida = new List<double>(Sensoriamento.DistanciaPercorrida),
|
|
PorcentagemBateria = Sensoriamento.PorcentagemBateria,
|
|
AnguloCarroBussola = Sensoriamento.AnguloCarroBussola
|
|
});
|
|
if (!Directory.Exists(Variaveis.CaminhoOperacoes + ID))
|
|
{
|
|
Directory.CreateDirectory(Variaveis.CaminhoOperacoes + ID);
|
|
}
|
|
if (!File.Exists(Variaveis.CaminhoOperacoes + ID + "/logsGerais.json"))
|
|
{
|
|
string jsonLog = JsonConvert.SerializeObject(Logs, Formatting.None);
|
|
File.WriteAllText(Variaveis.CaminhoOperacoes + ID + "/logsGerais.json", jsonLog.Substring(0, jsonLog.Length - 1));
|
|
}
|
|
else
|
|
{
|
|
string jsonLog = JsonConvert.SerializeObject(Logs[Logs.Count - 1], Formatting.None);
|
|
File.AppendAllText(Variaveis.CaminhoOperacoes + ID + "/logsGerais.json", "," + jsonLog + (Fim ? "]" : ""));
|
|
}
|
|
|
|
|
|
|
|
File.WriteAllText(Variaveis.CaminhoOperacoes + ID + "/trajetoria.json", JsonConvert.SerializeObject(GPSTrajetoria, Formatting.None));
|
|
}
|
|
}
|
|
|
|
private void TmrLogs_Tick(object sender, EventArgs e)
|
|
{
|
|
if (Iniciado)
|
|
{
|
|
SalvarLog(false);
|
|
}
|
|
|
|
AtualizarSinaleiroOperacao();
|
|
}
|
|
|
|
public void AtualizarSinaleiroOperacao()
|
|
{
|
|
if (DispSen != null && DispSen.Dados.Conectado)
|
|
{
|
|
DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDOP").Comportamento = Variaveis.ComportamentoPorStatus();
|
|
DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDAT").Comportamento.statusLED = Modo == ModoOperacao.MapaGPS ? StatusLED.Aceso : StatusLED.Apagado;
|
|
DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDMN").Comportamento.statusLED = Modo == ModoOperacao.Manual ? StatusLED.Aceso : StatusLED.Apagado;
|
|
|
|
DispSen.Dados.Sinaleiros.ForEach(x => DispSen.AdicionarMensagemFila(x.ProtocoloComando()));
|
|
}
|
|
}
|
|
|
|
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());
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal = 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;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public class OperacaoSensoriamentoModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public double VelocidadeMedia
|
|
{
|
|
get
|
|
{
|
|
return Variaveis.OperacaoEmAndamento.DispMov.Dados.Motores.Average(x => x.VelocidadeInstantanea);
|
|
}
|
|
}
|
|
public double PorcentagemBateria { get; set; } = 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 + 1], Pontos[i]);
|
|
}
|
|
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 (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 SonarModel SonarFrontal { get; set; }
|
|
|
|
}
|
|
|
|
public class OperacaoControleModel
|
|
{
|
|
public int RPM_Max { get; set; } = 45;
|
|
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 { get; set; } = 0;
|
|
public Direcao Direcao { get; set; } = Direcao.Parado;
|
|
public List<AtuadorBicoModel> BicosAtuados { get; set; } = new List<AtuadorBicoModel>();
|
|
|
|
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 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; }
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|