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

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

@ -36,7 +36,7 @@ namespace AgroBase.Services
{ {
get 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 try
{ {
ProcurarDispositivosUSB();
var dispositivosMapeados = DispositivosMapeados.ToList(); var dispositivosMapeados = DispositivosMapeados.ToList();
var Portas = SerialPort.GetPortNames(); var Portas = SerialPort.GetPortNames();
@ -206,60 +204,57 @@ namespace AgroBase.Services
AtualizarConsole("Procurando dispositivos conectados à porta " + PortaCom + "..."); AtualizarConsole("Procurando dispositivos conectados à porta " + PortaCom + "...");
SerialPort _Porta = new SerialPort() { PortName = PortaCom, BaudRate = 115200 }; SerialPort _Porta = new SerialPort() { PortName = PortaCom, BaudRate = 115200 };
if (Variaveis.IsAgroMonitor) if (!LoRaService.Iniciado)
{ {
try bool LoRa = await ProcurarDispositivoLoRa(_Porta);
{ if (LoRa)
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
{ {
_Porta.Close(); _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; continue;
} }
try try
{ {
_Porta.Open(); if (!CanService.Iniciado)
if (!PortaDispositivoProprio && !GPSService.Iniciado)
{ {
AtualizarConsole("Procurando dispositivo GPS"); AtualizarConsole($"{PortaCom} - Procurando dispositivos no barramento CAN");
await Task.Delay(1000); bool dispositivoCan = await ProcurarDispositivosCAN(_Porta);
bool GPSEncontrado = VerificaRespostaGPS(_Porta); if (dispositivoCan)
if (GPSEncontrado)
{ {
_Porta.Close(); _Porta.Close();
AtualizarConsole("Barramento CAN encontrado");
continue; continue;
} }
} }
bool dispositivoCan = await ProcurarDispositivosCAN(_Porta); if (!ModbusService.Iniciado)
if (dispositivoCan)
{ {
_Porta.Close(); AtualizarConsole($"{PortaCom} - Procurando dispositivos no barramento RS485");
continue; bool DispModbus = await ProcuraDispositivoModbus(_Porta);
if (DispModbus)
{
_Porta.Close();
AtualizarConsole("Barramento RS485 encontrado");
continue;
}
} }
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -271,11 +266,6 @@ namespace AgroBase.Services
await Task.Delay(100); await Task.Delay(100);
} }
if (!PortaDispositivoProprio)
{
await TentarIdentificarDispositivo(_Porta);
}
} }
if (Variaveis.IsAgroMonitor) if (Variaveis.IsAgroMonitor)
@ -283,39 +273,16 @@ namespace AgroBase.Services
return; return;
} }
ProcurarDispositivosUSB();
if (Variaveis.OperacaoEmAndamento.DispMvd != null) if (Variaveis.OperacaoEmAndamento.DispMvd != null)
{ {
await ProcurarDispositivosEthernet(); 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) if (ModbusService.Iniciado)
{ {
await ProcuraDispositivoModbus(ModbusService._PortaModbus, false); await ProcuraDispositivoModbus(ModbusService._PortaModbus);
} }
else else
{ {
@ -328,7 +295,7 @@ namespace AgroBase.Services
if (CanService.Iniciado) if (CanService.Iniciado)
{ {
await ProcurarDispositivosCAN(CanService._serialPort); await ProcurarDispositivosCAN(CanService._PortaCAN);
} }
else else
{ {
@ -338,6 +305,21 @@ namespace AgroBase.Services
DispositivosMapeados.Remove(DispositivosMapeados.FirstOrDefault(x => x.Dispositivo == _Disp)); 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) catch (Exception ex)
{ {
@ -348,6 +330,8 @@ namespace AgroBase.Services
VarreduraEmAndamento = false; VarreduraEmAndamento = false;
RealizarVerificacaoDeRotina(); 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 ProcurarPzm = !PZEMService.Iniciado || !DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Pzm);
bool ProcurarWit = !WT901CService.Iniciado || !DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Wit); bool ProcurarWit = !WT901CService.Iniciado || !DispositivosMapeados.Any(x => x.Dispositivo == T_Code.Wit);
bool ProcurarA05 = !UltrasonicA05Service.Iniciado || !DispositivosMapeados.Any(x => x.Dispositivo == T_Code.A05); bool ProcurarA05 = !UltrasonicA05Service.Iniciado || !DispositivosMapeados.Any(x => x.Dispositivo == T_Code.A05);
if (!ProcurarPzm && !ProcurarWit && !ProcurarA05) if (!ProcurarPzm && !ProcurarWit && !ProcurarA05)
{ {
return false; return ModbusService.Iniciado;
} }
AtualizarConsole("Procurando dispositivos Modbus");
if (ProcurarPzm) if (ProcurarPzm)
{ {
AtualizarConsole("Procurando dispositivo PZM"); AtualizarConsole($"{porta.PortName} - Procurando dispositivo PZM");
bool _encontrado = await PZEMService.VerificaPortaPZEM(ModbusService.Iniciado ? ModbusService._PortaModbus : porta); bool _encontrado = await PZEMService.VerificaPortaPZEM(ModbusService.Iniciado ? ModbusService._PortaModbus : porta);
if (_encontrado && PararAoEncontrar) if (_encontrado)
{ {
AtualizarConsole("Dispositivo PZM encontrado"); AtualizarConsole("Dispositivo PZM encontrado");
return _encontrado;
} }
} }
if (ProcurarWit) if (ProcurarWit)
{ {
AtualizarConsole("Procurando dispositivo WIT"); AtualizarConsole("Procurando dispositivo WIT");
bool _encontrado = await WT901CService.VerificaPortaWT901C(ModbusService.Iniciado ? ModbusService._PortaModbus : porta); bool _encontrado = await WT901CService.VerificaPortaWT901C(ModbusService.Iniciado ? ModbusService._PortaModbus : porta);
if (_encontrado && PararAoEncontrar) if (_encontrado)
{ {
AtualizarConsole("Dispositivo WIT encontrado"); AtualizarConsole("Dispositivo WIT encontrado");
return _encontrado;
} }
} }
if (ProcurarA05) if (ProcurarA05)
{ {
AtualizarConsole("Procurando dispositivo A05"); AtualizarConsole("Procurando dispositivo A05");
bool _encontrado = await UltrasonicA05Service.VerificaPortaA05(ModbusService.Iniciado ? ModbusService._PortaModbus : porta); bool _encontrado = await UltrasonicA05Service.VerificaPortaA05(ModbusService.Iniciado ? ModbusService._PortaModbus : porta);
if (_encontrado && PararAoEncontrar) if (_encontrado)
{ {
AtualizarConsole("Dispositivo A05 encontrado"); AtualizarConsole("Dispositivo A05 encontrado");
return _encontrado;
} }
} }
return ModbusService.Iniciado; 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) private static async Task<bool> ProcurarDispositivosCAN(SerialPort porta)
{ {
bool dispCan = false;
if (!Variaveis.OperacaoEmAndamento.DispSen.Dados.Conectado) if (!Variaveis.OperacaoEmAndamento.DispSen.Dados.Conectado)
{ {
AtualizarConsole($"{porta.PortName} - Procurando dispositivo SEN");
bool DispSen = await Variaveis.OperacaoEmAndamento.DispSen.Dados.VerificaPortaSEN(porta); bool DispSen = await Variaveis.OperacaoEmAndamento.DispSen.Dados.VerificaPortaSEN(porta);
if (DispSen) if (DispSen)
{ {
dispCan = DispSen; AtualizarConsole("Dispositivo SEN encontrado");
} }
} }
if (!Variaveis.OperacaoEmAndamento.DispAtu.Dados.Conectado) if (!Variaveis.OperacaoEmAndamento.DispAtu.Dados.Conectado)
{ {
AtualizarConsole($"{porta.PortName} - Procurando dispositivo ATU");
bool DispAtu = await Variaveis.OperacaoEmAndamento.DispAtu.Dados.VerificaPortaATU(porta); bool DispAtu = await Variaveis.OperacaoEmAndamento.DispAtu.Dados.VerificaPortaATU(porta);
if (DispAtu) if (DispAtu)
{ {
dispCan = DispAtu; AtualizarConsole("Dispositivo ATU encontrado");
} }
} }
bool DispMks = await ProcuraDispositivoMKS(porta); bool DispMks = await ProcuraDispositivoMKS(porta);
if (DispMks) if (DispMks)
{ {
dispCan = DispMks;
} }
return dispCan; return CanService.Iniciado;
} }
private static void ProcurarDispositivosUSB() 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))) 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); bool Encontrado = await MKS057DCanService.VerificaPortaMKS(porta);
if (Encontrado) if (Encontrado)
{ {
@ -806,9 +663,27 @@ namespace AgroBase.Services
return MKS057DCanService.Iniciado; return MKS057DCanService.Iniciado;
} }
private static async Task<bool> ProcurarDispositivoLoRa(SerialPort porta)
private static bool VerificaRespostaGPS(SerialPort Porta, string Recebido = null)
{ {
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)) if (string.IsNullOrEmpty(Recebido))
{ {
//Recebido = Porta.ReadLine(); //Recebido = Porta.ReadLine();