1175 lines
52 KiB
C#
1175 lines
52 KiB
C#
using AForge.Video.DirectShow;
|
|
using AForge.Video;
|
|
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;
|
|
using CefSharp.DevTools.Page;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
|
|
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<MovimentacaoUnificadaModel> DispMvd { get; set; }
|
|
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 OperacaoSensoriamentoLogModel 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;
|
|
}
|
|
else
|
|
{
|
|
Modulo.Conectado = !Modulo.Mandatorio || 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<GPSModel> GPSTrajetoria { get; set; } = new List<GPSModel>();
|
|
public List<List<GPSModel>> GPSTrajetoriaRua { get; set; } = new List<List<GPSModel>>();
|
|
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 = 1000 };
|
|
|
|
|
|
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);
|
|
|
|
var MvdConectado = (DispositivosService<MovimentacaoUnificadaModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Mvd);
|
|
|
|
Variaveis.OperacaoEmAndamento.tmrLogs.Stop();
|
|
|
|
OperacaoModel OperacaoCarregar = new OperacaoModel(Modo)
|
|
{
|
|
Iniciado = false,
|
|
TimestampInicio = 0,
|
|
TimestampFim = 0,
|
|
DispAtu = AtuConectado,
|
|
DispDir = DirConectado,
|
|
DispMov = MovConectado,
|
|
DispSen = SenConectado,
|
|
DispMvd = MvdConectado,
|
|
Sensoriamento = new OperacaoSensoriamentoLogModel(),
|
|
};
|
|
|
|
|
|
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.Mvd,
|
|
Mandatorio = true,
|
|
},
|
|
};
|
|
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.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(Variaveis.OperacaoEmAndamento.DispSen.Dados.Modulo_ID, x.ProtocoloComando(), true, false));
|
|
}
|
|
|
|
|
|
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 (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;
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
GPSTrajetoria = new List<GPSModel>();
|
|
ID = (new DateTime(TimestampInicio)).ToString("dd_MM_yyyy_HH_mm_ss");
|
|
idxLog = 0;
|
|
|
|
Directory.CreateDirectory(Variaveis.CaminhoOperacoes + ID + "/");
|
|
|
|
//Controle = new OperacaoControleModel();
|
|
//ControleAnterior = new OperacaoControleModel();
|
|
|
|
|
|
//tmrParametrizacao.Stop();
|
|
|
|
//RealizarCalibracaoInicialAsync().ConfigureAwait(false);
|
|
|
|
Mapa.GerarTrajetoriaDinamica();
|
|
}
|
|
|
|
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(DispAtu.Dados.Modulo_ID, Protocolo, true, false);
|
|
}
|
|
|
|
Iniciado = false;
|
|
TimestampFim = DateTime.Now.Ticks;
|
|
|
|
//tmrLogs.Stop();
|
|
//tmrParametrizacao.Start();
|
|
|
|
SalvarLogs(false);
|
|
|
|
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(DispAtu.Dados.Modulo_ID, Protocolo, true, 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)
|
|
{
|
|
Bico.Atuado = true;
|
|
DispAtu.AdicionarMensagemFila(DispAtu.Dados.Modulo_ID, Bico.ProtocoloComando(), true, true);
|
|
|
|
await Task.Delay(1000);
|
|
|
|
Bico.Atuado = false;
|
|
DispAtu.AdicionarMensagemFila(DispAtu.Dados.Modulo_ID, Bico.ProtocoloComando(), true, true);
|
|
}
|
|
}
|
|
|
|
await Task.Delay(1000);
|
|
}
|
|
}
|
|
|
|
|
|
#region REGISTRO DE LOGS
|
|
|
|
private int idxLog = 0;
|
|
|
|
private void TmrLogs_Tick(object sender, EventArgs e)
|
|
{
|
|
if (Iniciado)
|
|
{
|
|
SalvarLogs(false);
|
|
}
|
|
|
|
AtualizarSinaleiroOperacao();
|
|
}
|
|
|
|
public void SalvarLogs(bool Fim)
|
|
{
|
|
if (!string.IsNullOrEmpty(ID))
|
|
{
|
|
DateTime Agora = DateTime.Now;
|
|
|
|
OperacaoSensoriamentoLogModel logGeral = new OperacaoSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
BateriaConsumida = Sensoriamento.BateriaConsumida,
|
|
DistanciaDireita = Sensoriamento.DistanciaDireita,
|
|
DistanciaEsquerda = Sensoriamento.DistanciaEsquerda,
|
|
DistanciaPercorrida = new List<double>(Sensoriamento.DistanciaPercorrida),
|
|
PorcentagemBateria = Sensoriamento.PorcentagemBateria,
|
|
AnguloCarroBussola = Sensoriamento.AnguloCarroBussola,
|
|
TempoMovimento = DispMvd.Dados.TempoEmAtividade,
|
|
StatusOperacao = _EtapaAtual,
|
|
StatusCarro = OpMapaGPS.ReferencialRuaGPS.StatusAtual,
|
|
ErvasIdentificadas = OpMapaGPS.Sensoriamento.AtuacoesPorBico.Sum(),
|
|
ErvasNoRadar = Sensoriamento.ErvasNoRadar,
|
|
HerbicidaConsumido = Sensoriamento.HerbicidaConsumido,
|
|
HerbicidaPorErva = Sensoriamento.HerbicidaPorErva,
|
|
ProgressoTrajeto = Sensoriamento.ProgressoTrajeto,
|
|
ProgressoRua = Sensoriamento.ProgressoRua,
|
|
Direcao = OpMapaGPS.ReferencialRuaGPS.Direcao,
|
|
AnguloRua = Mapa.AnguloCaminho,
|
|
DentroDaRua = OpMapaGPS.ReferencialRuaGPS.DentroDaRua,
|
|
IdxPontoAproximadoRua = OpMapaGPS.ReferencialRuaGPS.IdxPontoAproximadoRua,
|
|
IdxRuaAtual = Mapa.IdxRuaAtual,
|
|
AnguloDif = Sensoriamento.AnguloDif,
|
|
};
|
|
SalvarLog("operacao", logGeral, Fim);
|
|
|
|
GPSModel logGps = new GPSModel()
|
|
{
|
|
Momento = Agora,
|
|
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);
|
|
|
|
DispMvd.Dados.Modulos.ForEach(Modulo =>
|
|
{
|
|
MovSensoriamentoLogModel logMov = new MovSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Modulo_ID = Modulo.Modulo_ID,
|
|
Inicializado = Modulo.MovMotor.Inicializado,
|
|
RPM_SP = Modulo.MovMotor.RPM_SP,
|
|
RPM = Modulo.MovMotor.RPM,
|
|
Corrente = Modulo.MovMotor.Corrente,
|
|
Temperatura = Modulo.MovMotor.Temperatura,
|
|
Tensao = Modulo.MovMotor.Tensao,
|
|
Sentido_SP = Modulo.MovMotor.Sentido_SP,
|
|
Sentido = Modulo.MovMotor.Sentido,
|
|
Velocidade = Modulo.MovMotor.VelocidadeInstantanea,
|
|
CodAlarme = Modulo.MovMotor.CodigoAlarme,
|
|
};
|
|
SalvarLog(T_Code.Mov.ToString(), logMov, false);
|
|
|
|
DirSensoriamentoLogModel logDir = new DirSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Modulo_ID = Modulo.Modulo_ID,
|
|
Inicializado = Modulo.MovMotor.Inicializado,
|
|
Angulo = Modulo.DirMotor.Angulo,
|
|
Angulo_SP = Modulo.DirMotor.Angulo_SP,
|
|
Controlar = Modulo.DirMotor.Controlar,
|
|
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,
|
|
MassaReservatorio = DispAtu.Dados.MassaReservatorio,
|
|
PercentualReservatorio = DispAtu.Dados.PercentualReservatorio,
|
|
VolumeReservatorio = DispAtu.Dados.VolumeReservatorio,
|
|
PressaoLinha_SP = DispAtu.Dados.BombaPressurizadora.PressaoSP,
|
|
PressaoLinha = DispAtu.Dados.PressaoLinha,
|
|
PotenciaBomba = DispAtu.Dados.BombaPressurizadora.Potencia,
|
|
VazaoFluxoMLpS = DispAtu.Dados.VazaoFluxoMLpS,
|
|
VolumeVazaoML = DispAtu.Dados.VolumeVazaoML,
|
|
QuantidadeBicos = DispAtu.Dados.QuantidadeBicos,
|
|
Bicos = 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 = OpMapaGPS.Sensoriamento.AtuacoesPorBico.Count > Bico.Posicao ? OpMapaGPS.Sensoriamento.AtuacoesPorBico[Bico.Posicao] : 0,
|
|
}).ToList()
|
|
};
|
|
SalvarLog(DispAtu.Dispositivo.ToString(), logAtu, false);
|
|
|
|
SenSensoriamentoLogModel logSen = new SenSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
Barramento3v3Corrente = DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB3V" && x.Inicializado)?.Leituras?[0] ?? -1,
|
|
Barramento3v3Tensao = DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB3V" && x.Inicializado)?.Leituras?[1] ?? -1,
|
|
Barramento5vCorrente = DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB5V" && x.Inicializado)?.Leituras?[0] ?? -1,
|
|
Barramento5vTensao = DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB5V" && x.Inicializado)?.Leituras?[1] ?? -1,
|
|
Barramento7v2Corrente = DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB7V2" && x.Inicializado)?.Leituras?[0] ?? -1,
|
|
Barramento7v2Tensao = DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB7V2" && x.Inicializado)?.Leituras?[1] ?? -1,
|
|
Barramento12vCorrente = DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB12V" && x.Inicializado)?.Leituras?[0] ?? -1,
|
|
Barramento12vTensao = DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "AB12V" && x.Inicializado)?.Leituras?[1] ?? -1,
|
|
OrientacaoMagnetica = DispSen.Dados.Sensores.FirstOrDefault(x => x.ID == "SMAG" && x.Inicializado)?.Leituras?[0] ?? -1,
|
|
};
|
|
SalvarLog(DispSen.Dispositivo.ToString(), logSen, false);
|
|
|
|
PzmSensoriamentoLogModel logPzm = new PzmSensoriamentoLogModel()
|
|
{
|
|
Momento = Agora,
|
|
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);
|
|
|
|
|
|
SalvarLogCamera("caminho", DispSen.Dados.ultimoFrameCaminho);
|
|
SalvarLogCamera("soloE", DispSen.Dados.ultimoFrameSoloE);
|
|
SalvarLogCamera("soloD", DispSen.Dados.ultimoFrameSoloD);
|
|
|
|
string ArquivoOp = Variaveis.CaminhoOperacoes + ID + "/data.lgop";
|
|
if (!File.Exists(ArquivoOp))
|
|
{
|
|
var data = new OperacaoDadosModel()
|
|
{
|
|
id = 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(),
|
|
caminho = "caminho",
|
|
soloE = "soloE",
|
|
soloD = "soloD"
|
|
};
|
|
File.WriteAllText(ArquivoOp, JsonConvert.SerializeObject(data));
|
|
}
|
|
|
|
idxLog++;
|
|
|
|
|
|
if (LoRaService.Iniciado && idxLog % 2 == 0)
|
|
{
|
|
LoRaProtocoloTransmissaoModel dados = new LoRaProtocoloTransmissaoModel()
|
|
{
|
|
Momento = Agora,
|
|
EnderecoCarro = Variaveis.ConexaoLoRa.parametros.address,
|
|
Operacao = new LoRaProtocoloTransmissaoOperacaoModel()
|
|
{
|
|
idxRuaAtual = Sensoriamento.IdxRuaAtual,
|
|
statusOperacao = Sensoriamento.StatusOperacao,
|
|
statusCarro = Sensoriamento.StatusCarro,
|
|
TempoOperacao = Convert.ToInt32(Tempo.TotalSeconds),
|
|
PercentualRua = OpMapaGPS.Sensoriamento.ProgressoRua,
|
|
PercentualOperacao = OpMapaGPS.Sensoriamento.ProgressoTrajeto,
|
|
},
|
|
Coordenadas = new LoRaProtocoloTransmissaoCoordenadasModel()
|
|
{
|
|
Latitude = GPSService.UltimaLeitura.Latitude,
|
|
Longitude = GPSService.UltimaLeitura.Longitude,
|
|
},
|
|
Sensores = new LoRaProtocoloTransmissaoSensoresModel()
|
|
{
|
|
DistanciaPercorrida = Math.Round(Sensoriamento.DistanciaPercorrida.Sum(), 2),
|
|
ErvasIdentificadas = OpMapaGPS.Sensoriamento.ErvasIdentificadas,
|
|
OrientacaoCaminho = Math.Round(Sensoriamento.AnguloRua, 2),
|
|
OrientacaoCarro = Math.Round(Sensoriamento.AnguloCarro, 2),
|
|
PercentualBateria = Math.Round(Sensoriamento.PorcentagemBateria, 2),
|
|
PercentualReservatorio = Math.Round(DispAtu.Dados.PercentualReservatorio, 2),
|
|
PressaoLinha = Math.Round(DispAtu.Dados.PressaoLinha, 2),
|
|
Temperatura = Math.Round(DispMvd.Dados.Modulos.Average(x => x.MovMotor.Temperatura), 2),
|
|
Velocidade = Math.Round(DispMvd.Dados.Modulos.Average(x => x.MovMotor.VelocidadeInstantanea), 2),
|
|
}
|
|
};
|
|
|
|
byte[] dadosEnvio = LoRaSerializer.SerializeLoRaProtocoloTransmissaoModel(dados);
|
|
|
|
var t = LoRaSerializer.DeserializeLoRaProtocoloTransmissaoModel(dadosEnvio);
|
|
|
|
LoRaService.MontarMensagemEnvio(dadosEnvio, VariaveisEquipamento.ComunicacaoLoRaBaseConfig.address, LoRaTipoProtocolo.DadosOperacao, true);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void SalvarLog<T>(string Arquivo, T Objeto, bool Fim)
|
|
{
|
|
var Caminho = Variaveis.CaminhoOperacoes + ID;
|
|
if (!Directory.Exists(Caminho))
|
|
{
|
|
Directory.CreateDirectory(Caminho);
|
|
}
|
|
|
|
Caminho += "/" + Arquivo + ".json";
|
|
string jsonLog = JsonConvert.SerializeObject(Objeto, Formatting.None);
|
|
|
|
if (!File.Exists(Caminho))
|
|
{
|
|
File.WriteAllText(Caminho, "[" + jsonLog);
|
|
}
|
|
else
|
|
{
|
|
File.AppendAllText(Caminho, "," + jsonLog + (Fim ? "]" : ""));
|
|
}
|
|
}
|
|
|
|
private void SalvarLogCamera(string Camera, Bitmap frame)
|
|
{
|
|
var Caminho = Variaveis.CaminhoOperacoes + ID + "/" + Camera;
|
|
if (!Directory.Exists(Caminho))
|
|
{
|
|
Directory.CreateDirectory(Caminho);
|
|
}
|
|
|
|
Caminho += "/" + idxLog + ".jpg";
|
|
|
|
// Se o frame for nulo, cria um novo bitmap representando uma tela preta
|
|
if (frame == null)
|
|
{
|
|
frame = new Bitmap(1, 1);
|
|
using (Graphics g = Graphics.FromImage(frame))
|
|
{
|
|
g.Clear(Color.Black);
|
|
}
|
|
}
|
|
|
|
// Define a qualidade da imagem (0 a 100)
|
|
long qualidade = 50L; // Ajuste este valor conforme necessário (0 = menor qualidade, 100 = maior qualidade)
|
|
|
|
// Obtém o codec para JPEG
|
|
ImageCodecInfo jpegCodec = GetEncoderInfo("image/jpeg");
|
|
|
|
// Configura os parâmetros de compressão
|
|
EncoderParameters encoderParams = new EncoderParameters(1);
|
|
encoderParams.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, qualidade);
|
|
|
|
// Salva a imagem com a qualidade ajustada
|
|
frame.Save(Caminho, jpegCodec, encoderParams);
|
|
}
|
|
|
|
private ImageCodecInfo GetEncoderInfo(string mimeType)
|
|
{
|
|
// Obtém todos os codecs de imagem disponíveis
|
|
ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
|
|
// Procura pelo codec que corresponde ao mimeType fornecido
|
|
foreach (ImageCodecInfo codec in codecs)
|
|
{
|
|
if (codec.MimeType == mimeType)
|
|
{
|
|
return codec;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
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(DispSen.Dados.Modulo_ID, x.ProtocoloComando(), true, false));
|
|
}
|
|
}
|
|
|
|
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 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; }
|
|
}
|
|
|
|
|
|
|
|
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 caminho { get; set; }
|
|
public string soloE { get; set; }
|
|
public string soloD { get; set; }
|
|
}
|
|
|
|
public class OperacaoSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public double VelocidadeMedia
|
|
{
|
|
get
|
|
{
|
|
return Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Average(x => x.MovMotor.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], 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 SonarModel SonarFrontal { get; set; }
|
|
public double TempoMovimento { get;set; }
|
|
public StatusOperacao StatusOperacao { get; set; }
|
|
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 class PzmSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public DateTime DataHora { 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 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 { 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 Corrente { get; set; }
|
|
public double Tensao { get; set; }
|
|
public int CodAlarme { get; set; }
|
|
}
|
|
|
|
public class AtuSensoriamentoLogModel
|
|
{
|
|
public DateTime Momento { 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 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; }
|
|
}
|
|
|
|
|
|
}
|