Zendion/agrobot_base
Zendion
/
agrobot_base
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ajsutes gerais na mensageria CAN e verificacao serial

This commit is contained in:
Diego Freitas 2025-04-11 09:25:52 -03:00
parent 1712254d9c
commit a0b879c877
3 changed files with 101 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
AgroBase/AgroBase/Services/CANService.cs
View File

@ -34,7 +34,7 @@ namespace AgroBase.Services
public class CanService : IDisposable
{
public static SerialPort _serialPort;
public static SerialPort _PortaCAN;
public static string _portName;
private static int _baudRate;
private static object _lock = new object();
@ -67,15 +67,15 @@ namespace AgroBase.Services
Porta.Close();
}
if (_serialPort == null || !IsConnected)
if (_PortaCAN == null || !IsConnected)
{
lock (_lock)
{
_portName = Porta.PortName;
_baudRate = 115200;
_serialPort = new SerialPort(_portName, _baudRate, Parity.None, 8, StopBits.One);
_serialPort.Open();
_PortaCAN = new SerialPort(_portName, _baudRate, Parity.None, 8, StopBits.One);
_PortaCAN.Open();
EnviarComando("S6\r"); // 500Kbps
Thread.Sleep(100);
@ -83,28 +83,28 @@ namespace AgroBase.Services
Thread.Sleep(100);
tmrOuvirCAN?.Dispose();
tmrOuvirCAN = new AsyncTaskTimerModel("tmrOuvirCAN", OuvirCAN, 10);
tmrOuvirCAN = new AsyncTaskTimerModel("tmrOuvirCAN", OuvirCAN, 5);
tmrOuvirCAN.Start();
tmrEnviarCAN?.Dispose();
tmrEnviarCAN = new AsyncTaskTimerModel("tmrEnviarCAN", EnviarCAN, 10);
tmrEnviarCAN = new AsyncTaskTimerModel("tmrEnviarCAN", EnviarCAN, 5);
tmrEnviarCAN.Start();
IsConnected = true;
}
}
if (_serialPort != null && !_serialPort.IsOpen)
if (_PortaCAN != null && !_PortaCAN.IsOpen)
{
_serialPort.Open();
_PortaCAN.Open();
}
}
private static async Task OuvirCAN()
{
if (_serialPort.BytesToRead > 0)
if (_PortaCAN.BytesToRead > 0)
{
byte[] tempBuffer = await SerialService.LerDadosDaPortaSerialAsync(_serialPort, _serialPort.BytesToRead);
byte[] tempBuffer = await SerialService.LerDadosDaPortaSerialAsync(_PortaCAN, _PortaCAN.BytesToRead);
foreach (byte b in tempBuffer)
{
@ -187,7 +187,7 @@ namespace AgroBase.Services
public static void AdicionarMensagemNaFila(T_Code Dispositivo, byte id, byte funcCodeTx, byte funcCodeRx, byte[] payload = null, bool get = true)
{
if (_serialPort?.IsOpen != true) return;
if (_PortaCAN?.IsOpen != true) return;
// Monta o payload com funcCode + dados + CRC
var dados = new List<byte> { funcCodeTx };
@ -275,7 +275,7 @@ namespace AgroBase.Services
private static async Task EnviarCAN()
{
if (_serialPort?.IsOpen != true) return;
if (_PortaCAN?.IsOpen != true) return;
CanMessage msg = ObterProximaMensagem();
@ -285,7 +285,7 @@ namespace AgroBase.Services
if (_ultimoIdEnviado.HasValue && msg.Id == _ultimoIdEnviado.Value)
{
await Task.Delay(50);
await Task.Delay(5);
}
lock (_lock)
@ -312,9 +312,9 @@ namespace AgroBase.Services
private static void EnviarComando(string comando)
{
if (_serialPort?.IsOpen == true)
if (_PortaCAN?.IsOpen == true)
{
_serialPort.Write(comando);
_PortaCAN.Write(comando);
//Console.WriteLine($"[CAN] Frame enviado: {comando}");
}
@ -347,10 +347,10 @@ namespace AgroBase.Services
_roteadores.Clear();
_ultimoIdEnviado = null;
if (_serialPort?.IsOpen == true)
if (_PortaCAN?.IsOpen == true)
{
EnviarComando("C\r");
_serialPort.Close();
_PortaCAN.Close();
}
IsConnected = false;

2
AgroBase/AgroBase/Services/MKS057DCanService.cs
View File

@ -36,7 +36,7 @@ namespace AgroBase.Services
{
get
{
return Referenciando ? 200 : 1000;
return Referenciando ? 100 : 300;
}
}

291
AgroBase/AgroBase/Services/SerialService.cs
View File

@ -192,8 +192,6 @@ namespace AgroBase.Services
try
{
ProcurarDispositivosUSB();
var dispositivosMapeados = DispositivosMapeados.ToList();
var Portas = SerialPort.GetPortNames();
@ -206,60 +204,57 @@ namespace AgroBase.Services
AtualizarConsole("Procurando dispositivos conectados à porta " + PortaCom + "...");
SerialPort _Porta = new SerialPort() { PortName = PortaCom, BaudRate = 115200 };
if (Variaveis.IsAgroMonitor)
if (!LoRaService.Iniciado)
{
try
{
bool LoRa = await ProcuraDispositivoLoRa(_Porta);
if (!LoRa && !GPSService.Iniciado)
{
_Porta.Open();
await AguardaRespostaPorta(_Porta, 1100);
bool GPS = VerificaRespostaGPS(_Porta);
}
}
catch (Exception ex)
{
Console.WriteLine("Erro ao abrir a porta " + PortaCom + ": " + ex.Message);
}
finally
bool LoRa = await ProcurarDispositivoLoRa(_Porta);
if (LoRa)
{
_Porta.Close();
continue;
}
continue;
}
bool PortaDispositivoProprio = false;
if (!GPSService.Iniciado)
{
bool GPSEncontrado = await ProcurarDispositivoGPS(_Porta);
if (GPSEncontrado)
{
_Porta.Close();
continue;
}
}
if (Variaveis.OperacaoEmAndamento.DispMvd == null)
if (Variaveis.IsAgroMonitor || Variaveis.OperacaoEmAndamento.DispMvd == null)
{
continue;
}
try
{
_Porta.Open();
if (!PortaDispositivoProprio && !GPSService.Iniciado)
if (!CanService.Iniciado)
{
AtualizarConsole("Procurando dispositivo GPS");
await Task.Delay(1000);
bool GPSEncontrado = VerificaRespostaGPS(_Porta);
if (GPSEncontrado)
AtualizarConsole($"{PortaCom} - Procurando dispositivos no barramento CAN");
bool dispositivoCan = await ProcurarDispositivosCAN(_Porta);
if (dispositivoCan)
{
_Porta.Close();
AtualizarConsole("Barramento CAN encontrado");
continue;
}
}
bool dispositivoCan = await ProcurarDispositivosCAN(_Porta);
if (dispositivoCan)
if (!ModbusService.Iniciado)
{
_Porta.Close();
continue;
AtualizarConsole($"{PortaCom} - Procurando dispositivos no barramento RS485");
bool DispModbus = await ProcuraDispositivoModbus(_Porta);
if (DispModbus)
{
_Porta.Close();
AtualizarConsole("Barramento RS485 encontrado");
continue;
}
}
}
catch (Exception ex)
{
@ -271,11 +266,6 @@ namespace AgroBase.Services
await Task.Delay(100);
}
if (!PortaDispositivoProprio)
{
await TentarIdentificarDispositivo(_Porta);
}
}
if (Variaveis.IsAgroMonitor)
@ -283,39 +273,16 @@ namespace AgroBase.Services
return;
}
ProcurarDispositivosUSB();
if (Variaveis.OperacaoEmAndamento.DispMvd != null)
{
await ProcurarDispositivosEthernet();
}
var DispositivosRemovidos = dispositivosMapeados.Where(x => x.Tipo == TipoConexao.PortaCOM && !Portas.Contains(x.Endereco)).ToList();
foreach (var Dispositivo in DispositivosRemovidos)
{
DispositivosMapeados.Remove(Dispositivo);
}
/*if (DispositivosMapeados.Any(x => DispositivosConexaoInicial.Contains(x.Dispositivo)))
{
FilaService.IniciarRotinas();
}
else
{
FilaService.PararRotinas();
}*/
if (DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Knt) && !KinectService.Iniciado)
{
KinectService.PararRotinas();
DispositivosMapeados.Remove(DispositivosMapeados.First(x => x.Dispositivo == T_Code.Knt));
}
AtualizarDispositivos();
// Se algum dispositivo no barramento RS485 para Modbus já foi identificado
if (ModbusService.Iniciado)
{
await ProcuraDispositivoModbus(ModbusService._PortaModbus, false);
await ProcuraDispositivoModbus(ModbusService._PortaModbus);
}
else
{
@ -328,7 +295,7 @@ namespace AgroBase.Services
if (CanService.Iniciado)
{
await ProcurarDispositivosCAN(CanService._serialPort);
await ProcurarDispositivosCAN(CanService._PortaCAN);
}
else
{
@ -338,6 +305,21 @@ namespace AgroBase.Services
DispositivosMapeados.Remove(DispositivosMapeados.FirstOrDefault(x => x.Dispositivo == _Disp));
}
}
var DispositivosRemovidos = dispositivosMapeados.Where(x => x.Tipo == TipoConexao.PortaCOM && !Portas.Contains(x.Endereco)).ToList();
foreach (var Dispositivo in DispositivosRemovidos)
{
DispositivosMapeados.Remove(Dispositivo);
}
if (DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Knt) && !KinectService.Iniciado)
{
KinectService.PararRotinas();
DispositivosMapeados.Remove(DispositivosMapeados.First(x => x.Dispositivo == T_Code.Knt));
}
AtualizarDispositivos();
}
catch (Exception ex)
{
@ -348,6 +330,8 @@ namespace AgroBase.Services
VarreduraEmAndamento = false;
RealizarVerificacaoDeRotina();
AtualizarConsole("Iteração finalizada, aguardando a próxima...");
}
}
@ -511,205 +495,78 @@ namespace AgroBase.Services
}
}
private static async Task<bool> TentarIdentificarDispositivo(SerialPort porta)
private static async Task<bool> ProcuraDispositivoModbus(SerialPort porta)
{
// Método para tentar identificar dispositivos que não respondem ao comando de verificação padrão
try
{
bool DispModbus = await ProcuraDispositivoModbus(porta, false);
if (DispModbus)
{
return true;
}
bool DispLoRa = await ProcuraDispositivoLoRa(porta);
if (DispLoRa)
{
return true;
}
if (TentativasPortas.TryGetValue(porta.PortName, out int tentativas))
{
TentativasPortas[porta.PortName] = tentativas + 1;
}
else
{
TentativasPortas.Add(porta.PortName, 1);
}
if (TentativasPortas[porta.PortName] > 5)
{
TentativasPortas.Remove(porta.PortName);
//PortasDesconhecidas.Add(porta);
}
}
catch (Exception ex)
{
Console.WriteLine("Erro ao tentar identificar dispositivo na porta " + porta.PortName + ": " + ex.Message);
porta.Close();
}
return false;
}
private static async Task<bool> ProcuraDispositivoMvd(SerialPort porta)
{
bool DispositivoMvd = false;
if (porta == null)
{
return false;
}
if (DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Mvd) && porta.PortName != DispositivosMapeados.First(x => x.Dispositivo == T_Code.Mvd).Endereco)
{
return false;
}
bool conectado = Variaveis.OperacaoEmAndamento.DispMvd.Dados.Conectado;
if (!conectado)
{
porta.Open();
}
foreach (var Modulo in Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos.Where(x => !DispositivosMapeados.Select(y => y.Mod_ID).Contains(x.Modulo_ID)))
{
try
{
string ProtocoloCheck = Modulo.ProtocoloVerificacao(true);
EnviarDadosPortaSerial(porta, ProtocoloCheck);
await AguardaRespostaPorta(porta, 1000);
bool respondeu = ProcessarRespostaDispositivo(porta);
if (!DispositivoMvd)
{
DispositivoMvd = respondeu;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
if (!conectado)
{
porta.Close();
}
return DispositivoMvd;
}
private static async Task<bool> ProcuraDispositivoModbus(SerialPort porta, bool PararAoEncontrar)
{
if (ModbusService.Iniciado && porta.PortName != ModbusService._PortaModbus.PortName)
{
return false;
}
bool ProcurarPzm = !PZEMService.Iniciado || !DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Pzm);
bool ProcurarWit = !WT901CService.Iniciado || !DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Wit);
bool ProcurarA05 = !UltrasonicA05Service.Iniciado || !DispositivosMapeados.Any(x => x.Dispositivo == T_Code.A05);
if (!ProcurarPzm && !ProcurarWit && !ProcurarA05)
{
return false;
return ModbusService.Iniciado;
}
AtualizarConsole("Procurando dispositivos Modbus");
if (ProcurarPzm)
{
AtualizarConsole("Procurando dispositivo PZM");
AtualizarConsole($"{porta.PortName} - Procurando dispositivo PZM");
bool _encontrado = await PZEMService.VerificaPortaPZEM(ModbusService.Iniciado ? ModbusService._PortaModbus : porta);
if (_encontrado && PararAoEncontrar)
if (_encontrado)
{
AtualizarConsole("Dispositivo PZM encontrado");
return _encontrado;
}
}
if (ProcurarWit)
{
AtualizarConsole("Procurando dispositivo WIT");
bool _encontrado = await WT901CService.VerificaPortaWT901C(ModbusService.Iniciado ? ModbusService._PortaModbus : porta);
if (_encontrado && PararAoEncontrar)
if (_encontrado)
{
AtualizarConsole("Dispositivo WIT encontrado");
return _encontrado;
}
}
if (ProcurarA05)
{
AtualizarConsole("Procurando dispositivo A05");
bool _encontrado = await UltrasonicA05Service.VerificaPortaA05(ModbusService.Iniciado ? ModbusService._PortaModbus : porta);
if (_encontrado && PararAoEncontrar)
if (_encontrado)
{
AtualizarConsole("Dispositivo A05 encontrado");
return _encontrado;
}
}
return ModbusService.Iniciado;
}
private static async Task<bool> ProcuraDispositivoLoRa(SerialPort porta)
{
if (LoRaService.Iniciado && porta.PortName != LoRaService._PortaLoRa.PortName)
{
return false;
}
if (!LoRaService.Iniciado)
{
AtualizarConsole("Procurando dispositivo LRA");
bool Encontrado = await LoRaService.VerificaPortaLoRa(porta);
if (Encontrado)
{
AtualizarConsole("Dispositivo LRA encontrado");
}
return Encontrado;
}
else
{
return false;
}
}
private static async Task<bool> ProcurarDispositivosCAN(SerialPort porta)
{
bool dispCan = false;
if (!Variaveis.OperacaoEmAndamento.DispSen.Dados.Conectado)
{
AtualizarConsole($"{porta.PortName} - Procurando dispositivo SEN");
bool DispSen = await Variaveis.OperacaoEmAndamento.DispSen.Dados.VerificaPortaSEN(porta);
if (DispSen)
{
dispCan = DispSen;
AtualizarConsole("Dispositivo SEN encontrado");
}
}
if (!Variaveis.OperacaoEmAndamento.DispAtu.Dados.Conectado)
{
AtualizarConsole($"{porta.PortName} - Procurando dispositivo ATU");
bool DispAtu = await Variaveis.OperacaoEmAndamento.DispAtu.Dados.VerificaPortaATU(porta);
if (DispAtu)
{
dispCan = DispAtu;
AtualizarConsole("Dispositivo ATU encontrado");
}
}
bool DispMks = await ProcuraDispositivoMKS(porta);
if (DispMks)
{
dispCan = DispMks;
}
return dispCan;
return CanService.Iniciado;
}
private static void ProcurarDispositivosUSB()
@ -794,7 +651,7 @@ namespace AgroBase.Services
{
if (!MKS057DCanService.Referenciando && (!MKS057DCanService.Iniciado || MKS057DCanService.DadosLeitura.Count(x => x.Iniciado) < (Variaveis.OperacaoEmAndamento.DispMvd?.Dados?.Modulos?.Count() ?? 4)))
{
AtualizarConsole("Procurando dispositivos MKS");
AtualizarConsole($"{porta.PortName} - Procurando dispositivos MKS");
bool Encontrado = await MKS057DCanService.VerificaPortaMKS(porta);
if (Encontrado)
{
@ -806,9 +663,27 @@ namespace AgroBase.Services
return MKS057DCanService.Iniciado;
}
private static bool VerificaRespostaGPS(SerialPort Porta, string Recebido = null)
private static async Task<bool> ProcurarDispositivoLoRa(SerialPort porta)
{
AtualizarConsole($"{porta.PortName} - Procurando dispositivo LRA");
bool Encontrado = await LoRaService.VerificaPortaLoRa(porta);
if (Encontrado)
{
AtualizarConsole("Dispositivo LRA encontrado");
return true;
}
return false;
}
private static async Task<bool> ProcurarDispositivoGPS(SerialPort Porta)
{
Porta.Open();
await Task.Delay(100);
AtualizarConsole($"{Porta.PortName} - Procurando dispositivo GPS");
await Task.Delay(1000);
string Recebido = "";
if (string.IsNullOrEmpty(Recebido))
{
//Recebido = Porta.ReadLine();