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!");
}
}
void loop()
{
controll.run();
blynk.run();
}