BLYNK
HOME       📲 GETTING STARTED       📗 DOCS       ❓HELP CENTER       👉 SKETCH BUILDER

My program is resetting every 4 seconds after disabling blynk

I removed the code from the main program to instantiate in another module and now my program does not stop resetting.

/*-------------------------------------------------------------------
 Projeto : Vacuometro digital
 Cliente : None
 Data    : 15 de março de 2021
 Author  : Nera
 Plataforma : ARDUINO
 Placa   : ESP32 VRROM D1 WEMOS
 Device  : ESP32 DEV Module##
 Observações:
    Este projeto utiliza um teclado de membrana e displays 74hc595
    Utiliza-se também de terminal para alterar e visualizar parametros.
    A configuração do terminal deve ser:
        O terminal pode ser qualquer um, porém este foi testado no Putty.
        Baud Rate: 115200.
        BackSpace: ControlH
        Controle de fluxo: None (nenhum)
        Estudar o protocolo MQTT para Arduino (Blynk)
----------------------------------------------------------------------*/

#include "Arduino.h"
#include "global.h"
#include "Thread.h"
#include "ThreadController.h"
#include "Shell.h"
#include "EEPROM.h"
#include "Modulo595.h"
#include "Keypad.h"
#include "key.h"
#include "Eeprom_Indka.h"
#include <stdlib.h>
#include "AD_Converter.h"


/*
#include "WiFi.h"
#include "WiFiClient.h"
#include "BlynkSimpleEsp32.h"
*/
/*
#include <Arduino.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <esp_ipc.h>
*/


TaskHandle_t Task1;

extern bool flag_multicore;

//-------------------------------------------
hw_timer_t* timer = NULL; // Para o Timer Zero

Controladores SensoresAtuadores[MAXDEVICE];

uint32_t tempoDecorrido = 0;

int SCLK = 26; //Clock
int RCLK = 17; //Lath
int DIO = 16;  //Data

String blynkDisplay[MAXDEVICE];
Eeprom_Indka hardDisk = Eeprom_Indka();
Modulo595 seteSegmentos(SCLK, RCLK, DIO);
Shell comandos;
uint8_t enterDoKeypad = 0;

/*
char auth[] = "Pd9SZNodRX688FDh_kTitt-nOUkYIrnh";
char ssid[] = "Nera";
char pass[] = "iub950962";
*/


//BlynkWifi Blynk;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//             T E C L A D O   D E   M E M B R A N A
const byte qtdLinhas = 4; //QUANTIDADE DE LINHAS DO TECLADO
const byte qtdColunas = 4; //QUANTIDADE DE COLUNAS DO TECLADO

//CONSTRUÇÃO DA MATRIZ DE CARACTERES
char matriz_teclas[qtdLinhas][qtdColunas] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

byte PinosqtdLinhas[qtdLinhas] = { 12 , 32, 25, 27 }; //PINOS UTILIZADOS PELAS LINHAS
byte PinosqtdColunas[qtdColunas] = { 14,33,15,22 }; //PINOS UTILIZADOS PELAS COLUNAS 

//INICIALIZAÇÃO DO TECLADO
Keypad meuteclado = Keypad(makeKeymap(matriz_teclas), PinosqtdLinhas, PinosqtdColunas, qtdLinhas, qtdColunas);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


ThreadController controll = ThreadController();

uint16_t buzzer = 0;


//======================================================================
//                           T  H  R  E  A  D  S
//======================================================================

Thread thLerSensor;
AD_Converter ADC_Indka;
void doLerSensor() {
    static uint8_t escalona = 0;
    uint8_t contador;
    //--------------------------------
    float ADCvalue;
    float resistencia;
    float temperatura;
    float calc;


    //--------------------------------
    if (escalona == 0)
    {
        SensoresAtuadores[escalona].value = 124.8;
    }
    else if (escalona == 1)
    {
#define B 3975 
        ADCvalue = ADC_Indka.read_pin(34);       //Faz uma média das entradas
        ADCvalue = ADC_Indka.suaviza(ADCvalue, escalona);  //Suaviza os dados por tendência


        resistencia = (4095.0 - ADCvalue);
        resistencia *= (10000.0 - ADCvalue);
        temperatura = ADCvalue * 10000.0 / resistencia;
        calc = temperatura;
        temperatura = log(calc);
        temperatura /= B;
        temperatura += 1.0 / (25.0 + 273.15);
        temperatura = 1.0 / temperatura;
        temperatura -= 273.15;

        SensoresAtuadores[escalona].value = temperatura;//(3.3 / 4095) * valor;//(((200.0 * valor) / 1024.0) - 110.0) / 10;
    }
    else if (escalona == 2)
    {
        ADCvalue = ADC_Indka.read_pin(39);       //Faz uma média das entradas
        ADCvalue = ADC_Indka.suaviza(ADCvalue, escalona);  //Suaviza os dados por tendência

        SensoresAtuadores[escalona].value = ((200.0 * ADCvalue) / 4095.0) - 100.0;
    }
    else if (escalona == 3)
    {
        SensoresAtuadores[escalona].value = 673.4;
    }

    escalona++;
    if (escalona >= MAXDEVICE) escalona = 0;



}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Thread thBlynkRun;
bool flag_connected = false;
void doBlynkRun() {
    //Blynk.run();
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Thread thBlynkExibe;
void doBlynkExibe() {
    static uint8_t escalona = 0;
    /*
    switch (escalona++)
    {
    case 0:Blynk.virtualWrite(V0, SensoresAtuadores[0].valorDeLeitura(COMPOSTO)); break;
    case 1:Blynk.virtualWrite(V1, SensoresAtuadores[1].valorDeLeitura(COMPOSTO)); break;
    case 2:Blynk.virtualWrite(V2, SensoresAtuadores[2].valorDeLeitura(COMPOSTO)); break;
    case 3:Blynk.virtualWrite(V3, SensoresAtuadores[1].valorDeLeitura(COMPOSTO)); break;
    case 4:Blynk.virtualWrite(V4, SensoresAtuadores[2].valorDeLeitura(COMPOSTO)); break;
    case 5: escalona = 0; break;
    }
    */
}


//thBlynk.onRun(doBlynk);
//thBlynk.setInterval(500);

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Thread thDisplay;
void doDisplay(void) {
    
}



//=====================================================================
//++++++++++++++++++++++
// TECLADO DE MEMBRANA
Thread thKeypad;
char tecla_pressionada = 0;
int8_t displayNumero = 0;
static float decimal = 100.0;
static float temp = 0;
bool flag_zerar = true;
uint8_t funcao = FUNCAO_NONE;
uint8_t funcaoMemo = FUNCAO_NONE;
int8_t autorestore = -1;
void doKeypad()
{
    tecla_pressionada = meuteclado.getKey();
    if (tecla_pressionada)
    {
        SaidaAutomatica(SETA); //Define desistência de edição
        buzzer = TIME_BUZZER; //Define aviso sonoro.
        switch (tecla_pressionada)
        {
        case 'A':Pressionou_a_Tecla_A(); break;
        case 'B':Pressionou_a_Tecla_B(); break;
        case 'C':Pressionou_a_Tecla_C(); break;
        case '*':Pressionou_Asterisco(); break;
        case 'D':Pressionou_a_Tecla_D(); break;
        case '#':Pressionou_Tecla_Sharp(); break;
        default:Pressionou_Tecla_Numerica(); break;
        }

        tecla_pressionada = 0;
    }
}

//=====================================================================
//++++++++++++++++++++++
//Relogio de tempo real

Thread thRTC = Thread();
void doRTC() {
    milisegundo++;
    if (tempoDecorrido > 0) tempoDecorrido--;
    if (buzzer > 0)
    {
        buzzer--;
        digitalWrite(PIN_BUZZER, HIGH);
    }
    else
    {
        //buzzer--;
        digitalWrite(PIN_BUZZER, LOW);
    }

}


//========================================================================
//#define CHECK1(x, ...) if (!(x)) { printf(__VA_ARGS__); }




Thread thAutoRelay;
void doAutoRelay() {
    uint8_t escalona;

    if (Relay_Status(escalona) == RELAY_ESTADO_ATIVO)
    {
        //================ CONTROLE DE TEMPO DO RELE 0 =================
        if (Relay_Valor_Composto(escalona) <= Relay_Setagem_Baixa(escalona))
        {
            if (Relay_Modo(escalona) == RELAY_AQUECER)
            {
                Relay_Status(escalona) = RELAY_SOBE;
                Relay_Power(escalona, HIGH);
            }
            else
                if (Relay_Modo(escalona) == RELAY_REFRIGERAR)
                {
                    Relay_Status(escalona) = RELAY_DESCE;
                    Relay_Power(escalona, LOW);
                }
        }
        else if (Relay_Valor_Composto(escalona) > Relay_Setagem_Alta(escalona))
        {
            if (Relay_Modo(escalona) == RELAY_AQUECER)
            {
                Relay_Status(escalona) = RELAY_DESCE;
                Relay_Power(escalona, LOW);
            }
            else
                if (Relay_Modo(escalona) == RELAY_AQUECER)
                {
                    Relay_Status(escalona) = RELAY_SOBE;
                    Relay_Power(escalona, HIGH);
                }
        }
    }
    escalona++;
    if (escalona >= MAXDEVICE) escalona = 0;
}


//========================================================================
Thread thShell = Thread();
void doShell() {
    comandos.prompt();
}



void Task1code(void* parameter) {
    for (;;) {
        Exibe_Display();        
    }
} 




// The setup() function runs once each time the micro-controller starts
void setup()
{


    delay(500);
    pinMode(LED_BLINK, OUTPUT);
    pinMode(PIN_BUZZER, OUTPUT);
    pinMode(2, OUTPUT);
    pinMode(34, INPUT);
    pinMode(35, INPUT);
    seteSegmentos.clearDisplay();
    Serial.begin(115200);
    //Blynk.begin(auth, ssid, pass);
    EEPROM.begin(1024);
    analogReadResolution(12);
    for (uint8_t i = 0; i < MAXDEVICE; i++) doLerSensor();
    startTimer();
    //---------------------------

    //---FUNÇÃO MULTICORE----------
    xTaskCreatePinnedToCore(
        Task1code, /* Function to implement the task */
        "Task1", /* Name of the task */
        10000,  /* Stack size in words */
        NULL,  /* Task input parameter */
        0,  /* Priority of the task */
        &Task1,  /* Task handle. */
        0); /* Core where the task should run */



    thBlynkRun.onRun(doBlynkRun);
    thBlynkRun.setInterval(2);

    thAutoRelay.onRun(doAutoRelay);
    thAutoRelay.setInterval(400);


    thLerSensor.onRun(doLerSensor);
    thLerSensor.setInterval(500);

    thBlynkExibe.onRun(doBlynkExibe);
    thBlynkExibe.setInterval(50);

    thDisplay.onRun(doDisplay);
    thDisplay.setInterval(1);

    thKeypad.onRun(doKeypad);
    thKeypad.setInterval(16);

    thShell.onRun(doShell);
    thShell.setInterval(15);

    thRTC.onRun(doRTC);
    thRTC.setInterval(1);

    controll.add(&thBlynkRun);
    controll.add(&thAutoRelay);
    controll.add(&thLerSensor);
    controll.add(&thBlynkExibe);
    controll.add(&thDisplay);  //Displays de sete segmentos
    controll.add(&thKeypad);   //Teclado de membrana
    controll.add(&thShell);    //Terminal Putty
    controll.add(&thRTC);      //RTC



    //-------APAGAR DEPOIS DE TESTES (FIX)----------
    /*
    SensoresAtuadores[VOLTIMETRO].value = 125.3;
    SensoresAtuadores[CONDENSADOR].value = 30.4;
    SensoresAtuadores[VACUOMETRO].value = 637.2;
    SensoresAtuadores[SENSOR_NTC].value = 17.9;
    */
    //----------------------------------------------

    for (uint8_t i = 0; i < MAXDEVICE; i++)
    {
        SensoresAtuadores[i].setpoint = hardDisk.EEPROMReadFloat(12 * i);
        SensoresAtuadores[i].histerese = hardDisk.EEPROMReadFloat(12 * i + 4);
        SensoresAtuadores[i].offset = hardDisk.EEPROMReadFloat(12 * i + 8);
        SensoresAtuadores[i].status = NORMAL;
        SensoresAtuadores[i].power.relayPin = 2;
        SensoresAtuadores[i].value = 25.0;
    }

}

// Add the main program code into the continuous loop() function
void loop()
{
    controll.run();
}












//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

void timerRTC() {
    Gerenciador_de_Tempo(); //alta precisão

}


void startTimer() {
    // inicialização do timer.Parametros:
    /* 0 - seleção do timer a ser usado, de 0 a 3.
      80 - prescaler. O clock principal do ESP32 é 80MHz. Dividimos por 80 para ter 1us por tick.
    true - true para contador progressivo, false para regressivo
    */
    timer = timerBegin(0, 80, true);

    /*conecta à interrupção do timer
     - timer é a instância do hw_timer
     - endereço da função a ser chamada pelo timer
     - edge=true gera uma interrupção
    */
    timerAttachInterrupt(timer, &timerRTC, true);

    /* - o timer instanciado no inicio
       - o valor em us para 1s
       - auto-reload. true para repetir o alarme
    */
    timerAlarmWrite(timer, 1000000, true);

    //ativa o alarme
    timerAlarmEnable(timer);
}

void stopTimer() {
    timerEnd(timer);
    timer = NULL;
}








//oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
void Exibe_Display() {
    int8_t counter;

    for (counter = MAXDEVICE - 1; counter > -1; counter--)
    {
        if ((funcao == FUNCAO_SETPOINT) || (funcao == FUNCAO_HISTERESE))
        {
            if (SensoresAtuadores[counter].status == DINAMICO)
            {
                if (tempoDecorrido > 0)
                {
                    seteSegmentos.sendDisplay(SensoresAtuadores[counter].mensagem, DINAMICO);
                }
                else
                {
                    seteSegmentos.sendDisplay(SensoresAtuadores[counter].temp, PISCA);
                }
            }
            else if (SensoresAtuadores[counter].status == NORMAL)
            {
                seteSegmentos.sendDisplay(SensoresAtuadores[counter].valorDeLeitura(COMPOSTO), NORMAL);
            }
            else if (SensoresAtuadores[counter].status == PISCA)
            {
                seteSegmentos.sendDisplay(SensoresAtuadores[counter].valorDeLeitura(COMPOSTO), PISCA);
            }
        }
        else if (funcao == FUNCAO_CODIGO)
        {
            if (SensoresAtuadores[counter].status == DINAMICO)
            {
                if (tempoDecorrido > 0)
                {
                    seteSegmentos.sendDisplay(SensoresAtuadores[counter].mensagem, DINAMICO);
                }
                else
                {
                    seteSegmentos.sendDisplay(SensoresAtuadores[counter].temp, PISCA);
                }
            }
            else if (SensoresAtuadores[counter].status == NORMAL)
            {
                seteSegmentos.sendDisplay(SensoresAtuadores[counter].valorDeLeitura(COMPOSTO), NORMAL);
            }
            else if (SensoresAtuadores[counter].status == PISCA)
            {
                seteSegmentos.sendDisplay(SensoresAtuadores[counter].valorDeLeitura(COMPOSTO), PISCA);
            }
        }
        else if (funcao == FUNCAO_NONE)
        {
            if (SensoresAtuadores[counter].status == DINAMICO)
            {
                if (autorestore % 2 == 0)
                {
                    seteSegmentos.sendDisplay(SensoresAtuadores[counter].temp, NORMAL);
                }
                else
                {
                    seteSegmentos.sendDisplay(SensoresAtuadores[counter].mensagem, NORMAL);
                }
            }
            else
            {
                seteSegmentos.sendDisplay(SensoresAtuadores[counter].valorDeLeitura(COMPOSTO), NORMAL);
            }
        }
    }
    seteSegmentos.show();
    
}



//00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000









//oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
//RTC do Sistema
uint8_t  hora = 0;
uint8_t  minuto = 0;
uint8_t  segundo = 0;
uint16_t milisegundo = 0;
void Gerenciador_de_Tempo() {
    milisegundo = 0;
    segundo++;
    SaidaAutomatica(MONITORA);
    if (segundo >= 60)
    {
        segundo = 0;
        minuto++;
        if (minuto >= 60)
        {
            minuto = 0;
            hora++;
            if (hora >= 24)
            {
                hora++;
            }
        }

    }

}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//SetPoint do Sistema
void Pressionou_a_Tecla_A() {
    funcao = FUNCAO_SETPOINT;
    for (int8_t i = 0; i < MAXDEVICE; i++)
    {
        SensoresAtuadores[i].status = NORMAL;
        strcpy(SensoresAtuadores[i].mensagem,"SET.P");
        SensoresAtuadores[i].temp = SensoresAtuadores[i].setpoint;
    }
    if (funcaoMemo == FUNCAO_SETPOINT)
    {
        if (++displayNumero >= MAXDEVICE) displayNumero = 0;
        flag_zerar = true;
    }
    funcaoMemo = FUNCAO_SETPOINT;

    SensoresAtuadores[displayNumero].status = DINAMICO;
    tempoDecorrido = 3000;
}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//Histerese do sistema
void Pressionou_a_Tecla_B() {
    static int8_t displayMemo = 0;
    funcao = FUNCAO_HISTERESE;
    decimal = 0.01;
    for (int8_t i = 0; i < MAXDEVICE; i++)
    {
        SensoresAtuadores[i].status = NORMAL;
        strcpy(SensoresAtuadores[i].mensagem,"HIST");
        SensoresAtuadores[i].temp = SensoresAtuadores[i].histerese;
    }
    if (funcaoMemo == FUNCAO_HISTERESE)
    {
        if (++displayNumero >= MAXDEVICE) displayNumero = 0;
        flag_zerar = true;
    }
    funcaoMemo = FUNCAO_HISTERESE;

    SensoresAtuadores[displayNumero].status = DINAMICO;
    tempoDecorrido = 3000;
}

//====================================================================================
//Code do Sistema
void Pressionou_a_Tecla_C() {
    funcao = FUNCAO_CODIGO;
    decimal = 0.01;
    for (int8_t i = 0; i < MAXDEVICE; i++)
    {
        SensoresAtuadores[i].status = NORMAL;
        strcpy(SensoresAtuadores[i].mensagem, "CODE");
        SensoresAtuadores[i].temp = 0;
    }
    if (funcaoMemo == FUNCAO_CODIGO)
    {
        if (++displayNumero >= MAXDEVICE) displayNumero = 0;
        flag_zerar = true;
    }
    funcaoMemo = FUNCAO_CODIGO;





    SensoresAtuadores[displayNumero].status = DINAMICO;
    tempoDecorrido = 3000;
}


//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//Alterna entre positivo e negativo
void Pressionou_a_Tecla_D() {
    SensoresAtuadores[displayNumero].temp = -SensoresAtuadores[displayNumero].temp;
}



//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//Teclas Numericas
void Pressionou_Tecla_Numerica() {
    if ((funcao == FUNCAO_SETPOINT) || (funcao == FUNCAO_HISTERESE))
        FormaNumero(&SensoresAtuadores[displayNumero].temp);
    else if ((funcao == FUNCAO_CODIGO))
    {
        if (flag_zerar)
        {
            flag_zerar = false;
            SensoresAtuadores[displayNumero].temp = 0;
        }
        FormaNumero(&SensoresAtuadores[displayNumero].temp);
    }


}

//===================================================================================
//Esc do sistema
void Pressionou_Asterisco() {
    flag_zerar = true;
    tempoDecorrido = 0;
    autorestore = -1;
    funcao = FUNCAO_NONE;
    enterDoKeypad = 0;
    //PadronizaSensoresAtuadores("", NORMAL, false);
    //PadronizaValordoTempFloat(0);
    for (int8_t i = 0; i < MAXDEVICE; i++)
    {
        SensoresAtuadores[i].status = NORMAL;
        strcpy(SensoresAtuadores[i].mensagem,"");
        SensoresAtuadores[i].temp = SensoresAtuadores[i].histerese;
    }
    if (++displayNumero >= MAXDEVICE) displayNumero = 0;
    flag_zerar = false;
}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//Enter do Sistema

void Pressionou_Tecla_Sharp()
{
    if (funcao == FUNCAO_SETPOINT)
    {
        SensoresAtuadores[displayNumero].setpoint = SensoresAtuadores[displayNumero].temp;
        SensoresAtuadores[displayNumero].status = NORMAL;
        hardDisk.EEPROMWriteFloat((displayNumero * 12), SensoresAtuadores[displayNumero].setpoint);
        funcao = FUNCAO_NONE;
    }
    else if (funcao == FUNCAO_HISTERESE)
    {
        SensoresAtuadores[displayNumero].histerese = SensoresAtuadores[displayNumero].temp;
        SensoresAtuadores[displayNumero].status = NORMAL;
        hardDisk.EEPROMWriteFloat((12 * displayNumero + 4), SensoresAtuadores[displayNumero].histerese);
        funcao = FUNCAO_NONE;
    }
    else if (funcao == FUNCAO_CODIGO)
    {
        static float codigo;
        static float parametro;
        if (flag_zerar) enterDoKeypad = 0;
        if (enterDoKeypad == 0)
        {
            tempoDecorrido = 2000;
            Serial.print("Digitou o codigo ");
            Serial.println(SensoresAtuadores[displayNumero].temp, 3);
            codigo = round(SensoresAtuadores[displayNumero].temp * 1000);
            strcpy(SensoresAtuadores[displayNumero].mensagem,"----");
            SensoresAtuadores[displayNumero].status = DINAMICO;
            SensoresAtuadores[displayNumero].temp = 0;
            enterDoKeypad++;
            if ((codigo == DEFAULT_FACTORE) || //Restaura padrão de Fabrica
                (codigo == OFFSET_VIEW))   //Seta offset dos sensores
            {
                executaTarefa(codigo, 0);
                enterDoKeypad = 0;
            }
        }
        else
        {
            tempoDecorrido = 2000;
            SensoresAtuadores[displayNumero].status = NORMAL;
            Serial.print("Com o parametro ");
            Serial.println(SensoresAtuadores[displayNumero].temp, 3);
            parametro = round(SensoresAtuadores[displayNumero].temp * 1000);
            enterDoKeypad = 0;
            executaTarefa(codigo, parametro);
        }





    }
}



//=======================================================================================================================================
void SaidaAutomatica(uint8_t acao)
{
    if (acao == SETA)
    {
        autorestore = TEMPO_MAX_EDICAO;
    }
    else if (acao == MONITORA)
    {
        if (autorestore > 0)
            autorestore--;
        else if (autorestore == 0)
        {
            autorestore = -1;
            for (uint8_t i = 0; i < MAXDEVICE; i++)
            {
                SensoresAtuadores[i].status = NORMAL;
            }
            funcao = FUNCAO_NONE;
            displayNumero = 0;
            flag_zerar = true;
            //buzzer = 100;
        }
    }
}



/*
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
void SetarInformacaoeIndice(uint8_t index, String Texto){
SensoresAtuadores[displayNumero].mensagem = Texto;
//SensoresAtuadores[displayNumero].index_message = index;
SensoresAtuadores[displayNumero].temp = 0;
}
*/

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
void FormaNumero(float* number) {
    float temp;
    if (flag_zerar)
    {
        flag_zerar = false;
        *number = 0;
    }

    (*number) *= 10.0;
    temp = (tecla_pressionada - 48) * 0.001;

    (*number) += temp;
}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
void executaTarefa(uint32_t codigo, float parametro) {
    //codigo /= 1000;
    parametro /= 1000.0;
    if (codigo == DEFAULT_FACTORE)
    {
        hardDisk.EEPROMWriteFloat(0, 127.0); //SetPoint V
        hardDisk.EEPROMWriteFloat(4, 15.0); //Histerese V
        hardDisk.EEPROMWriteFloat(8, 0.0); //OFF Set V

        hardDisk.EEPROMWriteFloat(12, -35.0); //SetPoint Condensador
        hardDisk.EEPROMWriteFloat(16, 20.0);  //Histerese Condensador
        hardDisk.EEPROMWriteFloat(20, 0.0);//Off set condensador

        hardDisk.EEPROMWriteFloat(24, 600.0);  //SetPoint Vacuometro
        hardDisk.EEPROMWriteFloat(28, 200.0);  //Histerese Vacuometro
        hardDisk.EEPROMWriteFloat(32, 0.0);  //Off Set Vacuometro

        for (uint8_t i = 0; i < MAXDEVICE; i++)
        {
            SensoresAtuadores[i].setpoint = hardDisk.EEPROMReadFloat(12 * i + 0);
            SensoresAtuadores[i].histerese = hardDisk.EEPROMReadFloat(12 * i + 4);
            SensoresAtuadores[i].offset = hardDisk.EEPROMReadFloat(12 * i + 8);
            SensoresAtuadores[i].status = NORMAL;
        }
        funcao = FUNCAO_NONE;
        Serial.println("Valores padrao de fabrica carregados!");
    }
    else if (codigo == OFFSET_SETAR)
    {
        Serial.printf("Voce setou o offset de condensador em %3.3f *C\n", parametro);
        SensoresAtuadores[displayNumero].offset = parametro;
        hardDisk.EEPROMWriteFloat(12 * displayNumero + 8, parametro);
    }
    else if (codigo == OFFSET_VIEW)
    {
        funcao = FUNCAO_NONE;
        SaidaAutomatica(SETA);
        SensoresAtuadores[displayNumero].status = DINAMICO;
        strcpy(SensoresAtuadores[displayNumero].mensagem,"OFF.S");
        SensoresAtuadores[displayNumero].temp = hardDisk.EEPROMReadFloat(12 * displayNumero + 8);
        Serial.printf("Voce esta visualizando o Offset");
    }
    else
    {
        Serial.println("Código inválido!");
    }

}