agrobot_base/Firmware/Modulos/SinaleiroModel.h

#include "SerialService.h"
#include "Pinout.h"
#include "Utils.h"

#ifndef SinaleiroModel
#define SinaleiroModel

class Sinaleiro {
  public:

    static void InicializarLista(std::vector<Sinaleiro*>& lista, const String& parametros, const String& Mod_ID);

    Sinaleiro(String _modID, String _id, int _taxaAmostragem = 2000) {
      Mod_ID = _modID;
      _ID = _id;
    }

    String Mod_ID;
    String _ID;
    int ID_Num;
    PinoModel _pino;
    bool Iniciado = false;

    StatusLED _Status = Apagado;
    StatusLED _StatusLeitura = Apagado;
    int _Qtd = 0;
    int _TempoMs = 0;
    int _PausaMs = 0;

    void Inicializar() {
      if (Iniciado) {
        PrintTela(_ID + " ja inicializado");
        return;
      }
      
      _pino.Conectar(false);

      Iniciado = _pino.Definido();

      if (Iniciado) {
        xTaskCreatePinnedToCore(&Sinaleiro::LEDTaskWrapper, "LEDTask", 5000, this, 6, &LEDTaskHandle, tskNO_AFFINITY);

        PrintTela(_ID + " Iniciado");
      }
      else {
        PrintTela(_ID + " nao Iniciado");
      }
    }

    void Desligar() {
      if (!Iniciado) {
        PrintTela(_ID + " nao esta inicializado");
        return;
      }

      // Parar a execução das tarefas
      vTaskDelete(LEDTaskHandle);

      // Redefinir as configurações para os valores iniciais
      _pino.Desconectar();

      PrintTela(_ID + " Desligado");

      Iniciado = false;
    }

    void AtualizarLeitura() {
      if (Iniciado) {
        _StatusLeitura = (StatusLED)_pino.get();
      }
    }

    void RequisitarDados() {
      AtualizarLeitura();
    }

    std::vector<uint8_t> MontarMensagemCAN() {
      std::vector<uint8_t> data;
      data.push_back(ID_Num);
      data.push_back(Iniciado ? 1 : 0);
      data.push_back(_StatusLeitura ? 1 : 0);
      data.push_back(_Status ? 1 : 0);
      return data;
    }

  private:
    TaskHandle_t LEDTaskHandle = NULL;
    static void LEDTaskWrapper(void *pvParameters) {
      Sinaleiro *led = static_cast<Sinaleiro*>(pvParameters);
      led->LEDTask();
    }

    void LEDTask() {
      unsigned long lastMillis = millis();
      bool ledState = false;
      int piscadasAtual = 0;
      bool emPausa = false;

      while (1) {
        unsigned long currentMillis = millis();

        if (_Status != Piscando) {
          _pino.set(_Status == Aceso);
          //_StatusLeitura = (StatusLED)_pino.get();
        }
        else if (_Status == Piscando && piscadasAtual < _Qtd) {
          if (!emPausa && (currentMillis - lastMillis >= _TempoMs)) {
            ledState = !ledState;
            _pino.set(ledState);
            lastMillis = currentMillis;
            if (!ledState) { // Se o LED acabou de ser desligado, incrementa o contador de piscadas
              piscadasAtual++;
            }
          } else if (emPausa && (currentMillis - lastMillis >= _PausaMs)) {
            emPausa = false;
            lastMillis = currentMillis;
          }
        } else if (piscadasAtual >= _Qtd) {
          // Se alcançou a quantidade desejada de piscadas, entra em pausa
          if (!emPausa) {
            ledState = false;
            _pino.set(false); // Garante que o LED está desligado
            emPausa = true;
            piscadasAtual = 0; // Reseta o contador de piscadas
            lastMillis = currentMillis;
          }
        }

        vTaskDelay(1); // Pequena pausa para liberar o CPU
      }
    }

};


// Função para inicializar os sinaleiros com IDs e pinos específicos
void Sinaleiro::InicializarLista(std::vector<Sinaleiro*>& lista, const String& parametros, const String& Mod_ID) {
  // Verifica se há sensores já na lista
  if (!lista.empty()) {
    PrintTela("Limpando lista de sinaleiros existente...");

    for (auto* sensor : lista) {
      sensor->Desligar();  // Desliga cada sensor antes de remover
      PrintTela("Sinaleiro " + sensor->_ID + " desligado.");
      delete sensor;
    }

    lista.clear();  // Limpa a lista após desligar todos os itens
  }

  if (parametros.length() > 0) {
    std::vector<String> _config = SplitString(parametros, SplitConfig);  // Divide a configuração por vírgulas

    for (const String& config : _config) {
      std::vector<String> partes = SplitString(config, SplitSubParams);  // Divide cada configuração pelo '-'

      if (partes.size() == 4) {
        String id = partes[0];
        bool conectar = partes[1] == "1";
        TiposBarramentos pinoB = (TiposBarramentos)partes[2].toInt();
        int pino = partes[3].toInt();

        if (conectar) {
          Sinaleiro* sensor = new Sinaleiro(Mod_ID, id);
          sensor->ID_Num = lista.size();
          sensor->_pino = PinoModel(pino, pinoB, _OUTPUT);
          sensor->Inicializar();
          lista.push_back(sensor);
          PrintTela("Sinaleiro " + id + " inicializado no pino " + String(pino));
        }
      } else {
        PrintTela("Configuração inválida para sinaleiro: " + config);
      }
    }
  } else {
    PrintTela("Configuração de sinaleiro não encontrada.");
  }
}

#endif