823 lines
39 KiB
C#
823 lines
39 KiB
C#
using AgroBase.Models;
|
|
using AgroBase.Models.Operadores;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using static AgroBase.Models.Enums;
|
|
using static AgroBase.Models.Operadores.OperadoresModels;
|
|
|
|
namespace AgroBase.Services.Operadores
|
|
{
|
|
public class HealthWorkerService : IWorkerModel
|
|
{
|
|
public HealthWorkerModel DadosLeitura = new HealthWorkerModel();
|
|
public SaudeWorkerModel Saude { get; set; } = new SaudeWorkerModel();
|
|
public static List<ManagerWorkerMessageResponseModulosPendentesModel> ModulosSaude = new List<ManagerWorkerMessageResponseModulosPendentesModel>();
|
|
|
|
private bool DebugMode = true;
|
|
private static bool AtualizandoRedis = false;
|
|
|
|
public void MostrarLog(string message, int limite = 500)
|
|
{
|
|
if (DebugMode)
|
|
{
|
|
Console.WriteLine($"[HealthWorker] {message.Substring(0, Math.Min(limite, message.Length))}{(message.Length > limite ? "..." : "")}");
|
|
}
|
|
}
|
|
|
|
public async Task<bool> IniciarProcessamento()
|
|
{
|
|
RedisService.Subscribe(CmdKey.HealthWorkerTx, RedisCallback);
|
|
|
|
DadosLeitura.IniciadoEm = DateTime.Now;
|
|
DadosLeitura.Iniciado = true;
|
|
|
|
bool pronto() => DadosLeitura.Pronto;
|
|
await FuncoesGlobais.AguardarCondicaoAsync(pronto, 5000);
|
|
if (pronto())
|
|
{
|
|
MostrarLog("Processamento iniciado com sucesso");
|
|
return true;
|
|
}
|
|
|
|
MostrarLog("Timeout ao iniciar script");
|
|
DadosLeitura.ReiniciarEstado();
|
|
return false;
|
|
}
|
|
|
|
public void RedisCallback(string mensagem)
|
|
{
|
|
try
|
|
{
|
|
var comando = JsonConvert.DeserializeObject<ComandoRedis>(mensagem);
|
|
|
|
var cmd = (HealthWorkerCommandType)comando.cmd;
|
|
|
|
//MostrarLog($"Comando recebido: cmd = {cmd.ToString()}");
|
|
|
|
switch (cmd)
|
|
{
|
|
case HealthWorkerCommandType.ScriptCarregado:
|
|
DadosLeitura.Pronto = true;
|
|
DadosLeitura.ProntoEm = DateTime.Now;
|
|
MostrarLog($"Comando recebido: cmd = {cmd.ToString()}");
|
|
break;
|
|
|
|
default:
|
|
MostrarLog($"Comando não reconhecido: {comando.cmd}");
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MostrarLog($"Erro ao deserializar resposta: {ex.Message}");
|
|
}
|
|
finally
|
|
{
|
|
DadosLeitura.UltimaMensagem = DateTime.Now;
|
|
}
|
|
}
|
|
|
|
public void AtualizarSaude()
|
|
{
|
|
Saude = OperadoresModels.AtualizarSaude(CtxKey.DadosHealthWorker);
|
|
}
|
|
|
|
|
|
private static void AtualizarDadosContextoLocal()
|
|
{
|
|
RedisService.AtualizarCampos(
|
|
CtxKey.DadosOperacao,
|
|
("debug_mode", Variaveis.DebugMode),
|
|
("iniciado", Variaveis.OperacaoEmAndamento.Iniciado),
|
|
("finalizando", Variaveis.OperacaoEmAndamento.Finalizando),
|
|
("calibrando", Variaveis.OperacaoEmAndamento.Calibrando),
|
|
("emergencia", Variaveis.OperacaoEmAndamento.Emergencia),
|
|
("pausa", Variaveis.OperacaoEmAndamento.Pausa)
|
|
);
|
|
}
|
|
|
|
public static void AtualizarDadosContexto()
|
|
{
|
|
if (AtualizandoRedis)
|
|
return;
|
|
AtualizandoRedis = true;
|
|
|
|
AtualizarDadosContextoLocal();
|
|
AtualizarDadosModulos();
|
|
AtualizarDadosControleOperacao();
|
|
|
|
var _Sensoriamento = Variaveis.OperacaoEmAndamento.Sensoriamento;
|
|
|
|
if (_Sensoriamento == null)
|
|
{
|
|
AtualizandoRedis = false;
|
|
return;
|
|
}
|
|
|
|
var _t = _Sensoriamento.Trajetoria;
|
|
PontoTrajetoriaModel pontoComparar = _t != null ? (_t.PontoAtual.Aproximando ? _t.PontoAtual : _t.ProximoPonto != null ? _t.ProximoPonto : _t.PontoAtual) : null;
|
|
int idx_p_alvo = _t != null ?
|
|
(pontoComparar.DistanciaAtual > 1.0 ? pontoComparar.idxPonto :
|
|
pontoComparar.idxPonto < _t.QtdPontos - 1 ? pontoComparar.idxPonto + 1 :
|
|
pontoComparar.idxPonto) : 0;
|
|
RedisService.AtualizarCampos(
|
|
CtxKey.DadosContexto,
|
|
("Trajetoria", _t != null ? new
|
|
{
|
|
status = (int)_t.StatusCarro,
|
|
concluido = _t.TrajetoriaConcluida,
|
|
manobrando = _t.ManobrandoEntreRuas,
|
|
erro_angular = _t.ErroOrientacaoAngularCombinado,
|
|
erro_angular_caminho = _t.ErroOrientacaoAngularCaminho,
|
|
erro_angular_proximo_ponto = _t.ErroOrientacaoAngularProximoPonto,
|
|
idx_proximo_ponto = _t.ProximoPonto.idxPonto,
|
|
idx_ponto_alvo = idx_p_alvo,
|
|
CorredorAtual = new
|
|
{
|
|
concluido = _t.CorredorAtual.Concluido,
|
|
dentro = _t.CorredorAtual.Dentro,
|
|
ultimo = _t.CorredorAtual.Ultimo,
|
|
largura = _t.CorredorAtual.Largura,
|
|
progresso = _t.CorredorAtual.Progresso,
|
|
dist_esq = _t.DistanciaEsquerda,
|
|
dist_dir = _t.DistanciaDireita,
|
|
angulo = _t.AnguloMedioCorredor,
|
|
pontos_restantes = _t.CorredorAtual.QtdPontos - pontoComparar.idxPontoCorredor,
|
|
liberado = _t.AutonomiaCooredor?.Liberado ?? false,
|
|
motivo = _t.AutonomiaCooredor?.Motivo ?? "",
|
|
bateria_ok = _t.AutonomiaCooredor?.BateriaSuficiente ?? false,
|
|
herbicida_ok = _t.AutonomiaCooredor?.HerbicidaSuficiente ?? false
|
|
},
|
|
} : null
|
|
),
|
|
("Gerais", new
|
|
{
|
|
velocidade_ms = Variaveis.OperacaoEmAndamento.Simulando ? FuncoesMatematicas.CalculaVelocidadeMsPercentual(Variaveis.OperacaoEmAndamento.Controle.RPM_SP) : _Sensoriamento.Movimentacao?.VelocidadeMedia ?? 0,
|
|
ervas_no_radar = _Sensoriamento.Atuador?.ErvasNoRadar ?? false,
|
|
percentual_ervas_no_radar = _Sensoriamento.Atuador?.PercentualErvasNoRadar ?? 0,
|
|
percentual_reservatorio = _Sensoriamento.Atuador?.PercentualReservatorio ?? 0,
|
|
percentual_bateria = _Sensoriamento.Bateria?.PercentualBateria ?? 0,
|
|
}
|
|
)
|
|
);
|
|
|
|
AtualizandoRedis = false;
|
|
}
|
|
|
|
private static void AtualizarDadosEquipamento()
|
|
{
|
|
RedisService.AtualizarCampos(
|
|
CtxKey.DadosEquipamento,
|
|
("base_ip", VariaveisEquipamento.Parametros.base_ip),
|
|
("base_porta_caminho", VariaveisEquipamento.Parametros.base_porta_caminho),
|
|
("base_porta_ervas", VariaveisEquipamento.Parametros.base_porta_ervas),
|
|
("serial_number", VariaveisEquipamento.Parametros.serial_number),
|
|
("largura", VariaveisEquipamento.LarguraEquipamentoMm / 1000.0),
|
|
("distancia_entre_eixos", VariaveisEquipamento.DistanciaEntreEixos / 100.0),
|
|
("qtd_bicos", VariaveisEquipamento.QuantidadeBicosPulverizadores),
|
|
("percentual_reservatorio_min", VariaveisEquipamento.PercentualReservatorioMin),
|
|
("percentual_tensao_bateria_min", VariaveisEquipamento.PercentualTensaoBateriaMin),
|
|
("camera_caminho_id", Variaveis.OperacaoEmAndamento.DispSen?.Dados?.CameraCaminho?.Id ?? ""),
|
|
("camera_solo_id", Variaveis.OperacaoEmAndamento.DispSen?.Dados?.CamerasSolo?.FirstOrDefault()?.Id ?? ""),
|
|
("path_ia_model_ruas_seg", VersionamentoService.ArquivoModeloSegStreetDetector.CaminhoCompleto),
|
|
("path_ia_labelmap_ruas_seg", VersionamentoService.ArquivoLabelmapSegStreetDetector.CaminhoCompleto),
|
|
("ia_backbone_ruas_seg", "nvidia/segformer-b0-finetuned-ade-512-512"),
|
|
("path_ia_model_ruas_det", VersionamentoService.ArquivoModeloDetStreetDetector.CaminhoCompleto),
|
|
("path_ia_model_ervas", VersionamentoService.ArquivoModeloWeedDetector.CaminhoCompleto),
|
|
("path_ia_labelmap_ervas", VersionamentoService.ArquivoModeloLabelmapWeedDetector.CaminhoCompleto),
|
|
("path_ia_norm_stats_ervas", VersionamentoService.ArquivoModeloNormstatsWeedDetector.CaminhoCompleto),
|
|
("ia_backbone_ervas", "nvidia/segformer-b1-finetuned-ade-512-512"),
|
|
("angulo_roll_max", VariaveisEquipamento.AnguloInclinacaoRollMax),
|
|
("angulo_pitch_max", VariaveisEquipamento.AnguloInclinacaoPitchMax)
|
|
);
|
|
}
|
|
|
|
public static void AtualizarDadosOperacao()
|
|
{
|
|
if (AtualizandoRedis)
|
|
return;
|
|
AtualizandoRedis = true;
|
|
|
|
AtualizarDadosEquipamento();
|
|
|
|
if (Variaveis.OperacaoEmAndamento.DispMvd == null)
|
|
{
|
|
AtualizandoRedis = false;
|
|
return;
|
|
}
|
|
|
|
var _Parametros = Variaveis.OperacaoEmAndamento.Parametros;
|
|
var pControle = _Parametros.Controle;
|
|
var _Controle = Variaveis.OperacaoEmAndamento.Controle;
|
|
|
|
RedisService.AtualizarCampos(
|
|
CtxKey.DadosOperacao,
|
|
("configurado", true),
|
|
("modo", Variaveis.OperacaoEmAndamento.Modo),
|
|
("tempo_aguardar_inicio_operacao", Variaveis.OperacaoEmAndamento.TempoIniciarOperacao),
|
|
("modulos_mandatorios", _Parametros.ModulosMandatorios.Where(x => x.Mandatorio && x.Utilizar).Select(x => (int)x.Dispositivo).ToArray()),
|
|
("modulos_opcionais", _Parametros.ModulosMandatorios.Where(x => !x.Mandatorio && x.Utilizar).Select(x => (int)x.Dispositivo).ToArray()),
|
|
("parametros_mandatorios", _Parametros.ParametrosMandatorios.Where(x => x.Mandatorio && x.Utilizar).Select(x => (int)x.Parametro).ToArray()),
|
|
("Mov", new
|
|
{
|
|
percent_vel_max = pControle.MovVelocidadeSErvasPercent,
|
|
percent_vel_min = pControle.MovVelocidadeCErvasPercent,
|
|
}
|
|
),
|
|
("Dir", new
|
|
{
|
|
angulo_max = pControle.DirAnguloMaximo,
|
|
vel_movimento = pControle.DirVelocidadeMovimento,
|
|
tipo_controle = (int)pControle.DirTipoMovimento,
|
|
mpc = new
|
|
{
|
|
pontos = Variaveis.OperacaoEmAndamento.Trajetoria?._TrajetoriaFixa?
|
|
.Select(p => new
|
|
{
|
|
lat = p.Posicao.Latitude,
|
|
lon = p.Posicao.Longitude,
|
|
tipo = (int)p.Tipo,
|
|
distanciaMargem = p.LarguraCorredor * 0.8
|
|
})
|
|
.ToList(),
|
|
horizonte = 2.0,
|
|
horizonte_min = 1.2,
|
|
horizonte_max = 2.8,
|
|
horizonte_parado = 1.2,
|
|
angulo_max_graus = pControle.DirAnguloMaximo,
|
|
velocidade_min = FuncoesMatematicas.CalculaVelocidadeMsPercentual(pControle.MovVelocidadeCErvasPercent),
|
|
velocidade_max = FuncoesMatematicas.CalculaVelocidadeMsPercentual(pControle.MovVelocidadeSErvasPercent),
|
|
tempo_entre_comandos = (Variaveis.OperacaoEmAndamento.Controle.TiposControle.FirstOrDefault(x => x.Tipo == Enums.T_Code.Dir)?.DelayEnvioComando ?? 500) / 1000.0,
|
|
passos_atraso = 1
|
|
}
|
|
}
|
|
),
|
|
("Atu", new
|
|
{
|
|
qtd_bicos = _Parametros.QtdBicos,
|
|
tempo_atuacao = pControle.AtuDuracaoAtuacao,
|
|
capacidade_reservatorio = _Parametros.CapacidadeReservatorio,
|
|
pressao_linha = pControle.AtuPressaoLinha,
|
|
percent_vertical_deteccao = pControle.AtuPercentualInicioPulverizacao / 100.0,
|
|
height_area_deteccao = pControle.AtuAlturaAreaPulverizacao / 100.0,
|
|
pct_erva_bico_on = pControle.AtuPercentualErvasBicoOn / 100.0,
|
|
pct_erva_bico_off = pControle.AtuPercentualErvasBicoOff / 100.0
|
|
}
|
|
),
|
|
("Snr", new
|
|
{
|
|
percentual_altura_solo = Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraCaminho.PercentualAlturaSolo,
|
|
distancia_maxima = Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraCaminho.DistanciaMaximaVisao,
|
|
distancia_minima = Variaveis.OperacaoEmAndamento.DispSen.Dados.CameraCaminho.DistanciaMinimaVisao
|
|
}
|
|
)
|
|
);
|
|
|
|
if (Variaveis.OperacaoEmAndamento.Modo == Enums.ModoOperacao.MapaGPS && (Variaveis.OperacaoEmAndamento.Trajetoria?._TrajetoriaFixa?.Count() ?? 0) > 0)
|
|
{
|
|
var comando = new
|
|
{
|
|
cmd = HealthWorkerCommandType.AtualizarPontosMapa
|
|
};
|
|
RedisService.Publish(CmdKey.HealthWorkerRx, JsonConvert.SerializeObject(comando));
|
|
}
|
|
|
|
AtualizandoRedis = false;
|
|
}
|
|
|
|
public static void AtualizarDadosControleOperacao()
|
|
{
|
|
var pControle = Variaveis.OperacaoEmAndamento.Parametros.Controle;
|
|
RedisService.AtualizarCampos(
|
|
CtxKey.DadosControle,
|
|
("pulverizador_automatico", pControle.PulverizadorAutomatico),
|
|
("movimento_automatico", pControle.MovimentoAutomatico),
|
|
("direcional_automatico", pControle.DirecionalAutomatico),
|
|
("frenagem_automatica", pControle.FrenagemAutomaticaAoParar),
|
|
("oak_parada_por_bloqueio", pControle.OakParadaPorObstaculo),
|
|
("imu_parada_por_inclinacao", pControle.ImuParadaPorInclinacao)
|
|
);
|
|
}
|
|
|
|
private static void AtualizarDadosModulos()
|
|
{
|
|
if (Variaveis.OperacaoEmAndamento.DispMvd == null) return;
|
|
if (Variaveis.OperacaoEmAndamento.DispAtu == null) return;
|
|
if (Variaveis.OperacaoEmAndamento.DispSen == null) return;
|
|
|
|
var _Sensoriamento = Variaveis.OperacaoEmAndamento.Sensoriamento;
|
|
var agora = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
|
|
|
|
//Console.WriteLine(RedisService.Get(RedisService.ModKey(Enums.T_Code.Gps)));
|
|
//Console.WriteLine(RedisService.Get(RedisService.ModKey(Enums.T_Code.Dir)));
|
|
//Console.WriteLine(RedisService.Get(RedisService.ModKey(Enums.T_Code.Mov)));
|
|
//Console.WriteLine(RedisService.Get(RedisService.ModKey(Enums.T_Code.Sen)));
|
|
|
|
//RedisService.SetObject(RedisService.ModKey(Enums.T_Code.Gps), string.Empty);
|
|
//RedisService.SetObject(RedisService.ModKey(Enums.T_Code.Dir), string.Empty);
|
|
//RedisService.SetObject(RedisService.ModKey(Enums.T_Code.Mov), string.Empty);
|
|
//RedisService.SetObject(RedisService.ModKey(Enums.T_Code.Sen), string.Empty);
|
|
|
|
var dirAtivos = new List<int>();
|
|
var movAtivos = new List<int>();
|
|
foreach (var mod in Variaveis.OperacaoEmAndamento.DispMvd.Dados.Modulos)
|
|
{
|
|
int endereco_dir = mod.DirMotor._EnderecoCAN_Tx;
|
|
RedisService.AtualizarCampos(
|
|
RedisService.ModKey(Enums.T_Code.Dir),
|
|
($"{endereco_dir}.timestamp", agora),
|
|
($"{endereco_dir}.conectado", mod.DirMotor.Inicializado),
|
|
($"{endereco_dir}.freq_base", Variaveis.OperacaoEmAndamento.DispMvd.Dados.tmrRegistradorDIR.IntervalHz),
|
|
($"{endereco_dir}.endereco", mod.DirMotor._EnderecoCAN_Tx),
|
|
($"{endereco_dir}.mod_id", mod.Modulo_ID),
|
|
($"{endereco_dir}.angulo", mod.DirMotor.AnguloLeitura),
|
|
($"{endereco_dir}.angulo_sp", mod.DirMotor.Angulo_SP),
|
|
($"{endereco_dir}.comandar", mod.DirMotor.Comandar),
|
|
($"{endereco_dir}.referenciado", mod.DirMotor.Referenciado),
|
|
($"{endereco_dir}.in1_atuado", mod.DirMotor.IN1_Atuado),
|
|
($"{endereco_dir}.sentido", mod.DirMotor.Sentido),
|
|
($"{endereco_dir}.sentido_sp", mod.DirMotor.Sentido_SP),
|
|
($"{endereco_dir}.sentido_real", mod.DirMotor.SentidoReal),
|
|
($"{endereco_dir}.freq.pulsos", mod.DirMotor.Leitura?.NumeroPulsos?.frequencia ?? 0),
|
|
($"{endereco_dir}.freq.io", mod.DirMotor.Leitura?.EntradaIN1?.frequencia ?? 0)
|
|
);
|
|
|
|
int endereco_mov = mod.MovMotor._EnderecoCAN_Tx;
|
|
RedisService.AtualizarCampos(
|
|
RedisService.ModKey(Enums.T_Code.Mov),
|
|
($"{endereco_mov}.timestamp", agora),
|
|
($"{endereco_mov}.conectado", mod.MovMotor.Inicializado),
|
|
($"{endereco_mov}.freq_base", Variaveis.OperacaoEmAndamento.DispMvd.Dados.tmrRegistradorMOV.IntervalHz),
|
|
($"{endereco_mov}.endereco", mod.MovMotor._EnderecoCAN_Tx),
|
|
($"{endereco_mov}.mod_id", mod.Modulo_ID),
|
|
($"{endereco_mov}.cod_erro", mod.MovMotor.CodigoAlarme),
|
|
($"{endereco_mov}.rpm", mod.MovMotor.RPM_Roda),
|
|
($"{endereco_mov}.rpm_sp", mod.MovMotor.RPM_SP_Leitura),
|
|
($"{endereco_mov}.tensao", mod.MovMotor.Tensao),
|
|
($"{endereco_mov}.corrente_motor", mod.MovMotor.Corrente_Motor),
|
|
($"{endereco_mov}.corrente_barramento", mod.MovMotor.Corrente_Barramento),
|
|
($"{endereco_mov}.temperatura_driver", mod.MovMotor.TemperaturaDriver),
|
|
($"{endereco_mov}.temperatura_motor", mod.MovMotor.Temperatura),
|
|
($"{endereco_mov}.freado", mod.MovMotor.Leitura?.Freado ?? false),
|
|
($"{endereco_mov}.freq.erro", mod.MovMotor.Leitura?.CodigoAlarme?.frequencia ?? 0),
|
|
($"{endereco_mov}.freq.rpm", mod.MovMotor.Leitura?.ERPM?.frequencia ?? 0),
|
|
($"{endereco_mov}.freq.tensao", mod.MovMotor.Leitura?.Tensao?.frequencia ?? 0),
|
|
($"{endereco_mov}.freq.corrente_motor", mod.MovMotor.Leitura?.CorrenteMotor?.frequencia ?? 0),
|
|
($"{endereco_mov}.freq.corrente_barramento", mod.MovMotor.Leitura?.CorrenteBarramento?.frequencia ?? 0),
|
|
($"{endereco_mov}.freq.temperatura", mod.MovMotor.Leitura?.Temperatura?.frequencia ?? 0)
|
|
);
|
|
|
|
dirAtivos.Add(endereco_dir);
|
|
movAtivos.Add(endereco_mov);
|
|
}
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Dir), ($"ativos", dirAtivos.ToList()));
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Mov), ($"ativos", movAtivos.ToList()));
|
|
|
|
var DadosSen = Variaveis.OperacaoEmAndamento.DispSen.Dados;
|
|
//Console.WriteLine("[HEALTH SEN] " + DadosSen.Conectado);
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Sen),
|
|
("timestamp", agora),
|
|
("conectado", DadosSen.Conectado),
|
|
("freq_base", DadosSen.FrequenciaBase)
|
|
);
|
|
var senSensoresAtualizados = new List<(string caminho, object valor)>();
|
|
var senSensoresAtivos = new List<string>();
|
|
foreach (var sensor in DadosSen.Sensores)
|
|
{
|
|
int tipo = (int)sensor.Componente;
|
|
int id = sensor.ID_Num;
|
|
string basePath = $"sensores.{tipo}.{id}";
|
|
|
|
var saude = RedisService.GetField<object>(RedisService.ModKey(Enums.T_Code.Sen), $"{basePath}.saude");
|
|
|
|
var dados = sensor.ValoresLeituras
|
|
.Where(y => y.analise_health)
|
|
.Select(y => new
|
|
{
|
|
label = y.funcao.ToString(),
|
|
nominal = y.nominal,
|
|
maximo = y.maximo,
|
|
minimo = y.minimo,
|
|
atual = y.atual.valor,
|
|
freq = y.atual.frequencia
|
|
})
|
|
.ToList();
|
|
|
|
var sensorObj = new
|
|
{
|
|
conectado = sensor.Inicializado,
|
|
id,
|
|
label = sensor.ID,
|
|
tipo,
|
|
aferir = sensor.Aferir,
|
|
mandatorio = sensor.Mandatorio,
|
|
dados,
|
|
timestamp = agora,
|
|
saude = saude ?? new { }
|
|
};
|
|
|
|
senSensoresAtivos.Add($"{tipo}.{id}");
|
|
senSensoresAtualizados.Add(($"{basePath}", sensorObj));
|
|
}
|
|
senSensoresAtualizados.Add(("sensores.ativos", senSensoresAtivos));
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Sen), senSensoresAtualizados.ToArray());
|
|
|
|
var senServosAtualizados = new List<(string caminho, object valor)>();
|
|
var senServosAtivos = new List<string>();
|
|
foreach (var servo in DadosSen.Servos)
|
|
{
|
|
int tipo = (int)servo.Componente;
|
|
int id = servo.ID_Num;
|
|
string basePath = $"servos.{tipo}.{id}";
|
|
|
|
var saude = RedisService.GetField<object>(RedisService.ModKey(Enums.T_Code.Sen), $"{basePath}.saude");
|
|
|
|
var dados = servo.ValoresLeituras
|
|
.Where(y => y.analise_health)
|
|
.Select(y => new
|
|
{
|
|
label = y.funcao.ToString(),
|
|
atual = y.atual.valor,
|
|
freq = y.atual.frequencia
|
|
})
|
|
.ToList();
|
|
|
|
var servoObj = new
|
|
{
|
|
conectado = servo.Inicializado,
|
|
id,
|
|
label = servo.ID,
|
|
tipo,
|
|
controlar = servo.Controlar,
|
|
mandatorio = servo.Mandatorio,
|
|
angulo_sp = servo._AnguloControle,
|
|
dados,
|
|
timestamp = agora,
|
|
saude = saude ?? new { }
|
|
};
|
|
|
|
senServosAtivos.Add($"{tipo}.{id}");
|
|
senServosAtualizados.Add(($"{basePath}", servoObj));
|
|
}
|
|
senServosAtualizados.Add(("servos.ativos", senServosAtivos));
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Sen), senServosAtualizados.ToArray());
|
|
|
|
var senRelesAtualizados = new List<(string caminho, object valor)>();
|
|
var senRelesAtivos = new List<string>();
|
|
foreach (var rele in DadosSen.Reles)
|
|
{
|
|
int tipo = (int)rele.Componente;
|
|
int id = rele.ID_Num;
|
|
string basePath = $"reles.{tipo}.{id}";
|
|
|
|
var saude = RedisService.GetField<object>(RedisService.ModKey(Enums.T_Code.Sen), $"{basePath}.saude");
|
|
|
|
var dados = rele.ValoresLeituras
|
|
.Where(y => y.analise_health)
|
|
.Select(y => new
|
|
{
|
|
label = y.funcao.ToString(),
|
|
atual = y.atual.valor,
|
|
freq = y.atual.frequencia
|
|
})
|
|
.ToList();
|
|
|
|
var releObj = new
|
|
{
|
|
conectado = rele.Inicializado,
|
|
id,
|
|
label = rele.ID,
|
|
tipo,
|
|
controlar = rele.Controlar,
|
|
mandatorio = rele.Mandatorio,
|
|
dados,
|
|
timestamp = agora,
|
|
saude = saude ?? new { }
|
|
};
|
|
|
|
senRelesAtivos.Add($"{tipo}.{id}");
|
|
senRelesAtualizados.Add(($"{basePath}", releObj));
|
|
}
|
|
senRelesAtualizados.Add(("reles.ativos", senRelesAtivos));
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Sen), senRelesAtualizados.ToArray());
|
|
|
|
var senLedsAtualizados = new List<(string caminho, object valor)>();
|
|
var senLedsAtivos = new List<string>();
|
|
foreach (var led in DadosSen.Sinaleiros)
|
|
{
|
|
int tipo = (int)led.Componente;
|
|
int id = led.ID_Num;
|
|
string basePath = $"sinaleiros.{tipo}.{id}";
|
|
|
|
var saude = RedisService.GetField<object>(RedisService.ModKey(Enums.T_Code.Sen), $"{basePath}.saude");
|
|
|
|
var dados = led.ValoresLeituras
|
|
.Where(y => y.analise_health)
|
|
.Select(y => new
|
|
{
|
|
label = y.funcao.ToString(),
|
|
atual = y.atual.valor,
|
|
freq = y.atual.frequencia
|
|
})
|
|
.ToList();
|
|
|
|
var ledObj = new
|
|
{
|
|
conectado = led.Inicializado,
|
|
id,
|
|
label = led.ID,
|
|
tipo,
|
|
controlar = led.Controlar,
|
|
mandatorio = led.Mandatorio,
|
|
dados,
|
|
timestamp = agora,
|
|
saude = saude ?? new { }
|
|
};
|
|
|
|
senLedsAtivos.Add($"{tipo}.{id}");
|
|
senLedsAtualizados.Add(($"{basePath}", ledObj));
|
|
}
|
|
senLedsAtualizados.Add(("sinaleiros.ativos", senLedsAtivos));
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Sen), senLedsAtualizados.ToArray());
|
|
|
|
|
|
var DadosAtu = Variaveis.OperacaoEmAndamento.DispAtu.Dados;
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Atu),
|
|
("timestamp", agora),
|
|
("conectado", DadosAtu.Conectado),
|
|
("freq_base", DadosAtu.FrequenciaBase)
|
|
);
|
|
var atuSensoresAtualizados = new List<(string caminho, object valor)>();
|
|
var atuSensoresAtivos = new List<string>();
|
|
foreach (var sensor in DadosAtu.Sensores)
|
|
{
|
|
int tipo = (int)sensor.Componente;
|
|
int id = sensor.ID_Num;
|
|
string basePath = $"sensores.{tipo}.{id}";
|
|
|
|
var saude = RedisService.GetField<object>(RedisService.ModKey(Enums.T_Code.Atu), $"{basePath}.saude");
|
|
|
|
var dados = sensor.ValoresLeituras
|
|
.Where(y => y.analise_health)
|
|
.Select(y => new
|
|
{
|
|
label = y.funcao.ToString(),
|
|
nominal = y.nominal,
|
|
maximo = y.maximo,
|
|
minimo = y.minimo,
|
|
atual = y.atual.valor,
|
|
freq = y.atual.frequencia
|
|
})
|
|
.ToList();
|
|
|
|
var sensorObj = new
|
|
{
|
|
conectado = sensor.Inicializado,
|
|
id,
|
|
label = sensor.ID,
|
|
tipo,
|
|
aferir = sensor.Aferir,
|
|
mandatorio = sensor.Mandatorio,
|
|
dados,
|
|
timestamp = agora,
|
|
saude = saude ?? new { }
|
|
};
|
|
|
|
atuSensoresAtivos.Add($"{tipo}.{id}");
|
|
atuSensoresAtualizados.Add(($"{basePath}", sensorObj));
|
|
}
|
|
atuSensoresAtualizados.Add(("sensores.ativos", atuSensoresAtivos));
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Atu), atuSensoresAtualizados.ToArray());
|
|
|
|
var atuBicosAtualizados = new List<(string caminho, object valor)>();
|
|
var atuBicosAtivos = new List<string>();
|
|
foreach (var bico in DadosAtu.BicosPulverizadores)
|
|
{
|
|
int tipo = (int)bico.Componente;
|
|
int id = bico.ID_Num;
|
|
string basePath = $"bicos.{tipo}.{id}";
|
|
|
|
var saude = RedisService.GetField<object>(RedisService.ModKey(Enums.T_Code.Atu), $"{basePath}.saude");
|
|
|
|
var dados = bico.ValoresLeituras
|
|
.Where(y => y.analise_health)
|
|
.Select(y => new
|
|
{
|
|
label = y.funcao.ToString(),
|
|
nominal = y.nominal,
|
|
maximo = y.maximo,
|
|
minimo = y.minimo,
|
|
atual = y.atual.valor,
|
|
freq = y.atual.frequencia
|
|
})
|
|
.ToList();
|
|
|
|
var bicoObj = new
|
|
{
|
|
conectado = bico.Inicializado,
|
|
id,
|
|
label = bico.ID,
|
|
tipo,
|
|
comandar = bico.Comandar,
|
|
mandatorio = bico.Mandatorio,
|
|
dados,
|
|
timestamp = agora,
|
|
saude = saude ?? new { }
|
|
};
|
|
|
|
atuBicosAtualizados.Add(($"{basePath}", bicoObj));
|
|
atuBicosAtivos.Add($"{tipo}.{id}");
|
|
}
|
|
atuBicosAtualizados.Add(("bicos.ativos", atuBicosAtivos));
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Atu), atuBicosAtualizados.ToArray());
|
|
|
|
var atuBombasAtualizados = new List<(string caminho, object valor)>();
|
|
var atuBombasAtivos = new List<string>();
|
|
foreach (var bomba in DadosAtu.BombasPressurizadoras)
|
|
{
|
|
int tipo = (int)bomba.Componente;
|
|
int id = bomba.ID_Num;
|
|
string basePath = $"bombas.{tipo}.{id}";
|
|
|
|
var saude = RedisService.GetField<object>(RedisService.ModKey(Enums.T_Code.Atu), $"{basePath}.saude");
|
|
|
|
var dados = bomba.ValoresLeituras
|
|
.Where(y => y.analise_health)
|
|
.Select(y => new
|
|
{
|
|
label = y.funcao.ToString(),
|
|
nominal = y.nominal,
|
|
maximo = y.maximo,
|
|
minimo = y.minimo,
|
|
atual = y.atual.valor,
|
|
freq = y.atual.frequencia
|
|
})
|
|
.ToList();
|
|
|
|
var sensorObj = new
|
|
{
|
|
conectado = bomba.Inicializado,
|
|
id,
|
|
label = bomba.ID,
|
|
tipo,
|
|
comandar = bomba.Comandar,
|
|
mandatorio = bomba.Mandatorio,
|
|
dados,
|
|
timestamp = agora,
|
|
saude = saude ?? new { }
|
|
};
|
|
|
|
atuBombasAtivos.Add($"{tipo}.{id}");
|
|
atuBombasAtualizados.Add(($"{basePath}", sensorObj));
|
|
}
|
|
atuBombasAtualizados.Add(("bombas.ativos", atuBombasAtivos));
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Atu), atuBombasAtualizados.ToArray());
|
|
|
|
var atuServosAtualizados = new List<(string caminho, object valor)>();
|
|
var atuServosAtivos = new List<string>();
|
|
foreach (var servo in DadosAtu.Servos)
|
|
{
|
|
int tipo = (int)servo.Componente;
|
|
int id = servo.ID_Num;
|
|
string basePath = $"servos.{tipo}.{id}";
|
|
|
|
var saude = RedisService.GetField<object>(RedisService.ModKey(Enums.T_Code.Atu), $"{basePath}.saude");
|
|
|
|
var dados = servo.ValoresLeituras
|
|
.Where(y => y.analise_health)
|
|
.Select(y => new
|
|
{
|
|
label = y.funcao.ToString(),
|
|
atual = y.atual.valor,
|
|
freq = y.atual.frequencia
|
|
})
|
|
.ToList();
|
|
|
|
var servoObj = new
|
|
{
|
|
conectado = servo.Inicializado,
|
|
id,
|
|
label = servo.ID,
|
|
tipo,
|
|
controlar = servo.Controlar,
|
|
mandatorio = servo.Mandatorio,
|
|
angulo_sp = servo._AnguloControle,
|
|
dados,
|
|
timestamp = agora,
|
|
saude = saude ?? new { }
|
|
};
|
|
|
|
atuServosAtivos.Add($"{tipo}.{id}");
|
|
atuServosAtualizados.Add(($"{basePath}", servoObj));
|
|
}
|
|
atuServosAtualizados.Add(("servos.ativos", atuServosAtivos));
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Atu), atuServosAtualizados.ToArray());
|
|
|
|
|
|
var DadosLra = Variaveis.LoraService;
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Lra),
|
|
("timestamp", agora),
|
|
("conectado", DadosLra.Conectado),
|
|
("configurado", DadosLra.Configurado),
|
|
("tempo_base_tx", DadosLra.TempoEnvioDadosBase / 1000.0),
|
|
("tempo_base_rx", VariaveisEquipamento.TempoEntrePingsConexao / 1000.0),
|
|
("last_tx", DadosLra.UltimoTxDados),
|
|
("last_rx", DadosLra.UltimoRxDados)
|
|
);
|
|
|
|
var DadosMod = _Sensoriamento.DadosPerformance;
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Npc),
|
|
("timestamp", agora),
|
|
("freq_base", 1.0 / Variaveis.OperacaoEmAndamento.tmrLeiturasInterval),
|
|
("cpu_load", DadosMod.CPU_load ?? 0),
|
|
("gpu_load", DadosMod.GPU_load ?? 0),
|
|
("hdd_load", DadosMod.HDD_load ?? 0),
|
|
("ram_usage", DadosMod.RAM_usage ?? 0),
|
|
("cpu_temp", DadosMod.CPU_temp ?? 0),
|
|
("gpu_temp", DadosMod.GPU_temp ?? 0)
|
|
);
|
|
|
|
var DadosCan = CanManager.CanService;
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Can),
|
|
("timestamp", agora),
|
|
("conectado", DadosCan.Iniciado),
|
|
("iniciado", DadosCan.IsConnected),
|
|
("executando", SerialService.DispositivosMapeados.Any(x => SerialService.DispositivosCan.Contains(x.Dispositivo))),
|
|
("erros_criticos", DadosCan.ErrosCriticos),
|
|
("freq_tx", DadosCan.FreqTx),
|
|
("freq_rx", DadosCan.FreqRx),
|
|
("last_tx", DadosCan.UltimoTx),
|
|
("last_rx", DadosCan.UltimoRx),
|
|
("last_ec", DadosCan.UltimoErroCritico)
|
|
);
|
|
|
|
double MinOrDefault(List<double> items)
|
|
{
|
|
if (items.Count == 0) return 0;
|
|
return items.Min();
|
|
}
|
|
|
|
double MaxOrDefault(List<double> items)
|
|
{
|
|
if (items.Count == 0) return 0;
|
|
return items.Max();
|
|
}
|
|
|
|
var DadosBateria = DalyBMSService.DadosLeitura;
|
|
RedisService.AtualizarCampos(
|
|
RedisService.ModKey(T_Code.Bat), // ajusta o T_Code se o seu enum tiver outro nome
|
|
("timestamp", agora),
|
|
("iniciado", DadosBateria.Iniciado),
|
|
("momento_bms", DadosBateria.Momento),
|
|
// Dados principais do pack
|
|
("tensao_total_v", DadosBateria.Pack.TensaoTotal_V),
|
|
("tensao_medida_v", DadosBateria.Pack.TensaoMedida_V),
|
|
("corrente_a", DadosBateria.Pack.Corrente_A),
|
|
("soc_pct", DadosBateria.Pack.SOC_percent),
|
|
("num_celulas_serie", DadosBateria.Pack.NumeroCelulasSerie),
|
|
("num_sensores_temp", DadosBateria.Pack.NumeroSensoresTemperatura),
|
|
("estado_geral", DadosBateria.Pack.EstadoGeral),
|
|
("charge_mos_on", DadosBateria.Pack.ChargeMosOn),
|
|
("discharge_mos_on", DadosBateria.Pack.DischargeMosOn),
|
|
("cap_restante_ah", DadosBateria.Pack.CapacidadeRestante_Ah),
|
|
("ciclos_aproximados", DadosBateria.Pack.CiclosAproximados),
|
|
// Tensão de células
|
|
("tensao_min_celula_v", DadosBateria.TensaoMin > 0 ? DadosBateria.TensaoMin : MinOrDefault(DadosBateria.Celulas.Select(c => c.Tensao_V).ToList())),
|
|
("tensao_max_celula_v", DadosBateria.TensaoMax > 0 ? DadosBateria.TensaoMax : MaxOrDefault(DadosBateria.Celulas.Select(c => c.Tensao_V).ToList())),
|
|
("idx_celula_min", DadosBateria.Celulas.FirstOrDefault(c => c.EhMinima)?.Index ?? 0),
|
|
("idx_celula_max", DadosBateria.Celulas.FirstOrDefault(c => c.EhMaxima)?.Index ?? 0),
|
|
// Temperaturas
|
|
("temp_min_c", DadosBateria.TemperaturaMin > -200 ? DadosBateria.TemperaturaMin : DadosBateria.Temperaturas.Min(t => t.Temperatura_C)),
|
|
("temp_max_c", DadosBateria.TemperaturaMax > -200 ? DadosBateria.TemperaturaMax : DadosBateria.Temperaturas.Max(t => t.Temperatura_C)),
|
|
// Balanceamento
|
|
("celulas_em_balanceamento", DadosBateria.Balanceamento.QtdeCelulasEmBalanceamento),
|
|
// Alarmes
|
|
("tem_alarme", DadosBateria.Alarmes?.TemAlarme ?? false),
|
|
("fault_code", DadosBateria.Alarmes?.FaultCode ?? 0x00),
|
|
("qtd_alarmes", DadosBateria.Alarmes?.Mensagens?.Count ?? 0),
|
|
("alarmes_texto", DadosBateria.Alarmes.Mensagens != null && DadosBateria.Alarmes.Mensagens.Count > 0 ? string.Join(" | ", DadosBateria.Alarmes.Mensagens) : string.Empty),
|
|
// Opcional: bytes brutos de alarme se quiser debugar depois
|
|
("alarm_bytes_raw", DadosBateria.Alarmes.AlarmBytesRaw != null ? BitConverter.ToString(DadosBateria.Alarmes.AlarmBytesRaw) : string.Empty)
|
|
);
|
|
|
|
var DadosTrj = _Sensoriamento?.Trajetoria;
|
|
RedisService.AtualizarCampos(RedisService.ModKey(Enums.T_Code.Trj),
|
|
("timestamp", agora),
|
|
("iniciado", DadosTrj?.AutonomiaCooredor?.Iniciado ?? false),
|
|
("liberado", DadosTrj?.AutonomiaCooredor?.Liberado ?? false),
|
|
("bateria_ok", DadosTrj?.AutonomiaCooredor?.BateriaSuficiente ?? false),
|
|
("herbicida_ok", DadosTrj?.AutonomiaCooredor?.HerbicidaSuficiente ?? false),
|
|
("motivo", DadosTrj?.AutonomiaCooredor?.Motivo)
|
|
);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|