591 lines
22 KiB
C#
591 lines
22 KiB
C#
using AgroBase.Services;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using static AgroBase.Models.Enums;
|
|
|
|
namespace AgroBase.Models.Modules
|
|
{
|
|
public class MovimentacaoUnificadaModel : DispositivoBaseModel
|
|
{
|
|
public bool Conectado
|
|
{
|
|
get
|
|
{
|
|
return Modulos.Any(x => x.Conectado);
|
|
}
|
|
set
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
public static int _TaxaAmostragem { get; set; } = 1000;
|
|
|
|
public double DistanciaPercorridaOperacao { get; set; } = 0;
|
|
public double TempoEmAtividade { get; set; } = 0;
|
|
public double DistanciaPercorridaTotal { get; set; } = 0;
|
|
public double DistanciaPercorridaParcial { get; set; } = 0;
|
|
public double VelocidadeMedia { get; set; } = 0.0;
|
|
public double DiametroRoda { get; set; } = 0.3556;
|
|
public double ReducaoMotorBLDC { get; set; } = 5;
|
|
public double RPM_Max_MotorBLDC { get; set; } = 500;
|
|
|
|
public string IP_Mov { get; set; } = Variaveis.FaixaIPethernet + ".10";
|
|
public string IP_Dir { get; set; } = Variaveis.FaixaIPethernet + ".11";
|
|
|
|
public static int LogsManter { get; set; } = 60;
|
|
public AsyncTaskTimerModel tmrRegistrador;
|
|
public AsyncTaskTimerModel tmrRegistradorMOV;
|
|
public AsyncTaskTimerModel tmrRegistradorDIR;
|
|
|
|
|
|
public List<ModuloMvdModel> Modulos { get; set; } = new List<ModuloMvdModel>();
|
|
|
|
public (bool, List<string>) StatusModulosMOV(Direcao Lado)
|
|
{
|
|
string Prefixo = Lado == Direcao.Esquerda ? "E" : Lado == Direcao.Direita ? "D" : "";
|
|
var Mods = Modulos.Where(Mod => Mod.Modulo_ID.Contains(Prefixo) && Mod.MovMotor.Comandar).ToList();
|
|
var ModsComFalha = Mods
|
|
.Where(Mod =>
|
|
!Mod.MovMotor.Inicializado ||
|
|
Mod.MovMotor.CodigoAlarme != 0 ||
|
|
Mod.MovMotor.AlarmeSensores ||
|
|
(Mod.MovMotor.AlarmeComando)
|
|
)
|
|
.ToList();
|
|
|
|
int total = Mods.Count;
|
|
int falhas = ModsComFalha.Count;
|
|
bool _operante = falhas < total;
|
|
|
|
List<string> ModsInoperantes = ModsComFalha.Select(x => x.Modulo_ID).ToList();
|
|
|
|
return (_operante, ModsInoperantes);
|
|
}
|
|
|
|
public (bool, List<string>) StatusModulosDIR(TipoMovimentoDirecional TipoMovimento)
|
|
{
|
|
var Mods = Modulos.Where(Mod => Mod.DirMotor.Comandar).ToList();
|
|
var ModsComFalha = Mods
|
|
.Where(Mod =>
|
|
!Mod.DirMotor.Inicializado && (
|
|
Mod.DirMotor.ConfigSentidos[TipoMovimento].Esquerda != Sentido.Parado &&
|
|
Mod.DirMotor.ConfigSentidos[TipoMovimento].Direita != Sentido.Parado
|
|
)
|
|
);
|
|
|
|
bool _operante = !ModsComFalha.Any();
|
|
List<string> ModsInoperantes = ModsComFalha.Select(x => x.Modulo_ID).ToList();
|
|
|
|
return (_operante, ModsInoperantes);
|
|
}
|
|
|
|
|
|
public static MovimentacaoUnificadaModel CarregarParametrosIniciais()
|
|
{
|
|
return new MovimentacaoUnificadaModel()
|
|
{
|
|
Modulos = new List<ModuloMvdModel>()
|
|
{
|
|
new ModuloMvdModel()
|
|
{
|
|
Modulo_ID = "ET",
|
|
MovMotor = MovimentacaoModel.CarregarParametrosIniciais("ET", "0x01"),
|
|
DirMotor = DirecionalModel.CarregarParametrosIniciais("ET", "0x01"),
|
|
},
|
|
new ModuloMvdModel()
|
|
{
|
|
Modulo_ID = "EF",
|
|
MovMotor = MovimentacaoModel.CarregarParametrosIniciais("EF", "0x03"),
|
|
DirMotor = DirecionalModel.CarregarParametrosIniciais("EF", "0x03")
|
|
},
|
|
new ModuloMvdModel()
|
|
{
|
|
Modulo_ID = "DT",
|
|
MovMotor = MovimentacaoModel.CarregarParametrosIniciais("DT", "0x02"),
|
|
DirMotor = DirecionalModel.CarregarParametrosIniciais("DT", "0x02")
|
|
},
|
|
new ModuloMvdModel()
|
|
{
|
|
Modulo_ID = "DF",
|
|
MovMotor = MovimentacaoModel.CarregarParametrosIniciais("DF", "0x04"),
|
|
DirMotor = DirecionalModel.CarregarParametrosIniciais("DF", "0x04")
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
public void LimparDados<T>(T _dados)
|
|
{
|
|
var Dados = _dados as MovimentacaoUnificadaModel;
|
|
Dados.Modulos.ForEach(x =>
|
|
{
|
|
x.MovMotor.Leitura = null;
|
|
x.DirMotor.Leitura = null;
|
|
});
|
|
|
|
ReiniciarLeituras(Dados);
|
|
}
|
|
|
|
public void ReiniciarLeituras(MovimentacaoUnificadaModel Dados)
|
|
{
|
|
Dados.DistanciaPercorridaParcial = 0;
|
|
Dados.DistanciaPercorridaTotal = 0;
|
|
Dados.DistanciaPercorridaOperacao = 0;
|
|
Dados.VelocidadeMedia = 0;
|
|
Dados.TempoEmAtividade = 0;
|
|
Dados.Modulos.ForEach(x =>
|
|
{
|
|
x.MovMotor.AlarmeSensores = false;
|
|
x.MovMotor.ConfigFreio.Leitura = false;
|
|
x.MovMotor.LogGrafico = new List<MvdMotorMOVSensorimanetoGrafico>();
|
|
x.MovMotor.Temperatura = 0;
|
|
x.MovMotor.RPM_SP = 0;
|
|
x.MovMotor.RPM_SP_Controle = 0;
|
|
|
|
x.DirMotor.Angulo_SP = 0;
|
|
x.DirMotor.Sentido_SP = Sentido.Parado;
|
|
});
|
|
}
|
|
|
|
public Dictionary<string, List<string>> ProtocoloConfiguracao(bool Conectar)
|
|
{
|
|
var Config = Modulos.Where(x => x.MovMotor.Comandar || x.DirMotor.Comandar).ToDictionary(x => x.Modulo_ID, x => x.ProtocoloConfiguracao(Conectar).ToList());
|
|
return Config;
|
|
}
|
|
|
|
public string ProtocoloVerificacao(bool Completo)
|
|
{
|
|
return "";
|
|
}
|
|
|
|
public void RecebeProtocoloModulo(string Protocolo)
|
|
{
|
|
|
|
}
|
|
|
|
public void RegistrarLogMov(ModuloMvdModel Modulo)
|
|
{
|
|
Modulo.MovMotor.LogGrafico.Add(new MvdMotorMOVSensorimanetoGrafico()
|
|
{
|
|
Momento = DateTime.Now,
|
|
Modulo_ID = Modulo.Modulo_ID,
|
|
RPM_SP = Modulo.MovMotor.RPM_SP_Leitura,
|
|
RPM_Motor = Modulo.MovMotor.RPM_Motor,
|
|
RPM_Roda = Modulo.MovMotor.RPM_Roda,
|
|
Corrente = Modulo.MovMotor.Corrente_Motor,
|
|
Sentido = Modulo.MovMotor.Sentido,
|
|
Temperatura = Modulo.MovMotor.Temperatura,
|
|
TemperaturaDriver = Modulo.MovMotor.TemperaturaDriver,
|
|
Tensao = Modulo.MovMotor.Tensao,
|
|
Velocidade = Modulo.MovMotor.VelocidadeInstantanea,
|
|
Potencia = Modulo.MovMotor.Potencia,
|
|
CicloTrabalho = Modulo.MovMotor.CicloTrabalho
|
|
});
|
|
|
|
if (Modulo.MovMotor.LogGrafico.Count > 60)
|
|
{
|
|
Modulo.MovMotor.LogGrafico.RemoveAt(0);
|
|
}
|
|
}
|
|
|
|
public void DefineStatusConexao(string Mod_ID, bool conecatdo)
|
|
{
|
|
var Modulo = Modulos.FirstOrDefault(x => x.Modulo_ID == Mod_ID);
|
|
if (Modulo != null)
|
|
{
|
|
//Modulo.Conectado = conecatdo;
|
|
}
|
|
}
|
|
|
|
public string GetTaxaAmostragem()
|
|
{
|
|
return _TaxaAmostragem.ToString("00000");
|
|
}
|
|
|
|
public void SetTaxaAmostragem(int TaxaAmostragem)
|
|
{
|
|
_TaxaAmostragem = TaxaAmostragem;
|
|
}
|
|
|
|
public bool GetStatusConexao()
|
|
{
|
|
return Conectado;
|
|
}
|
|
|
|
public string GetIP()
|
|
{
|
|
return IP_Mov;
|
|
}
|
|
|
|
public void IniciarRegistrador()
|
|
{
|
|
if (!(tmrRegistrador?.IsRunning ?? false))
|
|
{
|
|
LimparDados(this);
|
|
|
|
PararRegistrador();
|
|
|
|
tmrRegistrador = new AsyncTaskTimerModel("tmrRegistrador_" + T_Code.Mvd.ToString(), tmrRegistrador_Tick, _TaxaAmostragem);
|
|
tmrRegistrador.Start();
|
|
|
|
tmrRegistradorMOV = new AsyncTaskTimerModel("tmrRegistrador_" + T_Code.Mov.ToString(), tmrRegistradorMOV_Tick, OIDService.TaxaAmostragem);
|
|
tmrRegistradorMOV.Start();
|
|
|
|
tmrRegistradorDIR = new AsyncTaskTimerModel("tmrRegistrador_" + T_Code.Dir.ToString(), tmrRegistradorDIR_Tick, MKS057DCanService.TaxaAmostragem);
|
|
tmrRegistradorDIR.Start();
|
|
}
|
|
}
|
|
|
|
public void PararRegistrador()
|
|
{
|
|
tmrRegistrador?.Dispose();
|
|
tmrRegistradorMOV?.Dispose();
|
|
tmrRegistradorDIR?.Dispose();
|
|
}
|
|
|
|
public async Task tmrRegistrador_Tick()
|
|
{
|
|
tmrRegistrador.SetInterval(_TaxaAmostragem);
|
|
|
|
var UltimaDirecao = Variaveis.OperacaoEmAndamento.Controle.TiposControle.FirstOrDefault(x => x.Tipo == T_Code.Mov)?.UltimaDirecao ?? Direcao.Parado;
|
|
|
|
if (UltimaDirecao != Direcao.Parado)
|
|
{
|
|
VelocidadeMedia = FuncoesMatematicas.ConverteKmhParaMs(Modulos.Where(x => x.Conectado && x.MovMotor.ComandoLigado).DefaultIfEmpty().Average(x => x?.MovMotor?.VelocidadeInstantanea ?? 0));
|
|
double tempo = _TaxaAmostragem / 1000.0;
|
|
double distancia = tempo * VelocidadeMedia;
|
|
DistanciaPercorridaTotal += distancia;
|
|
DistanciaPercorridaParcial += ((UltimaDirecao == Direcao.Frente ? 1 : UltimaDirecao == Direcao.Tras ? -1 : 0) * distancia);
|
|
DistanciaPercorridaOperacao += distancia;
|
|
TempoEmAtividade += tempo;
|
|
}
|
|
}
|
|
|
|
private async Task tmrRegistradorMOV_Tick()
|
|
{
|
|
if (Variaveis.Fechando)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!OIDService.Iniciado && SerialService.DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Mov))
|
|
{
|
|
await OIDService.InicializarEthernetService();
|
|
|
|
foreach (var Leitura in OIDService.DadosLeitura.Where(x => x.UltimoComandoRecebido.AddSeconds(10) < DateTime.Now))
|
|
{
|
|
OIDService.AdicionarComandoNaFila(new OIDComandoModel()
|
|
{
|
|
Endereco = Leitura.Endereco,
|
|
Parametro = OIDService.Parametros.First(x => x.Chave == "CodErro"),
|
|
Get = true,
|
|
AguardaResposta = true
|
|
});
|
|
}
|
|
|
|
tmrRegistradorMOV.SetInterval(3000);
|
|
return;
|
|
}
|
|
|
|
var Controle = Variaveis.OperacaoEmAndamento.Controle.TiposControle?.FirstOrDefault(x => x.Tipo == T_Code.Mov);
|
|
|
|
foreach (var Modulo in Modulos.Where(x => x.MovMotor.Inicializado).OrderBy(x => x.MovMotor.EnderecoByte))
|
|
{
|
|
foreach (var Parametro in OIDService.Parametros.Where(x => x.LeituraLoop))
|
|
{
|
|
var Comando = new OIDComandoModel()
|
|
{
|
|
Endereco = Modulo.MovMotor.EnderecoByte,
|
|
AguardaResposta = true,
|
|
Parametro = Parametro,
|
|
Get = true,
|
|
TimeoutResposta = 200
|
|
};
|
|
OIDService.AdicionarComandoNaFila(Comando);
|
|
}
|
|
|
|
if (Controle != null)
|
|
{
|
|
Modulo.MovMotor.EnviarComandoControle(Controle.UltimaDirecao);
|
|
}
|
|
|
|
Modulo.MovMotor.ConfigFreio.Leitura = Modulo.MovMotor.Leitura?.Freado ?? false;
|
|
|
|
Variaveis.OperacaoEmAndamento.DispMvd.Dados.RegistrarLogMov(Modulo);
|
|
}
|
|
|
|
tmrRegistradorMOV.SetInterval(OIDService.TaxaAmostragem);
|
|
}
|
|
|
|
private async Task tmrRegistradorDIR_Tick()
|
|
{
|
|
if (Variaveis.Fechando)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!MKS057DCanService.Iniciado && SerialService.DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Mks))
|
|
{
|
|
//await MKS057DService.InicializarEthernetService();
|
|
|
|
foreach (var Leitura in MKS057DCanService.DadosLeitura.Where(x => x.UltimoComandoRecebido.AddSeconds(10) < DateTime.Now))
|
|
{
|
|
//MKS057DService.AdicionarComandoNaFila(MKS057DService.MontarComandoRequisicaoPulsos(Leitura.Endereco));
|
|
MKS057DCanService.RequisitarDado(Leitura.Endereco, MKS057DCanService.MksHandler.MksFuncCode.PulsosRecebidos);
|
|
}
|
|
|
|
tmrRegistradorDIR.SetInterval(3000);
|
|
return;
|
|
}
|
|
|
|
foreach (var Modulo in Modulos.Where(x => x.DirMotor.Inicializado))
|
|
{
|
|
byte modAddr = Modulo.DirMotor.EnderecoByte;
|
|
if (!MKS057DCanService.Referenciando || (MKS057DCanService.Referenciando && MKS057DCanService.AddrRef == modAddr))
|
|
{
|
|
//MKS057DService.AdicionarComandoNaFila(MKS057DService.MontarComandoRequisicaoPulsos(modAddr));
|
|
MKS057DCanService.RequisitarDado(modAddr, MKS057DCanService.MksHandler.MksFuncCode.PulsosRecebidos);
|
|
//MKS057DService.AdicionarComandoNaFila(MKS057DService.MontarComandoRequisicaoIO(modAddr));
|
|
MKS057DCanService.RequisitarDado(modAddr, MKS057DCanService.MksHandler.MksFuncCode.IO);
|
|
|
|
// Verifica se o angulo de set point do motor em questao e diferente do angulo atual, e se for, reenvia o comando para garantir que o motor esteja coerente com o set point
|
|
if (!MKS057DCanService.Referenciando && (Modulo.DirMotor.UltimoComandoEnviado.AddMilliseconds(MKS057DCanService.TaxaAmostragem) < DateTime.Now) && !Modulo.DirMotor.AtingiuAnguloSP)
|
|
{
|
|
var Controle = Variaveis.OperacaoEmAndamento.Controle.TiposControle?.FirstOrDefault(x => x.Tipo == T_Code.Dir);
|
|
if (Controle != null)
|
|
{
|
|
Modulo.DirMotor.EnviarComandoControle(Controle.UltimaDirecao);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
MKS057DCanService.TaxaAmostragem = MKS057DCanService.Referenciando ? 200 : 500;
|
|
tmrRegistradorDIR.SetInterval(MKS057DCanService.TaxaAmostragem);
|
|
}
|
|
|
|
|
|
|
|
public async Task ExecutarMovimentoDirecionalCombinado(Direcao DirecaoAtual)
|
|
{
|
|
if (DirecaoAtual == Direcao.Parado)
|
|
{
|
|
foreach (var Modulo in Modulos)
|
|
{
|
|
Modulo.MovMotor.EnviarComandoControle(Direcao.Parado);
|
|
}
|
|
|
|
await Task.Delay(1000);
|
|
}
|
|
|
|
switch (Variaveis.OperacaoEmAndamento.Controle.TipoMovimento)
|
|
{
|
|
case TipoMovimentoDirecional.RotacionarNoEixo:
|
|
case TipoMovimentoDirecional.MovimentoLateral:
|
|
|
|
foreach (var Modulo in Modulos.Where(x => x.DirMotor.Inicializado && !x.DirMotor.PosicaoTipoMovimentoConcluido(DirecaoAtual)))
|
|
{
|
|
Modulo.DirMotor.EnviarComandoControle(DirecaoAtual);
|
|
}
|
|
|
|
DateTime Agora = DateTime.Now;
|
|
bool Sucesso = Modulos.All(x => x.DirMotor.PosicaoTipoMovimentoConcluido(DirecaoAtual));
|
|
while (Agora.AddMilliseconds(5000) > DateTime.Now && !Sucesso)
|
|
{
|
|
await Task.Delay(100);
|
|
Sucesso = Modulos.All(x => x.DirMotor.PosicaoTipoMovimentoConcluido(DirecaoAtual));
|
|
}
|
|
|
|
if (Sucesso && DirecaoAtual != Direcao.Parado)
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Controle.PercentualVelocidadeSP = 20;
|
|
foreach (var Modulo in Modulos)
|
|
{
|
|
Modulo.MovMotor.EnviarComandoControle(
|
|
DirecaoAtual == Direcao.Direita ? Direcao.Frente :
|
|
DirecaoAtual == Direcao.Esquerda ? Direcao.Tras :
|
|
Direcao.Parado
|
|
);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
public async Task RealizarReferenciamentoDirecional()
|
|
{
|
|
if (!MKS057DCanService.Referenciando)
|
|
{
|
|
TipoMovimentoDirecional tipoControle = Variaveis.OperacaoEmAndamento.Controle.TipoMovimento;
|
|
|
|
Variaveis.OperacaoEmAndamento.Controle.TipoMovimento = TipoMovimentoDirecional.Diagnostico;
|
|
var ModsRef = Modulos.Where(x => x.DirMotor.Comandar && x.DirMotor.Inicializado && !x.DirMotor.IN1_Atuado).ToList();
|
|
foreach (var Modulo in ModsRef)
|
|
{
|
|
await Modulo.DirMotor.ReferenciaMotor();
|
|
}
|
|
Variaveis.OperacaoEmAndamento.Controle.TipoMovimento = tipoControle;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
public class ModuloMvdModel
|
|
{
|
|
public string Modulo_ID { get; set; }
|
|
public bool Disponivel { get; set; }
|
|
public bool RequisitarDados { get; set; } = false;
|
|
|
|
public bool Conectado
|
|
{
|
|
get
|
|
{
|
|
return MovMotor.Inicializado || DirMotor.Inicializado;
|
|
}
|
|
}
|
|
|
|
public MovimentacaoModel MovMotor { get; set; }
|
|
public DirecionalModel DirMotor { get; set; }
|
|
|
|
public static PinoutDataModel Pinout { get; set; }
|
|
public static List<FuncoesPinout> Funcoes { get; set; } = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.TX,
|
|
FuncoesPinout.RX,
|
|
FuncoesPinout.ModbusDI,
|
|
FuncoesPinout.ModbusRO,
|
|
FuncoesPinout.ModbusDE_RE
|
|
};
|
|
|
|
|
|
public List<string> ProtocoloConfiguracao(bool Conectar)
|
|
{
|
|
List<string> Config = new List<string>();
|
|
|
|
var _pinout = new PinoutDataModel()
|
|
{
|
|
ExpansorGPIO = Pinout.ExpansorGPIO,
|
|
EnderecoGPIO = Pinout.EnderecoGPIO,
|
|
Pinos = Pinout.Pinos.ToList(),
|
|
};
|
|
_pinout.Pinos = _pinout.Pinos.Where(x => x.ComponenteID == T_Code.Mvd.ToString()).ToList();
|
|
string ProtocoloMOD =
|
|
((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
|
|
Modulo_ID + SerialService.SplitParams +
|
|
(Conectar ? "1" : "0") + SerialService.SplitParams +
|
|
MovimentacaoUnificadaModel._TaxaAmostragem.ToString() + SerialService.SplitParams +
|
|
(RequisitarDados ? "1" : "0") + SerialService.SplitParams +
|
|
PinoutModel.PinoProtocolo(_pinout, Funcoes, SerialService.SplitParams);
|
|
|
|
if (Conectar)
|
|
{
|
|
Config.Add(ProtocoloMOD);
|
|
}
|
|
|
|
if (MovMotor.Comandar)
|
|
{
|
|
Config.Add(MovMotor.ProtocoloConfiguracao(Conectar));
|
|
}
|
|
/*if (DirMotor.Comandar)
|
|
{
|
|
Config.Add(DirMotor.ProtocoloConfiguracao(Conectar));
|
|
}*/
|
|
|
|
if (!Conectar)
|
|
{
|
|
Config.Add(ProtocoloMOD);
|
|
}
|
|
|
|
Config.Add(ProtocoloVerificacao(false));
|
|
|
|
return Config;
|
|
}
|
|
|
|
public string ProtocoloVerificacao(bool Completo)
|
|
{
|
|
if (Completo)
|
|
{
|
|
string ProtocoloCheck =
|
|
SerialService.BeginLine +
|
|
0 + SerialService.SplitMessage +
|
|
Modulo_ID + SerialService.SplitMessage +
|
|
((int)F_Code.Chk).ToString() + SerialService.SplitMessage +
|
|
"check" +
|
|
SerialService.EndLine;
|
|
|
|
return ProtocoloCheck;
|
|
}
|
|
else
|
|
{
|
|
string ProtocoloCheck =
|
|
((int)F_Code.Chk).ToString() + SerialService.SplitMessage +
|
|
"check";
|
|
|
|
return ProtocoloCheck;
|
|
}
|
|
}
|
|
|
|
public void AtualizarSensoresMotor()
|
|
{
|
|
var _Sensores = Variaveis.OperacaoEmAndamento.DispSen.Dados.DadosLeitura;
|
|
|
|
var sensorTmp = _Sensores.SensoresTemperatura.FirstOrDefault(x => x.ID.Contains(Modulo_ID));
|
|
if (sensorTmp != null)
|
|
{
|
|
MovMotor.Temperatura = sensorTmp.Temperatura;
|
|
|
|
AlarmeModel _Alarme = new AlarmeModel()
|
|
{
|
|
Tipo = S_Code.sTMP,
|
|
Valor = sensorTmp.Temperatura,
|
|
Maximo = sensorTmp.Temperatura > sensorTmp.LimiteMaximo,
|
|
Minimo = sensorTmp.Temperatura < sensorTmp.LimiteMinimo,
|
|
ParaMaximo = false,
|
|
ParaMinimo = false
|
|
};
|
|
VerificarAlarme(_Alarme);
|
|
}
|
|
var sensorCor = _Sensores.SensoresCorrente.FirstOrDefault(x => x.ID.Contains(Modulo_ID));
|
|
if (sensorCor != null)
|
|
{
|
|
AlarmeModel _Alarme = new AlarmeModel()
|
|
{
|
|
Tipo = S_Code.sCOR,
|
|
Valor = (double)sensorCor.Current,
|
|
Maximo = (double)sensorCor.Current > sensorCor.LimiteMaximo,
|
|
Minimo = (double)sensorCor.Current < sensorCor.LimiteMinimo,
|
|
ParaMaximo = false,
|
|
ParaMinimo = false
|
|
};
|
|
VerificarAlarme(_Alarme);
|
|
}
|
|
}
|
|
|
|
private void VerificarAlarme(AlarmeModel _Alarme)
|
|
{
|
|
var Alm = MovMotor.Alarmes.FirstOrDefault(x => x.Tipo == _Alarme.Tipo);
|
|
if (Alm == null)
|
|
{
|
|
Alm = _Alarme;
|
|
MovMotor.Alarmes.Add(Alm);
|
|
}
|
|
|
|
Alm.Valor = _Alarme.Valor;
|
|
Alm.Maximo = _Alarme.Maximo;
|
|
Alm.Minimo = _Alarme.Minimo;
|
|
|
|
MovMotor.AlarmeSensores = MovMotor.Alarmes.Any(x => (x.Maximo && x.ParaMaximo) || (x.Minimo && x.ParaMinimo));
|
|
}
|
|
|
|
}
|
|
|
|
}
|