1232 lines
51 KiB
C#
1232 lines
51 KiB
C#
using AgroBase.Forms;
|
|
using AgroBase.Services;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using static AgroBase.Models.Enums;
|
|
|
|
namespace AgroBase.Models.Modules
|
|
{
|
|
public class SensoriamentoModel : DispositivoBaseModel
|
|
{
|
|
public string Modulo_ID { get; set; } = T_Code.Sen.ToString();
|
|
public bool RequisitarDados { get; set; } = false;
|
|
private bool _MensagemConexaoRecebida { get; set; } = false;
|
|
public bool MensagemConexaoRecebida(bool Reset = false)
|
|
{
|
|
if (Reset)
|
|
{
|
|
_MensagemConexaoRecebida = false;
|
|
}
|
|
return _MensagemConexaoRecebida;
|
|
}
|
|
|
|
public static int _TaxaAmostragem { get; set; } = 500;
|
|
public bool Conectado { get; set; } = false;
|
|
public static int LogsManter { get; set; } = 60;
|
|
public static PinoutDataModel Pinout { get; set; }
|
|
public static bool ExpansorGPIO { get; set; } = false;
|
|
public static List<FuncoesPinout> Funcoes { get; set; } = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.SDA,
|
|
FuncoesPinout.SCL,
|
|
};
|
|
public List<SensorModel> Sensores { get; set; }
|
|
public List<SensorSinaleiroModel> Sinaleiros { get; set; }
|
|
public List<SensorReleModel> Reles { get; set; }
|
|
public List<SensorServoModel> Servos { get; set; }
|
|
public string CameraID_Caminho { get; set; } = "";
|
|
public List<string> CameraID_Solo { get; set; } = new List<string>();
|
|
public UltrasonicA05Configuracoes ConfiguracaoSensorUltrassom { get; set; }
|
|
public double BateriaCargaConsumida { get; set; }
|
|
public LoRaParametrosModel LoRaParametrosBase { get; set; } = new LoRaParametrosModel()
|
|
{
|
|
address = 0x01,
|
|
channel = 0x17,
|
|
tranMode = LoRaService.CodigosTipoTransmissao["Fixed"],
|
|
baudRate = LoRaService.CodigosBaudRates[9600],
|
|
airRate = LoRaService.CodigosAirRates[2.4],
|
|
packetSize = LoRaService.CodigosPacketSizes[200],
|
|
worCycle = LoRaService.CodigosWorCycles[4000],
|
|
power = LoRaService.CodigosPowers[22],
|
|
};
|
|
|
|
|
|
public static SensoriamentoModel CarregarParametrosIniciais()
|
|
{
|
|
return new SensoriamentoModel()
|
|
{
|
|
CameraID_Caminho = "",
|
|
CameraID_Solo = new List<string>()
|
|
{
|
|
"",
|
|
""
|
|
},
|
|
Sinaleiros = new List<SensorSinaleiroModel>()
|
|
{
|
|
new SensorSinaleiroModel()
|
|
{
|
|
ID = "LEDMN",
|
|
Descricao = "Sinaleiro indicação de modo Manual ativo",
|
|
Componente = S_Code.sLED,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.Sinaleiro,
|
|
},
|
|
Comportamento = VariaveisEquipamento.ComportamentoPorStatus(StatusOperacao.NaoIniciado)
|
|
},
|
|
new SensorSinaleiroModel()
|
|
{
|
|
ID = "LEDAT",
|
|
Descricao = "Sinaleiro indicação de modo Automático ativo",
|
|
Componente = S_Code.sLED,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.Sinaleiro,
|
|
},
|
|
Comportamento = VariaveisEquipamento.ComportamentoPorStatus(StatusOperacao.NaoIniciado)
|
|
},
|
|
new SensorSinaleiroModel()
|
|
{
|
|
ID = "LEDOP",
|
|
Descricao = "Sinaleiro indicação do status da operação ativa",
|
|
Componente = S_Code.sLED,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.Sinaleiro,
|
|
},
|
|
Comportamento = VariaveisEquipamento.ComportamentoPorStatus(StatusOperacao.NaoIniciado)
|
|
},
|
|
},
|
|
Sensores = new List<SensorModel>()
|
|
{
|
|
new SensorModel()
|
|
{
|
|
ID = "TMVET",
|
|
Descricao = "Temperatura Motor Esquerdo Trás",
|
|
Prioridade = 0,
|
|
Componente = S_Code.sTMP,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.TMP,
|
|
},
|
|
DelayAmostragem = 200,
|
|
UnidadeMedida = "ºC",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "V offset", "-1.038" },
|
|
},
|
|
},
|
|
new SensorModel()
|
|
{
|
|
ID = "TMVEF",
|
|
Descricao = "Temperatura Motor Esquerdo Frente",
|
|
Prioridade = 0,
|
|
Componente = S_Code.sTMP,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.TMP,
|
|
},
|
|
DelayAmostragem = 200,
|
|
UnidadeMedida = "ºC",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "V offset", "-1.038" },
|
|
},
|
|
},
|
|
new SensorModel()
|
|
{
|
|
ID = "TMVDT",
|
|
Descricao = "Temperatura Motor Direito Trás",
|
|
Prioridade = 0,
|
|
Componente = S_Code.sTMP,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.TMP,
|
|
},
|
|
DelayAmostragem = 200,
|
|
UnidadeMedida = "ºC",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "V offset", "-1.038" },
|
|
},
|
|
},
|
|
new SensorModel()
|
|
{
|
|
ID = "TMVDF",
|
|
Descricao = "Temperatura Motor Direito Frente",
|
|
Prioridade = 0,
|
|
Componente = S_Code.sTMP,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.TMP,
|
|
},
|
|
DelayAmostragem = 200,
|
|
UnidadeMedida = "ºC",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "V offset", "-1.038" },
|
|
},
|
|
},
|
|
/*new SensorModel()
|
|
{
|
|
ID = "AB3V",
|
|
Prioridade = 10,
|
|
Descricao = "Corrente no Barramento 3V",
|
|
Componente = S_Code.sCOR,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.I2C,
|
|
},
|
|
DelayAmostragem = 500,
|
|
UnidadeMedida = "A",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "Endereço I2C", "0x44" },
|
|
new string[] { "CI", "219" }
|
|
},
|
|
},*/
|
|
new SensorModel()
|
|
{
|
|
ID = "AB5V",
|
|
Prioridade = 10,
|
|
Descricao = "Corrente no Barramento 5V",
|
|
Componente = S_Code.sCOR,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.I2C,
|
|
},
|
|
DelayAmostragem = 500,
|
|
UnidadeMedida = "A",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "Endereço I2C", "0x41" },
|
|
new string[] { "Corrente Max", "3.2" }
|
|
},
|
|
},
|
|
/*new SensorModel()
|
|
{
|
|
ID = "AB7V2",
|
|
Prioridade = 10,
|
|
Descricao = "Corrente no Barramento 7,2V",
|
|
Componente = S_Code.sCOR,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.I2C,
|
|
},
|
|
DelayAmostragem = 500,
|
|
UnidadeMedida = "A",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "Endereço I2C", "0x40" },
|
|
new string[] { "CI", "219" }
|
|
},
|
|
},*/
|
|
new SensorModel()
|
|
{
|
|
ID = "AB12V",
|
|
Prioridade = 10,
|
|
Descricao = "Corrente no Barramento 12V",
|
|
Componente = S_Code.sCOR,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.I2C,
|
|
},
|
|
DelayAmostragem = 500,
|
|
UnidadeMedida = "A",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "Endereço I2C", "0x40" },
|
|
new string[] { "Corrente Max", "100" }
|
|
},
|
|
},
|
|
new SensorModel()
|
|
{
|
|
ID = "TBAT",
|
|
Descricao = "Temperatura da bateria",
|
|
Prioridade = 5,
|
|
Componente = S_Code.sTMP,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.TMP,
|
|
},
|
|
DelayAmostragem = 500,
|
|
UnidadeMedida = "ºC",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "V offset", "0.0000" },
|
|
},
|
|
},
|
|
/*new SensorModel()
|
|
{
|
|
ID = "SUESQ",
|
|
Descricao = "Sensor Ultrassom Esquerdo",
|
|
Prioridade = 2,
|
|
Componente = S_Code.sULT,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.Echo,
|
|
FuncoesPinout.Trigger,
|
|
},
|
|
DelayAmostragem = 1000,
|
|
UnidadeMedida = "cm",
|
|
Parametros = new List<string[]>(),
|
|
},
|
|
new SensorModel()
|
|
{
|
|
ID = "SUDIR",
|
|
Descricao = "Sensor Ultrassom Direito",
|
|
Prioridade = 2,
|
|
Componente = S_Code.sULT,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.Echo,
|
|
FuncoesPinout.Trigger,
|
|
},
|
|
DelayAmostragem = 1000,
|
|
UnidadeMedida = "cm",
|
|
Parametros = new List<string[]>(),
|
|
},
|
|
new SensorModel()
|
|
{
|
|
ID = "SMAG",
|
|
Descricao = "Sensor Magnetômetro",
|
|
Prioridade = 15,
|
|
Componente = S_Code.sMAG,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.I2C,
|
|
},
|
|
DelayAmostragem = 500,
|
|
UnidadeMedida = "º",
|
|
Parametros = new List<string[]>(),
|
|
},
|
|
new SensorModel()
|
|
{
|
|
ID = "SNR_F",
|
|
Descricao = "Sensor Sonar Frontal",
|
|
Prioridade = 20,
|
|
Componente = S_Code.sSNR,
|
|
Aferir = true,
|
|
Inicializado = false,
|
|
Testando = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.Echo,
|
|
FuncoesPinout.Trigger,
|
|
FuncoesPinout.ServoX,
|
|
FuncoesPinout.ServoY,
|
|
},
|
|
DelayAmostragem = 1000,
|
|
UnidadeMedida = "cm/º",
|
|
Parametros = new List<string[]>()
|
|
{
|
|
new string[] { "Angulo X Acrescentar", "5" },
|
|
new string[] { "Angulo Y Acrescentar", "30" },
|
|
},
|
|
LimiteMinimo = 40,
|
|
LimiteMaximo = 9999,
|
|
},*/
|
|
|
|
},
|
|
Reles = new List<SensorReleModel>()
|
|
{
|
|
new SensorReleModel()
|
|
{
|
|
ID = "RLLRA",
|
|
Descricao = "Relé modo operação LoRa",
|
|
Componente = S_Code.sRLE,
|
|
Controlar = true,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.Rele,
|
|
},
|
|
StatusControle = Estado.Desligado,
|
|
},
|
|
},
|
|
Servos = new List<SensorServoModel>()
|
|
{
|
|
new SensorServoModel()
|
|
{
|
|
ID = "FRO_ET",
|
|
Descricao = "Freio Motor ET",
|
|
Componente = S_Code.sFRO,
|
|
Controlar = true,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.ServoFreio,
|
|
},
|
|
_AnguloControle = 0,
|
|
},
|
|
new SensorServoModel()
|
|
{
|
|
ID = "FRO_EF",
|
|
Descricao = "Freio Motor EF",
|
|
Componente = S_Code.sFRO,
|
|
Controlar = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.ServoFreio,
|
|
},
|
|
_AnguloControle = 0,
|
|
},
|
|
new SensorServoModel()
|
|
{
|
|
ID = "FRO_DT",
|
|
Descricao = "Freio Motor DT",
|
|
Componente = S_Code.sFRO,
|
|
Controlar = true,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.ServoFreio,
|
|
},
|
|
_AnguloControle = 0,
|
|
},
|
|
new SensorServoModel()
|
|
{
|
|
ID = "FRO_DF",
|
|
Descricao = "Freio Motor DF",
|
|
Componente = S_Code.sFRO,
|
|
Controlar = false,
|
|
Funcoes = new List<FuncoesPinout>()
|
|
{
|
|
FuncoesPinout.ServoFreio,
|
|
},
|
|
_AnguloControle = 0,
|
|
},
|
|
}
|
|
};
|
|
}
|
|
|
|
public static void LimparDados(SensoriamentoModel Dados)
|
|
{
|
|
Dados.Conectado = false;
|
|
Dados.Reles.ForEach(x =>
|
|
{
|
|
x.Inicializado = false;
|
|
});
|
|
Dados.Sinaleiros.ForEach(x =>
|
|
{
|
|
x.Inicializado = false;
|
|
});
|
|
Dados.Sensores.ForEach(x =>
|
|
{
|
|
x.Inicializado = false;
|
|
});
|
|
Dados.Servos.ForEach(x =>
|
|
{
|
|
x.Inicializado = false;
|
|
});
|
|
|
|
ReiniciarLeituras(Dados);
|
|
}
|
|
|
|
public static void ReiniciarLeituras(SensoriamentoModel Dados)
|
|
{
|
|
Dados.BateriaCargaConsumida = 0;
|
|
Dados.Reles.ForEach(x =>
|
|
{
|
|
x.StatusLeitura = Estado.Desligado;
|
|
x.StatusControle = Estado.Desligado;
|
|
});
|
|
Dados.Sinaleiros.ForEach(x =>
|
|
{
|
|
x.StatusLED = StatusLED.Apagado;
|
|
});
|
|
Dados.Sensores.ForEach(x =>
|
|
{
|
|
x.Leituras = new List<double>();
|
|
x.ValorMinimo = 0;
|
|
x.ValorMaximo = 0;
|
|
});
|
|
Dados.Servos.ForEach(x =>
|
|
{
|
|
x._AnguloLeitura = 0;
|
|
x._AnguloControle = 0;
|
|
});
|
|
}
|
|
|
|
public Dictionary<string, List<string>> ProtocoloConfiguracao(bool Conectar)
|
|
{
|
|
// Inicializar o dicionário
|
|
var configDictionary = new Dictionary<string, List<string>>() { { Modulo_ID, new List<string>() } };
|
|
|
|
// Adicionar configurações dos Sensores que devem ser aferidos
|
|
var sensoresConfig = Sensores
|
|
.Where(x => x.Aferir)
|
|
.Select(x => x.ProtocoloConfiguracaoSensor(Pinout, Conectar))
|
|
.ToList();
|
|
configDictionary[Modulo_ID].AddRange(sensoresConfig);
|
|
|
|
// Adicionar configurações dos Sinaleiros
|
|
var sinaleirosConfig = Sinaleiros
|
|
.Select(x => x.ProtocoloConfiguracaoSinaleiro(Pinout, Conectar))
|
|
.ToList();
|
|
configDictionary[Modulo_ID].AddRange(sinaleirosConfig);
|
|
|
|
// Adicionar configurações dos Reles
|
|
var relesConfig = Reles
|
|
.Where(x => x.Controlar)
|
|
.Select(x => x.ProtocoloConfiguracaoRele(Pinout, Conectar))
|
|
.ToList();
|
|
configDictionary[Modulo_ID].AddRange(relesConfig);
|
|
|
|
// Adicionar configurações dos Servos
|
|
var servosConfig = Servos
|
|
.Where(x => x.Controlar)
|
|
.Select(x => x.ProtocoloConfiguracaoFreio(Pinout, Conectar))
|
|
.ToList();
|
|
configDictionary[Modulo_ID].AddRange(servosConfig);
|
|
|
|
// Adicionar configuração do ProtocoloMOD
|
|
string protocoloMOD =
|
|
((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
|
|
"MD" + SerialService.SplitParams +
|
|
(Conectar ? "1" : "0") + SerialService.SplitParams +
|
|
_TaxaAmostragem.ToString() + SerialService.SplitParams +
|
|
(RequisitarDados ? "1" : "0") + SerialService.SplitParams +
|
|
PinoutModel.PinoProtocolo(Pinout, Funcoes);
|
|
configDictionary[Modulo_ID].Add(protocoloMOD);
|
|
|
|
return configDictionary;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
private string ProtocoloAquisicaoDados(S_Code Componente, string ID)
|
|
{
|
|
string ProtocoloMotor =
|
|
((int)F_Code.Req).ToString() + SerialService.SplitMessage +
|
|
ID + SerialService.SplitParams +
|
|
((int)Componente).ToString() + SerialService.SplitParams +
|
|
"";
|
|
return ProtocoloMotor;
|
|
}
|
|
|
|
public void RecebeProtocoloSerial(string Protocolo)
|
|
{
|
|
string Mod_ID = Protocolo.Split(SerialService.SplitMessage[0])[0];
|
|
string mensagem = Protocolo.Substring(Mod_ID.Length + 1, Protocolo.Length - Mod_ID.Length - 1);
|
|
if (!string.IsNullOrEmpty(Protocolo) && mensagem[0].ToString() == SerialService.BeginSensor)
|
|
{
|
|
string[] Dados = mensagem.Replace(SerialService.BeginSensor, "").Split(SerialService.EndLine[0])[0].Split(';');
|
|
|
|
int cod = 0;
|
|
int.TryParse((Dados[0] ?? ""), out cod);
|
|
if (cod == 0 || Dados.Length < 3)
|
|
{
|
|
return;
|
|
}
|
|
|
|
S_Code TipoSensor = (S_Code)(cod);
|
|
|
|
SensorModel Sensor = Sensores.FirstOrDefault(x => x.ID == (Dados[1] ?? ""));
|
|
SensorSinaleiroModel Sinaleiro = Sinaleiros.FirstOrDefault(x => x.ID == (Dados[1] ?? ""));
|
|
SensorReleModel Rele = Reles.FirstOrDefault(x => x.ID == (Dados[1] ?? ""));
|
|
SensorServoModel Servo = Servos.FirstOrDefault(x => x.ID == (Dados[1] ?? ""));
|
|
|
|
if (Sensor == null && Sinaleiro == null && Rele == null && Servo == null)
|
|
{
|
|
if ((Dados[1] ?? "") == "MD")
|
|
{
|
|
Conectado = (Dados[2] ?? "") == "1";
|
|
_MensagemConexaoRecebida = true;
|
|
}
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
bool AtualizaGrafico = false;
|
|
|
|
switch (TipoSensor)
|
|
{
|
|
case S_Code.sCFG:
|
|
bool iniciado = (Dados[2] ?? "") == "1";
|
|
if (Sensor != null)
|
|
{
|
|
Sensor.Inicializado = iniciado;
|
|
}
|
|
else if (Sinaleiro != null)
|
|
{
|
|
Sinaleiro.Inicializado = iniciado;
|
|
}
|
|
else if (Rele != null)
|
|
{
|
|
Rele.Inicializado = iniciado;
|
|
}
|
|
else if (Servo != null)
|
|
{
|
|
Servo.Inicializado = iniciado;
|
|
}
|
|
break;
|
|
case S_Code.sCOR:
|
|
{
|
|
double vBarramento = -1;
|
|
double.TryParse((Dados[2] ?? "").Replace(".", ","), out vBarramento);
|
|
double vShunt = -1;
|
|
double.TryParse((Dados[3] ?? "").Replace(".", ","), out vShunt);
|
|
double corrente = -1;
|
|
double.TryParse((Dados[4] ?? "").Replace(".", ","), out corrente);
|
|
double potencia = -1;
|
|
double.TryParse((Dados[5] ?? "").Replace(".", ","), out potencia);
|
|
|
|
Sensor.Leituras = new List<double>()
|
|
{
|
|
corrente,
|
|
vBarramento,
|
|
potencia,
|
|
vShunt,
|
|
};
|
|
|
|
AtualizaGrafico = true;
|
|
break;
|
|
}
|
|
case S_Code.sTEN:
|
|
{
|
|
double leitura = -1;
|
|
double.TryParse((Dados[2] ?? "").Replace(".", ","), out leitura);
|
|
|
|
double Vcc = 3.3;
|
|
double Voffset = double.Parse(Sensor.Parametros[0][1]);
|
|
double R1 = double.Parse(Sensor.Parametros[1][1].Replace(".", ","));
|
|
double R2 = double.Parse(Sensor.Parametros[2][1].Replace(".", ","));
|
|
double Razao = (R1 + R2) / (double)R2;
|
|
double voltageV = (leitura * (Vcc / 4095.0)) + (Voffset / Razao); // Convertendo o valor ADC para tensão
|
|
double realVoltage = voltageV * Razao;
|
|
|
|
Sensor.Leituras = new List<double>()
|
|
{
|
|
realVoltage,
|
|
leitura,
|
|
voltageV,
|
|
};
|
|
|
|
if (Sensor.Descricao.ToLower().Contains("bateria"))
|
|
{
|
|
//frmInstancial.frmAcompanhamento.AtualizarSensores("Tensão atual: " + realVoltage.ToString("0.00") + "V - Mín: " + Sensor.ValorMinimo.ToString("0.00") + "V - Máx: " + Sensor.ValorMaximo.ToString("0.00") + "V");
|
|
//Variaveis.OperacaoEmAndamento.Sensoriamento.PorcentagemBateria = (realVoltage / Sensor.LimiteMaximo) * 100;
|
|
if (Variaveis.OperacaoEmAndamento.Sensoriamento.PorcentagemBateria < 0)
|
|
{
|
|
//Variaveis.OperacaoEmAndamento.Sensoriamento.PorcentagemBateria = 0;
|
|
}
|
|
}
|
|
|
|
AtualizaGrafico = true;
|
|
|
|
break;
|
|
}
|
|
case S_Code.sTMP:
|
|
{
|
|
double temp = -1;
|
|
double.TryParse((Dados[2] ?? "").Replace(".", ","), out temp);
|
|
|
|
double Tc = FuncoesMatematicas.CalcularTemperatura(temp, double.Parse(Sensor.Parametros[0][1].Replace(".", ",")));
|
|
|
|
Sensor.Leituras = new List<double>() { Tc };
|
|
|
|
if (Sensor.Descricao.ToLower().Contains("bateria"))
|
|
{
|
|
//frmInstancial.frmAcompanhamento.AtualizarSensores(Tc.ToString("0.00") + " ºC");
|
|
}
|
|
|
|
AtualizaGrafico = true;
|
|
break;
|
|
}
|
|
case S_Code.sULT:
|
|
{
|
|
double distancia = -1;
|
|
double.TryParse((Dados[2] ?? "").Replace(".", ","), out distancia);
|
|
int duracao = -1;
|
|
int.TryParse((Dados[3] ?? ""), out duracao);
|
|
|
|
Sensor.Leituras = new List<double>()
|
|
{
|
|
distancia,
|
|
duracao,
|
|
};
|
|
|
|
if (Sensor.ID == "SUESQ")
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaEsquerda = distancia;
|
|
}
|
|
else if (Sensor.ID == "SUDIR")
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaDireita = distancia;
|
|
}
|
|
|
|
AtualizaGrafico = true;
|
|
break;
|
|
}
|
|
case S_Code.sMAG:
|
|
{
|
|
int x = -1;
|
|
int.TryParse((Dados[2] ?? ""), out x);
|
|
int y = -1;
|
|
int.TryParse((Dados[3] ?? ""), out y);
|
|
int z = -1;
|
|
int.TryParse((Dados[4] ?? ""), out z);
|
|
double angulo = -1;
|
|
double.TryParse((Dados[5] ?? "").Replace(".", ","), out angulo);
|
|
|
|
Sensor.Leituras = new List<double>()
|
|
{
|
|
angulo,
|
|
x,
|
|
y,
|
|
z,
|
|
};
|
|
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.AnguloCarroBussola = angulo;
|
|
|
|
AtualizaGrafico = true;
|
|
break;
|
|
}
|
|
case S_Code.sSNR:
|
|
{
|
|
int distancia = -1;
|
|
int.TryParse((Dados[2] ?? ""), out distancia);
|
|
int angulo = -1;
|
|
int.TryParse((Dados[3] ?? ""), out angulo);
|
|
int posicao = -1;
|
|
int.TryParse((Dados[4] ?? ""), out posicao);
|
|
|
|
Sensor.Leituras = new List<double>()
|
|
{
|
|
distancia,
|
|
angulo,
|
|
posicao,
|
|
};
|
|
/*string protocolo = Dados[2];
|
|
int posicao = -1;
|
|
int.TryParse(protocolo.Split('_')[0], out posicao);
|
|
var Leituras = new Dictionary<int, int>();
|
|
foreach (var leitura in protocolo.Split('_')[1].Trim().Split('-'))
|
|
{
|
|
if (leitura == "")
|
|
{
|
|
break;
|
|
}
|
|
int distancia = int.Parse(leitura.Split(',')[0]);
|
|
int angulo = int.Parse(leitura.Split(',')[1]);
|
|
Leituras.Add(angulo, distancia);
|
|
}*/
|
|
|
|
if (Sensor.ID == "SNR_F")
|
|
{
|
|
var posArr = Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.Deteccoes.FirstOrDefault(x => x.Posicao == posicao);
|
|
if (posArr == null)
|
|
{
|
|
posArr = new SonarRegistroModel()
|
|
{
|
|
Posicao = posicao,
|
|
Leituras = new List<SonarLeituraModel>()
|
|
};
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.Deteccoes.Add(posArr);
|
|
}
|
|
var leituras = posArr.Leituras;
|
|
|
|
if (false && posicao != Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.PosicaoAtual && Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.Deteccoes.Any(x => x.Posicao == posicao))
|
|
{
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.Deteccoes.First(x => x.Posicao == posicao).Leituras.Clear();
|
|
}
|
|
|
|
if (leituras.Any(x => x.Angulo == angulo))
|
|
{
|
|
leituras.First(x => x.Angulo == angulo).Momento = DateTime.Now;
|
|
leituras.First(x => x.Angulo == angulo).Distancia = distancia;
|
|
}
|
|
else
|
|
{
|
|
leituras.Add(new SonarLeituraModel(angulo, distancia));
|
|
}
|
|
/*foreach (var leitura in Leituras)
|
|
{
|
|
if (leituras.Any(x => x.Angulo == leitura.Key))
|
|
{
|
|
leituras.First(x => x.Angulo == leitura.Key).Momento = DateTime.Now;
|
|
leituras.First(x => x.Angulo == leitura.Key).Distancia = leitura.Value;
|
|
}
|
|
else
|
|
{
|
|
leituras.Add(new SonarLeituraModel(leitura.Key, leitura.Value));
|
|
}
|
|
}*/
|
|
|
|
|
|
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaEsquerda = Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.DistanciaEsquerda;
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.DistanciaDireita = Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.DistanciaDireita;
|
|
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.PosicaoAtual = posicao;
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.AtualizarSonar();
|
|
|
|
if (
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.DesvioNecessario &&
|
|
Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal_old.DirecaoDesvio == Direcao.Parado &&
|
|
Variaveis.OperacaoEmAndamento.DispMvd.Dados.Conectado
|
|
)
|
|
{
|
|
GeneralJoystick.EnviaComandoMotor(Keys.Escape, T_Code.Mov);
|
|
}
|
|
}
|
|
|
|
AtualizaGrafico = true;
|
|
break;
|
|
}
|
|
case S_Code.sLED:
|
|
Sinaleiro.Inicializado = (Dados[2] ?? "") == "1";
|
|
Sinaleiro.StatusLED = (StatusLED)Enum.Parse(typeof(StatusLED), Dados[3]);
|
|
break;
|
|
case S_Code.sRLE:
|
|
Rele.Inicializado = (Dados[2] ?? "") == "1";
|
|
Rele.StatusLeitura = (Estado)Enum.Parse(typeof(Estado), Dados[3]);
|
|
break;
|
|
case S_Code.sFRO:
|
|
Servo.Inicializado = (Dados[2] ?? "") == "1";
|
|
int.TryParse((Dados[3] ?? ""), out int _angulo);
|
|
Servo._AnguloLeitura = _angulo;
|
|
break;
|
|
|
|
}
|
|
|
|
if (Sensor != null && Sensor.Leituras != null && Sensor.Leituras.Count() > 0)
|
|
{
|
|
if (Sensor.Leituras[0] > Sensor.ValorMaximo)
|
|
{
|
|
Sensor.ValorMaximo = Sensor.Leituras[0];
|
|
}
|
|
else if (Sensor.Leituras[0] < Sensor.ValorMinimo)
|
|
{
|
|
Sensor.ValorMinimo = Sensor.Leituras[0];
|
|
}
|
|
|
|
var Modulo = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.FirstOrDefault(x => Sensor.ID.Contains(x.Modulo_ID));
|
|
if (Modulo != null)
|
|
{
|
|
Modulo.AtualizarSensoresMotor(Sensor);
|
|
}
|
|
}
|
|
|
|
if (AtualizaGrafico)
|
|
{
|
|
Sensor.LogGrafico.Add(new SenSensorimanetoGrafico()
|
|
{
|
|
Momento = DateTime.Now,
|
|
ComponenteID = Sensor.ID,
|
|
Componente = Sensor.Componente,
|
|
Leitura1 = Sensor.Leituras.Count() > 0 ? Sensor.Leituras[0] : -1,
|
|
Leitura2 = Sensor.Leituras.Count() > 1 ? Sensor.Leituras[1] : -1,
|
|
Leitura3 = Sensor.Leituras.Count() > 2 ? Sensor.Leituras[2] : -1,
|
|
Leitura4 = Sensor.Leituras.Count() > 3 ? Sensor.Leituras[3] : -1,
|
|
AlarmeMinima = Sensor.Leituras[0] < Sensor.LimiteMinimo,
|
|
AlarmeMaxima = Sensor.Leituras[0] > Sensor.LimiteMaximo,
|
|
});
|
|
|
|
if (Sensor.LogGrafico.Count() > LogsManter)
|
|
{
|
|
Sensor.LogGrafico.RemoveAt(0);
|
|
}
|
|
|
|
if (Variaveis.DispositivosConectados.Any(x => x.Dispositivo == T_Code.Dir))
|
|
{
|
|
//((frmDirPlot)(frmPrincipal.Dispositivos.First(x => x.Dispositivo == T_Code.Dir).frmPlot)).AtualizaGrafico();
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine(ex.Message);
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|
|
|
|
public void DefineStatusConexao(string Mod_ID, bool conecatdo)
|
|
{
|
|
if (Mod_ID == Modulo_ID)
|
|
{
|
|
Conectado = conecatdo;
|
|
|
|
Variaveis.OperacaoEmAndamento.DispSen.AcaoConexao();
|
|
}
|
|
}
|
|
|
|
public string GetTaxaAmostragem()
|
|
{
|
|
return _TaxaAmostragem.ToString("00000");
|
|
}
|
|
|
|
public void SetTaxaAmostragem(int TaxaAmostragem)
|
|
{
|
|
_TaxaAmostragem = TaxaAmostragem;
|
|
}
|
|
|
|
public bool GetStatusConexao()
|
|
{
|
|
return Conectado;
|
|
}
|
|
|
|
public void IniciarRegistrador()
|
|
{
|
|
|
|
}
|
|
|
|
public async Task LoopRegistrador()
|
|
{
|
|
|
|
}
|
|
|
|
public void RequisitarDadosComponente(S_Code Componente, string ID)
|
|
{
|
|
string ProtocoloAquisicao = ProtocoloAquisicaoDados(Componente, ID);
|
|
Variaveis.OperacaoEmAndamento.DispSen.AdicionarMensagemFila(Modulo_ID, ProtocoloAquisicao, true, false);
|
|
}
|
|
|
|
|
|
public (bool, List<string>) StatusModulosSEN()
|
|
{
|
|
var _Sensores = Sensores.Where(x => x.Aferir).ToList();
|
|
var _SensoresComFalha = _Sensores.Where(x => !x.Inicializado).ToList();
|
|
bool _sensoresOperantes = _SensoresComFalha.Count() < _Sensores.Count();
|
|
|
|
var _Sinaleiros = Sinaleiros.ToList();
|
|
var _SinaleirosComFalha = _Sinaleiros.Where(x => !x.Inicializado).ToList();
|
|
bool _sinaleirosOperantes = !_SinaleirosComFalha.Any();
|
|
|
|
var _Reles = Reles.Where(x => x.Controlar).ToList();
|
|
var _RelesComFalha = _Reles.Where(x => !x.Inicializado).ToList();
|
|
bool _relesOperantes = !_RelesComFalha.Any();
|
|
|
|
var _Servos = Servos.Where(x => x.Controlar).ToList();
|
|
var _ServosComFalha = _Servos.Where(x => !x.Inicializado).ToList();
|
|
bool _servosOperantes = !_ServosComFalha.Any();
|
|
|
|
bool _sensoriamentoOperante = _sensoresOperantes && _relesOperantes && _servosOperantes;
|
|
List<string> ModsComFalha =
|
|
_SensoresComFalha.Select(x => x.ID)
|
|
.Union(_SinaleirosComFalha.Select(x => x.ID))
|
|
.Union(_RelesComFalha.Select(x => x.ID))
|
|
.Union(_ServosComFalha.Select(x => x.ID))
|
|
.ToList();
|
|
|
|
return (_sensoriamentoOperante, ModsComFalha);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public class SensorModel
|
|
{
|
|
public string ID { get; set; }
|
|
public int Prioridade { get; set; }
|
|
public string Descricao { get; set; }
|
|
public S_Code Componente { get; set; }
|
|
public bool Aferir { get; set; } = false;
|
|
public int DelayAmostragem { get; set; } = 500;
|
|
public bool Inicializado { get; set; } = false;
|
|
public bool Testando { get; set; } = false;
|
|
public List<FuncoesPinout> Funcoes { get; set; }
|
|
public List<string[]> Parametros { get; set;} = new List<string[]>();
|
|
|
|
public string UnidadeMedida { get; set; }
|
|
public List<double> Leituras { get; set; }
|
|
public double ValorMinimo { get; set; }
|
|
public double ValorMaximo { get; set; }
|
|
public double LimiteMaximo { get; set; }
|
|
public double LimiteMinimo { get; set; }
|
|
|
|
public List<SenSensorimanetoGrafico> LogGrafico = new List<SenSensorimanetoGrafico>();
|
|
|
|
public string ProtocoloConfiguracaoSensor(PinoutDataModel Pinout, bool Conectar)
|
|
{
|
|
var _pinout = new PinoutDataModel()
|
|
{
|
|
ExpansorGPIO = Pinout.ExpansorGPIO,
|
|
EnderecoExpansor = Pinout.EnderecoExpansor,
|
|
Pinos = Pinout.Pinos.ToList(),
|
|
};
|
|
_pinout.Pinos = _pinout.Pinos.Where(x => x.ComponenteID == ID).ToList();
|
|
string Protocolo =
|
|
((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
|
|
ID + SerialService.SplitParams +
|
|
(Conectar ? "1" : "0") + SerialService.SplitParams +
|
|
((int)Componente).ToString() + SerialService.SplitParams +
|
|
(Aferir ? "1" : "0") + SerialService.SplitParams +
|
|
DelayAmostragem.ToString() + SerialService.SplitParams +
|
|
Prioridade.ToString() + SerialService.SplitParams +
|
|
PinoutModel.PinoProtocolo(_pinout, Funcoes);
|
|
foreach (var Parametro in Parametros)
|
|
{
|
|
Protocolo += SerialService.SplitParams + Parametro[1];
|
|
}
|
|
return Protocolo;
|
|
}
|
|
}
|
|
|
|
public class SensorSinaleiroModel
|
|
{
|
|
public string ID { get; set; }
|
|
public string Descricao { get; set; }
|
|
public S_Code Componente { get; set; }
|
|
public List<FuncoesPinout> Funcoes { get; set; }
|
|
public SensorSinaleiroComportamentoModel Comportamento { get; set; }
|
|
|
|
public bool Inicializado { get; set; }
|
|
public StatusLED StatusLED { get; set; }
|
|
|
|
public string ProtocoloConfiguracaoSinaleiro(PinoutDataModel Pinout, bool Conectar)
|
|
{
|
|
var _pinout = new PinoutDataModel()
|
|
{
|
|
ExpansorGPIO = Pinout.ExpansorGPIO,
|
|
EnderecoExpansor = Pinout.EnderecoExpansor,
|
|
Pinos = Pinout.Pinos.ToList(),
|
|
};
|
|
_pinout.Pinos = _pinout.Pinos.Where(x => x.ComponenteID == ID).ToList();
|
|
string Protocolo = ((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
|
|
ID + SerialService.SplitParams +
|
|
(Conectar ? "1" : "0") + SerialService.SplitParams +
|
|
PinoutModel.PinoProtocolo(_pinout, Funcoes);
|
|
return Protocolo;
|
|
}
|
|
|
|
public string ProtocoloComando()
|
|
{
|
|
string ProtocoloSinaleiro =
|
|
((int)F_Code.Cmd).ToString() + SerialService.SplitMessage +
|
|
ID + SerialService.SplitParams +
|
|
(int)Comportamento.statusLED + SerialService.SplitParams +
|
|
Comportamento.QtdPiscadas.ToString() + SerialService.SplitParams +
|
|
Comportamento.TempoMs.ToString() + SerialService.SplitParams +
|
|
Comportamento.PausaMs.ToString();
|
|
|
|
return ProtocoloSinaleiro;
|
|
}
|
|
|
|
}
|
|
|
|
public class SensorReleModel
|
|
{
|
|
public string ID { get; set; }
|
|
public string Descricao { get; set; }
|
|
public S_Code Componente { get; set; }
|
|
public List<FuncoesPinout> Funcoes { get; set; }
|
|
|
|
public bool Controlar { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public Estado StatusControle { get; set; }
|
|
public Estado StatusLeitura { get; set; }
|
|
|
|
public string ProtocoloConfiguracaoRele(PinoutDataModel Pinout, bool Conectar)
|
|
{
|
|
var _pinout = new PinoutDataModel()
|
|
{
|
|
ExpansorGPIO = Pinout.ExpansorGPIO,
|
|
EnderecoExpansor = Pinout.EnderecoExpansor,
|
|
Pinos = Pinout.Pinos.ToList(),
|
|
};
|
|
_pinout.Pinos = _pinout.Pinos.Where(x => x.ComponenteID == ID).ToList();
|
|
string Protocolo = ((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
|
|
ID + SerialService.SplitParams +
|
|
(Conectar ? "1" : "0") + SerialService.SplitParams +
|
|
PinoutModel.PinoProtocolo(_pinout, Funcoes);
|
|
return Protocolo;
|
|
}
|
|
|
|
public string ProtocoloComando()
|
|
{
|
|
string ProtocoloRele =
|
|
((int)F_Code.Cmd).ToString() + SerialService.SplitMessage +
|
|
ID + SerialService.SplitParams +
|
|
(int)StatusControle;
|
|
|
|
return ProtocoloRele;
|
|
}
|
|
|
|
}
|
|
|
|
public class SensorServoModel
|
|
{
|
|
public string ID { get; set; }
|
|
public string Descricao { get; set; }
|
|
public S_Code Componente { get; set; }
|
|
public List<FuncoesPinout> Funcoes { get; set; }
|
|
|
|
public bool Controlar { get; set; }
|
|
public bool Inicializado { get; set; }
|
|
public int _AnguloControle { get; set; }
|
|
public int _AnguloLeitura { get; set; }
|
|
|
|
public string ProtocoloConfiguracaoFreio(PinoutDataModel Pinout, bool Conectar)
|
|
{
|
|
var _pinout = new PinoutDataModel()
|
|
{
|
|
ExpansorGPIO = Pinout.ExpansorGPIO,
|
|
EnderecoExpansor = Pinout.EnderecoExpansor,
|
|
Pinos = Pinout.Pinos.ToList(),
|
|
};
|
|
|
|
bool incremental = true;
|
|
var freio = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.FirstOrDefault(x => ID.Contains(x.Modulo_ID));
|
|
if (freio != null)
|
|
{
|
|
incremental = freio.MovMotor.ConfigFreio.Incremental;
|
|
}
|
|
|
|
_pinout.Pinos = _pinout.Pinos.Where(x => x.ComponenteID == ID).ToList();
|
|
string Protocolo = ((int)F_Code.Cfg).ToString() + SerialService.SplitMessage +
|
|
ID + SerialService.SplitParams +
|
|
(Conectar ? "1" : "0") + SerialService.SplitParams +
|
|
(incremental ? "1" : "0") + SerialService.SplitParams +
|
|
PinoutModel.PinoProtocolo(_pinout, Funcoes);
|
|
return Protocolo;
|
|
}
|
|
|
|
public string ProtocoloComando()
|
|
{
|
|
string ProtocoloFreio =
|
|
((int)F_Code.Cmd).ToString() + SerialService.SplitMessage +
|
|
ID + SerialService.SplitParams +
|
|
_AnguloControle;
|
|
|
|
return ProtocoloFreio;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public class SensorSinaleiroComportamentoModel
|
|
{
|
|
public StatusLED statusLED { get; set; }
|
|
public int QtdPiscadas { get; set; } = 0;
|
|
public int TempoMs { get; set; } = 0;
|
|
public int PausaMs { get; set; } = 0;
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj == null || GetType() != obj.GetType())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
SensorSinaleiroComportamentoModel other = (SensorSinaleiroComportamentoModel)obj;
|
|
return statusLED == other.statusLED &&
|
|
QtdPiscadas == other.QtdPiscadas &&
|
|
TempoMs == other.TempoMs &&
|
|
PausaMs == other.PausaMs;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
unchecked // Permite overflow de inteiros
|
|
{
|
|
int hash = 17;
|
|
hash = hash * 23 + statusLED.GetHashCode();
|
|
hash = hash * 23 + QtdPiscadas.GetHashCode();
|
|
hash = hash * 23 + TempoMs.GetHashCode();
|
|
hash = hash * 23 + PausaMs.GetHashCode();
|
|
return hash;
|
|
}
|
|
}
|
|
|
|
public static bool operator ==(SensorSinaleiroComportamentoModel left, SensorSinaleiroComportamentoModel right)
|
|
{
|
|
if (ReferenceEquals(left, right))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if ((object)left == null || (object)right == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return left.Equals(right);
|
|
}
|
|
|
|
public static bool operator !=(SensorSinaleiroComportamentoModel left, SensorSinaleiroComportamentoModel right)
|
|
{
|
|
return !(left == right);
|
|
}
|
|
}
|
|
|
|
public class SenSensorimanetoGrafico
|
|
{
|
|
public DateTime Momento { get; set; }
|
|
public string ComponenteID { get; set; }
|
|
public S_Code Componente { get; set; }
|
|
public double Leitura1 { get; set; }
|
|
public double Leitura2 { get; set; }
|
|
public double Leitura3 { get; set; }
|
|
public double Leitura4 { get; set; }
|
|
public bool AlarmeMaxima { get; set; }
|
|
public bool AlarmeMinima { get; set; }
|
|
}
|
|
|
|
|
|
}
|