895 lines
31 KiB
C#
895 lines
31 KiB
C#
using AgroBase.Forms;
|
|
using AgroBase.Models;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO.Ports;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using static AgroBase.Models.Enums;
|
|
|
|
namespace AgroBase.Services
|
|
{
|
|
public class SerialService
|
|
{
|
|
public static int InteraloVerificacao = 5000;
|
|
|
|
public static readonly string BeginLine = "@";
|
|
public static readonly string BreakLine = "&";
|
|
public static readonly string EndLine = "$";
|
|
public static readonly string BeginSensor = "#";
|
|
public static readonly string SplitMessage = ";";
|
|
public static readonly string SplitParams = ",";
|
|
public static readonly string SplitConfig = "*";
|
|
public static readonly string SplitSubParams = "~";
|
|
public static List<T_Code> DispositivosMotores = new List<T_Code>() { T_Code.Mov, T_Code.Dir };
|
|
public static List<T_Code> DispositivosConexaoInicial = new List<T_Code>() { T_Code.Mvd, T_Code.Atu, T_Code.Sen };
|
|
public static List<T_Code> DispositivosProprios = new List<T_Code>() { T_Code.Atu, T_Code.Sen };
|
|
public static List<T_Code> DispositivosModbus = new List<T_Code>() { T_Code.Pzm, T_Code.Wit, T_Code.A05 };
|
|
public static List<T_Code> DispositivosMultiplos = new List<T_Code>() { T_Code.Bld, T_Code.Mks, T_Code.Mvd };
|
|
|
|
public static List<DispositivoDetalhesModel> DispositivosMapeados = new List<DispositivoDetalhesModel>();
|
|
private static Dictionary<string, int> TentativasPortas = new Dictionary<string, int>();
|
|
private static bool VarreduraEmAndamento = false;
|
|
|
|
|
|
public static bool EnviarDadosPortaSerial(SerialPort _porta, string Dados, bool DebugMode = false)
|
|
{
|
|
bool ForceDebug = false;
|
|
if (ForceDebug)
|
|
{
|
|
DebugMode = true;
|
|
}
|
|
|
|
// Verifica se a porta está definida
|
|
if (_porta == null)
|
|
{
|
|
Console.WriteLine("A porta serial não está definida.");
|
|
return false;
|
|
}
|
|
|
|
// Verifica se a porta está aberta
|
|
if (!_porta.IsOpen)
|
|
{
|
|
Console.WriteLine("A porta serial não está aberta.");
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
// Define o tempo de espera máximo para a operação de escrita
|
|
_porta.WriteTimeout = 2000; // 2 segundos de timeout para escrita (ajuste conforme necessário)
|
|
|
|
// Verifica se há dados para enviar
|
|
if (string.IsNullOrEmpty(Dados))
|
|
{
|
|
if (DebugMode)
|
|
Console.WriteLine("Nenhum dado para enviar.");
|
|
return false;
|
|
}
|
|
|
|
// Tenta enviar os dados na porta serial
|
|
_porta.Write(Dados);
|
|
if (DebugMode)
|
|
Console.WriteLine("Dados enviados com sucesso.");
|
|
return true;
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
// Timeout ocorreu, o que significa que não foi possível escrever os dados no tempo estipulado
|
|
if (DebugMode)
|
|
Console.WriteLine("Erro: Timeout ao tentar enviar dados.");
|
|
return false;
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
// A porta não estava aberta ou algo relacionado a uma falha de operação na porta
|
|
if (DebugMode)
|
|
Console.WriteLine("Erro: A porta serial não está aberta ou houve uma falha na operação. " + ex.Message);
|
|
return false;
|
|
}
|
|
catch (UnauthorizedAccessException ex)
|
|
{
|
|
// Caso a porta serial esteja sendo acessada por outro processo
|
|
if (DebugMode)
|
|
Console.WriteLine("Erro: Acesso negado à porta serial. " + ex.Message);
|
|
return false;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Captura outros tipos de erro inesperados
|
|
if (DebugMode)
|
|
Console.WriteLine("Erro inesperado: " + ex.Message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static bool EnviarDadosPortaSerial(SerialPort _porta, byte[] Dados, int inicio, int comprimento, bool DebugMode = false)
|
|
{
|
|
bool ForceDebug = false;
|
|
if (ForceDebug)
|
|
{
|
|
DebugMode = true;
|
|
}
|
|
|
|
// Verifica se a porta está definida
|
|
if (_porta == null)
|
|
{
|
|
Console.WriteLine("A porta serial não está definida.");
|
|
return false;
|
|
}
|
|
|
|
// Verifica se a porta está aberta
|
|
if (!_porta.IsOpen)
|
|
{
|
|
Console.WriteLine("A porta serial não está aberta.");
|
|
return false;
|
|
}
|
|
|
|
try
|
|
{
|
|
// Define o tempo de espera máximo para a operação de escrita
|
|
_porta.WriteTimeout = 2000; // 2 segundos de timeout para escrita (ajuste conforme necessário)
|
|
|
|
// Verifica se há dados para enviar
|
|
if (Dados == null || Dados.Length == 0)
|
|
{
|
|
if (DebugMode)
|
|
Console.WriteLine("Nenhum dado para enviar.");
|
|
return false;
|
|
}
|
|
|
|
// Tenta enviar os dados na porta serial
|
|
_porta.Write(Dados, inicio, comprimento);
|
|
if (DebugMode)
|
|
Console.WriteLine("Dados enviados com sucesso.");
|
|
return true;
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
// Timeout ocorreu, o que significa que não foi possível escrever os dados no tempo estipulado
|
|
if (DebugMode)
|
|
Console.WriteLine("Erro: Timeout ao tentar enviar dados.");
|
|
return false;
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
// A porta não estava aberta ou algo relacionado a uma falha de operação na porta
|
|
if (DebugMode)
|
|
Console.WriteLine("Erro: A porta serial não está aberta ou houve uma falha na operação. " + ex.Message);
|
|
return false;
|
|
}
|
|
catch (UnauthorizedAccessException ex)
|
|
{
|
|
// Caso a porta serial esteja sendo acessada por outro processo
|
|
if (DebugMode)
|
|
Console.WriteLine("Erro: Acesso negado à porta serial. " + ex.Message);
|
|
return false;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Captura outros tipos de erro inesperados
|
|
if (DebugMode)
|
|
Console.WriteLine("Erro inesperado: " + ex.Message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public static async Task RealizarVarreduraPortasUSB()
|
|
{
|
|
if (VarreduraEmAndamento || frmInstancial.Fechando)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//VarreduraEmAndamento = true;
|
|
|
|
try
|
|
{
|
|
ProcurarDispositivosUSB();
|
|
|
|
var dispositivosMapeados = DispositivosMapeados.ToList();
|
|
|
|
var Portas = SerialPort.GetPortNames();
|
|
var PortasNaoMapeadas = Portas.Where(x => !dispositivosMapeados.Select(y => y.Endereco).Contains(x)).ToList();
|
|
List<string> PortasSemResposta = new List<string>();
|
|
|
|
for (int i = 0; i < PortasNaoMapeadas.Count(); i++)
|
|
{
|
|
string PortaCom = PortasNaoMapeadas[i].ToString();
|
|
AtualizarConsole("Procurando dispositivos conectados à porta " + PortaCom + "...");
|
|
SerialPort _Porta = new SerialPort() { PortName = PortaCom, BaudRate = 115200 };
|
|
|
|
if (Variaveis.IsAgroMonitor)
|
|
{
|
|
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
|
|
{
|
|
_Porta.Close();
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
bool PortaDispositivoProprio = false;
|
|
|
|
if (Variaveis.OperacaoEmAndamento.DispMvd == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
_Porta.Open();
|
|
|
|
if (!PortaDispositivoProprio && !GPSService.Iniciado)
|
|
{
|
|
AtualizarConsole("Procurando dispositivo GPS");
|
|
await Task.Delay(1000);
|
|
bool GPSEncontrado = VerificaRespostaGPS(_Porta);
|
|
if (GPSEncontrado)
|
|
{
|
|
_Porta.Close();
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Erro ao identificar dispositivo proprio: " + ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
_Porta.Close();
|
|
await Task.Delay(100);
|
|
}
|
|
|
|
if (!PortaDispositivoProprio)
|
|
{
|
|
await TentarIdentificarDispositivo(_Porta);
|
|
}
|
|
|
|
}
|
|
|
|
if (Variaveis.IsAgroMonitor)
|
|
{
|
|
return;
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Erro ao realizar varredura de portas: " + ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
VarreduraEmAndamento = false;
|
|
|
|
RealizarVerificacaoDeRotina();
|
|
}
|
|
}
|
|
|
|
private static void RealizarVerificacaoDeRotina()
|
|
{
|
|
FuncoesGlobais.SafeExecuteAsync(async () =>
|
|
{
|
|
try
|
|
{
|
|
await VersionamentoService.AtualizarArquivoVersionamento(false);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"Erro ao atualizar arquivo de versionamento: {ex.Message}");
|
|
}
|
|
}).ConfigureAwait(false);
|
|
|
|
FuncoesGlobais.SafeExecuteAsync(async () =>
|
|
{
|
|
try
|
|
{
|
|
await SyncDataService.SincronizarArquivosComServidor();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"Erro ao sincronizar arquivos com o servidor: {ex.Message}");
|
|
}
|
|
}).ConfigureAwait(false);
|
|
}
|
|
|
|
private static bool ProcessarRespostaDispositivo(SerialPort Porta)
|
|
{
|
|
if (Porta.BytesToRead <= 15 || Porta.BytesToRead >= 30)
|
|
{
|
|
//VerificaRespostaGPS(Porta);
|
|
VerificarRespostaPortasDesconhecidas(Porta);
|
|
return false;
|
|
}
|
|
|
|
string Recebido = ReadLineWithTimeout(Porta, 1000);
|
|
|
|
if (Recebido.Length > 2)
|
|
{
|
|
T_Code Dispositivo = T_Code.Vzo;
|
|
F_Code Verificacao = F_Code.Nda;
|
|
string Versao = "0";
|
|
|
|
var Dados = Recebido.Split(SplitMessage[0]);
|
|
|
|
if (Dados.Length <= 1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
string Mod_ID = Dados[0];
|
|
|
|
int.TryParse(Dados[1], out int check);
|
|
|
|
if (check == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
Verificacao = (F_Code)check;
|
|
|
|
if (Verificacao == F_Code.Msg)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
Dispositivo = (T_Code)(int.Parse(Dados[2]));
|
|
|
|
Versao = Dados[3];
|
|
|
|
if (Dispositivo != T_Code.Vzo && !DispositivosMapeados.Any(x => x.Dispositivo == Dispositivo && x.Mod_ID == Mod_ID))
|
|
{
|
|
DispositivosMapeados.Add(new DispositivoDetalhesModel()
|
|
{
|
|
Endereco = Porta.PortName,
|
|
Dispositivo = Dispositivo,
|
|
Erro = Verificacao == F_Code.Err,
|
|
Versao = Versao,
|
|
Mod_ID = Mod_ID,
|
|
});
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static string ReadLineWithTimeout(SerialPort porta, int timeout)
|
|
{
|
|
CancellationTokenSource cts = new CancellationTokenSource();
|
|
Task<string> task = Task.Run(() => porta.ReadLine(), cts.Token);
|
|
|
|
if (task.Wait(timeout))
|
|
{
|
|
return task.Result;
|
|
}
|
|
else
|
|
{
|
|
cts.Cancel();
|
|
return ""; // ou string.Empty, dependendo de como você deseja lidar com isso
|
|
}
|
|
}
|
|
|
|
public static void AtualizarDispositivos()
|
|
{
|
|
bool PrimeiraExecucao = !Variaveis.DispositivosConectados.Any();
|
|
DispositivosConexaoInicial.ForEach(Dispositivo =>
|
|
{
|
|
IDispositivosService dispositivoService = Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == Dispositivo);
|
|
|
|
if (dispositivoService == null)
|
|
{
|
|
dispositivoService = DispositivosServiceFactory.CreateDispositivoService(
|
|
Dispositivo,
|
|
"Nome: " + Enum.GetName(typeof(T_Code), Dispositivo),
|
|
"Descrição: " + string.Join(", ", DispositivosMapeados.Where(x => x.Dispositivo == Dispositivo).Select(x => x.Mod_ID).ToArray()),
|
|
new SerialPort()
|
|
);
|
|
dispositivoService.CarregarParametrosModulos();
|
|
Task.Run(async () => await dispositivoService.GerenciarMqttTopicos());
|
|
Variaveis.DispositivosConectados.Add(dispositivoService);
|
|
dispositivoService.Dados.IniciarRegistrador();
|
|
}
|
|
});
|
|
if (PrimeiraExecucao)
|
|
{
|
|
OperacaoModel.CarregarParametrosOperacaoPadrao(ModoOperacao.Manual);
|
|
}
|
|
}
|
|
|
|
private static async Task<bool> TentarIdentificarDispositivo(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;
|
|
}
|
|
|
|
AtualizarConsole("Procurando dispositivos Modbus");
|
|
|
|
if (ProcurarPzm)
|
|
{
|
|
AtualizarConsole("Procurando dispositivo PZM");
|
|
bool _encontrado = await PZEMService.VerificaPortaPZEM(ModbusService.Iniciado ? ModbusService._PortaModbus : porta);
|
|
|
|
if (_encontrado && PararAoEncontrar)
|
|
{
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
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 void ProcurarDispositivosUSB()
|
|
{
|
|
if (!Variaveis.IsAgroMonitor)
|
|
{
|
|
if (!KinectService.Iniciado)
|
|
{
|
|
KinectService.InicializarKinect();
|
|
}
|
|
|
|
if (GeneralJoystick.JoystickConectado == null)
|
|
{
|
|
GeneralJoystick.AtualizaDispositivo();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static async Task<bool> ProcurarDispositivosEthernet()
|
|
{
|
|
if (!Variaveis.IsAgroMonitor)
|
|
{
|
|
bool ethernetEncontrado = false;
|
|
|
|
if (WifiService.WifiConectado)
|
|
{
|
|
foreach (T_Code disp in DispositivosProprios)
|
|
{
|
|
bool proprio = await ProcuraDispositivoProprio(disp);
|
|
if (proprio)
|
|
{
|
|
ethernetEncontrado = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool DispBld = await ProcuraDispositivoBLD();
|
|
if (DispBld)
|
|
{
|
|
ethernetEncontrado = true;
|
|
}
|
|
|
|
bool DispMks = await ProcuraDispositivoMKS();
|
|
if (DispMks)
|
|
{
|
|
ethernetEncontrado = true;
|
|
}
|
|
|
|
return ethernetEncontrado;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static async Task<bool> ProcuraDispositivoProprio(T_Code Disp)
|
|
{
|
|
if (!DispositivosMapeados.Any(x => x.Dispositivo == Disp))
|
|
{
|
|
var Modulo = Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == Disp);
|
|
string ProtocoloCheck = Modulo.Dados.ProtocoloVerificacao(true);
|
|
|
|
AtualizarConsole($"Procurando dispositivo {Disp.ToString()}");
|
|
|
|
DateTime MomentoEnvio = DateTime.Now;
|
|
await Modulo.EnviarDadosMQTT(ProtocoloCheck);
|
|
|
|
await Task.Delay(1000);
|
|
|
|
var topicoRx = Modulo.GetMqttTopico(false);
|
|
|
|
var Recebido = topicoRx.Mensagens.FirstOrDefault(x => x.Momento >= MomentoEnvio);
|
|
|
|
if (Recebido != null && Recebido.Mensagem.Length > 2)
|
|
{
|
|
T_Code Dispositivo = T_Code.Vzo;
|
|
F_Code Verificacao = F_Code.Nda;
|
|
string Versao = "0";
|
|
|
|
var Dados = Recebido.Mensagem.Split(SplitMessage[0]);
|
|
|
|
if (Dados.Length <= 1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
string Mod_ID = Dados[0];
|
|
|
|
int.TryParse(Dados[1], out int check);
|
|
|
|
if (check == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
Verificacao = (F_Code)check;
|
|
|
|
if (Verificacao == F_Code.Msg)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
Dispositivo = (T_Code)(int.Parse(Dados[2]));
|
|
|
|
Versao = Dados[3];
|
|
|
|
if (Dispositivo != T_Code.Vzo && !DispositivosMapeados.Any(x => x.Dispositivo == Dispositivo && x.Mod_ID == Mod_ID))
|
|
{
|
|
DispositivosMapeados.Add(new DispositivoDetalhesModel()
|
|
{
|
|
Endereco = Modulo.Dados.GetIP(),
|
|
Dispositivo = Dispositivo,
|
|
Erro = Verificacao == F_Code.Err,
|
|
Versao = Versao,
|
|
Mod_ID = Mod_ID,
|
|
});
|
|
}
|
|
|
|
AtualizarConsole($"Dispositivo {Disp.ToString()} encontrado");
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static async Task<bool> ProcuraDispositivoBLD()
|
|
{
|
|
if (!BLD300RService.Iniciado || BLD300RService.DadosLeitura.Any(x => !x.Iniciado))
|
|
{
|
|
AtualizarConsole("Procurando dispositivos BLD");
|
|
bool Encontrado = await BLD300RService.VerificaPortaBLD();
|
|
if (Encontrado)
|
|
{
|
|
AtualizarConsole("Dispositivo BLD encontrado");
|
|
return Encontrado;
|
|
}
|
|
}
|
|
|
|
return BLD300RService.Iniciado;
|
|
}
|
|
|
|
private static async Task<bool> ProcuraDispositivoMKS()
|
|
{
|
|
if (!MKS057DService.Referenciando && (!MKS057DService.Iniciado || MKS057DService.DadosLeitura.Any(x => !x.Iniciado)))
|
|
{
|
|
AtualizarConsole("Procurando dispositivos MKS");
|
|
bool Encontrado = await MKS057DService.VerificaPortaMKS();
|
|
if (Encontrado)
|
|
{
|
|
AtualizarConsole("Dispositivo MKS encontrado");
|
|
return Encontrado;
|
|
}
|
|
}
|
|
|
|
return MKS057DService.Iniciado;
|
|
}
|
|
|
|
|
|
private static bool VerificaRespostaGPS(SerialPort Porta, string Recebido = null)
|
|
{
|
|
if (string.IsNullOrEmpty(Recebido))
|
|
{
|
|
//Recebido = Porta.ReadLine();
|
|
byte[] buffer = LerDadosDaPortaSerial(Porta, 15);
|
|
Recebido = Encoding.ASCII.GetString(buffer);
|
|
}
|
|
|
|
if (Recebido.Contains("$GPTXT") || Recebido.Contains("$GPRMC") || Recebido.Contains("$GPGGA") || Recebido.Contains("$GPGLL"))
|
|
{
|
|
GPSService.AtualizarPortaCOM(Porta);
|
|
AtualizarConsole("Dispositivo GPS encontrado");
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static byte[] VerificarRespostaPortasDesconhecidas(SerialPort Porta)
|
|
{
|
|
if (Porta != null && Porta.IsOpen)
|
|
{
|
|
int bytesToRead = Porta.BytesToRead;
|
|
byte[] buffer = new byte[bytesToRead];
|
|
Porta.Read(buffer, 0, bytesToRead);
|
|
//Porta.DiscardInBuffer();
|
|
return buffer;
|
|
}
|
|
else
|
|
{
|
|
return new byte[] { };
|
|
}
|
|
}
|
|
|
|
public static byte[] LerDadosDaPortaSerial(SerialPort porta, int tamanhoEsperado, int Timeout = 500)
|
|
{
|
|
DateTime inicio = DateTime.Now;
|
|
List<byte> buffer = new List<byte>();
|
|
while (buffer.Count < tamanhoEsperado && inicio.AddMilliseconds(Timeout) > DateTime.Now)
|
|
{
|
|
if (porta == null)
|
|
{
|
|
break;
|
|
}
|
|
int bytesDisponiveis = porta.BytesToRead;
|
|
if (bytesDisponiveis > 0)
|
|
{
|
|
byte[] tempBuffer = new byte[bytesDisponiveis];
|
|
int bytesLidos = porta.Read(tempBuffer, 0, bytesDisponiveis);
|
|
buffer.AddRange(tempBuffer.Take(bytesLidos));
|
|
}
|
|
}
|
|
return buffer.ToArray();
|
|
}
|
|
|
|
public static async Task<byte[]> LerDadosDaPortaSerialAsync(SerialPort porta, int tamanhoEsperado, int Timeout = 500)
|
|
{
|
|
DateTime inicio = DateTime.Now;
|
|
List<byte> buffer = new List<byte>();
|
|
while (buffer.Count < tamanhoEsperado && inicio.AddMilliseconds(Timeout) > DateTime.Now)
|
|
{
|
|
await Task.Delay(50);
|
|
if (porta == null || !porta.IsOpen)
|
|
{
|
|
break;
|
|
}
|
|
int bytesDisponiveis = porta.BytesToRead;
|
|
if (bytesDisponiveis > 0)
|
|
{
|
|
byte[] tempBuffer = new byte[bytesDisponiveis];
|
|
int bytesLidos = porta.Read(tempBuffer, 0, bytesDisponiveis);
|
|
buffer.AddRange(tempBuffer.Take(bytesLidos));
|
|
}
|
|
}
|
|
return buffer.ToArray();
|
|
}
|
|
|
|
public static async Task AguardaRespostaPorta(SerialPort _Porta, int Timeout)
|
|
{
|
|
DateTime inicio = DateTime.Now;
|
|
while (_Porta.BytesToRead == 0 && DateTime.Now < inicio.AddMilliseconds(Timeout))
|
|
{
|
|
await Task.Delay(50);
|
|
}
|
|
}
|
|
|
|
|
|
private static void AtualizarConsole(string msg)
|
|
{
|
|
Console.WriteLine(msg);
|
|
if (!Variaveis.IsAgroMonitor)
|
|
{
|
|
frmInstancial.frmPrincipal.Invoke((MethodInvoker)(() =>
|
|
{
|
|
frmInstancial.frmPrincipal.lblStatusConexao.Text = msg;
|
|
frmInstancial.frmIHM.lblStatus.Text = msg;
|
|
}));
|
|
}
|
|
}
|
|
|
|
public static void MostrarComandoResposta(T_Code tipo, byte[] comando, byte[] resposta)
|
|
{
|
|
bool showCommands = true;
|
|
if (showCommands)
|
|
{
|
|
Console.WriteLine(tipo.ToString() + " - TX: " + string.Join(" ", comando.Select(x => x.ToString("x"))) + ", RX: " + string.Join(" ", (resposta != null ? resposta : new byte[] { }).Select(x => x.ToString("x"))));
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|