//---------------- Versáo V0.70 -----------------------
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Adafruit_MCP4725.h>
//#include <Adafruit_ADS1015.h>
#include <Bounce2.h>
#define ADS1115_CONVERSIONDELAY  (1)
#define ADS1015_CONVERSIONDELAY  (1)
#define DAC_RESOLUTION           (9) //DAC resolution 12BIT: 0 - 4056

LiquidCrystal_I2C lcd(0x27,20,4);

// Custom characters
uint8_t arrow[8] = {0x0, 0x4, 0x6, 0x3f, 0x6, 0x4, 0x0}; // caractere seta
uint8_t ohm  [8] = {0xE, 0x11, 0x11, 0x11, 0xA, 0xA, 0x1B}; // caractere ohms
uint8_t dash [8] = {0x1F, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; // Caractere traço em cima

Adafruit_MCP4725 dac; // Defina 9, 8, 7, 6 ou 5 para ajustar a resolução

// Pin definitions
int SW = 4;            // botão encoder
int SW_red = 3;        // botão vermelho para parar/retomar
int SW_blue = 2;       // botão azul para o menu
int Buzzer = 5;        // Buzzer
int Led = 13;          // Led
int fan = 9;           // Ventilador conectado à porta digital 9

int temperature = A0;  // Sensor de temperatura
float tempCelsius;     // Variável para armazenar a temperatura
// Timing variables
int Delay = 500;                    // Atualização do LCD. Cada 300ms.
unsigned long previousMillis = 0;  // loop de atualização do LCD
unsigned long currentMillis = 0;   // loop de atualização do LCD

// Encoder variables
int Rotary_counter = 0;             // armazenar a posição do codificador
int Rotary_counter_prev = 0;        // armazenar o valor anterior do codificador
bool clk_State;                     // Estado do pino CLK do codificador (ALTO ou BAIXO)
bool Last_State;                    // Último estado do pino CLK do codificador (ALTO ou BAIXO)
bool dt_State;                      // Estado do pino DT do codificador (ALTO ou BAIXO)

// Menu variables
int Menu_level = 1;                 // Menu é estruturado por níveis
int Menu_row = 1;                   // Cada nível pode ter diferentes linhas

// Button debounce variables
int push_count_ON = 0;              // Variável usada como contador para detectar quando um botão é realmente pressionado (debounce)
int push_count_OFF = 0;             // Variável usada como contador para detectar quando um botão NÃO é pressionado (debounce)
bool SW_STATUS = false;             // Armazena o status do botão de pressão do codificador rotativo (pressionado ou não)
bool SW_red_status = false;         // Armazena o status do botão de pausa/retomar (pressionado ou não)
bool pause = false;                 // Armazena o status da pausa (habilitado ou desabilitado)

// LCD display strings
String pause_string = "";           // usado para imprimir algo no LCD

// Variables for ADC readings
float ohm_setpoint = 0;
float mA_setpoint = 0;
float mW_setpoint = 0;
int dac_value = 0;

/////////////////////////////////////////////////////////////IMPORTANTE////////////////////////////////////////////////////////////////
/* Ao usar o ADS1115, valores de bits (0 a 65000), usamos um multiplicador.
  Por padrão, é "0,185mV" ou "0,000185V". No código, para medir corrente, fazemos uma medição diferencial da tensão
  na carga de "1ohm". Como a carga é de 1ohm, isso nos dará DIRETAMENTE o valor da corrente, já que "I = V/R" e R é 1.
  MAS!!! O resistor não é exatamente 1ohm, então o para valores mais precisos multiplicador para 0,0001827. Você pode precisar ajustar essa
  variável para outros valores até obter boas leituras. Portanto, enquanto mede o valor com um multímetro externo ao mesmo tempo,
  ajuste essa variável até obter bons resultados. */
const float multiplier = 0.0001827;   
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* O mesmo vale aqui. Mas neste caso, a leitura de tensão é de um divisor de tensão. Veja, o ADS1115 só pode medir até 5V.
  Se a entrada for maior, ele será danificado. Então, entre o ADS1115 e a entrada principal, usei um divisor de 10K e 100K e 
  isso equivalerá a um divisor de 0,0909090. Então, agora o multiplicador é 0,000185 / 0,0909090 = 0,002035.
  Agora, esses valores dos resistores não são perfeitos, então não temos exatamente 10K e 100K, é por isso que meu multiplicador para leitura de tensão
  é 0,0020645. Faça o mesmo, meça a tensão na tela LCD e também com um multímetro externo e ajuste esse valor até obter 
  bons resultados.*/
const float multiplier_A2 = 0.0020645;  

Bounce debouncer = Bounce();

void setup() {////////////////////////////////////////////////////////////////////////
  lcd.init();                
  lcd.backlight();            
  
  lcd.createChar(0, arrow);   // Cria o caractere de seta
  lcd.createChar(1, ohm);     // Cria o caractere de ohm
  lcd.createChar(2, dash);    // Cria o caractere de seta para cima
  
  lcd.clear();
  lcd.setCursor(2,0);
  lcd.print("CARGA ELETRONICA"); 
  lcd.setCursor(7,1);
  lcd.print("V0.5");
  tone(Buzzer, 500, 100);     
  delay(100);
  tone(Buzzer, 700, 100);     
  delay(100);
  tone(Buzzer, 1200, 100);   
  delay(200);
  lcd.setCursor(2,3);
  lcd.print("FABIO ELETRONICA");  
  delay(100);
  
  PCICR |= (1 << PCIE0);      // Habilita a varredura PCMSK0                                               
  //PCMSK0 |= (1 << PCINT0);  // Configura o pino D8 para disparar uma interrupção na mudança de estado.
  PCMSK0 |= (1 << PCINT1);    // Pino 9 (DT) interrupção. Configura o pino D9 para disparar uma interrupção na mudança de estado.
  PCMSK0 |= (1 << PCINT2);    // Pino 10 (CLK) interrupção. Configura o pino D10 para disparar uma interrupção na mudança de estado.
  DDRB &= B11111001;          // Pinos 8, 9, 10 como entrada 

  pinMode(Led,OUTPUT);        // Define o pino do LED como saída
  pinMode(fan, OUTPUT);       // Define o pino da fan
  digitalWrite(Led, LOW);     // Desliga o Led
  pinMode(Buzzer,OUTPUT);     // Define o pino do buzzer como saída
  digitalWrite(Buzzer, LOW);  // Desliga o buzzer

  pinMode(SW,INPUT_PULLUP);       // Define o botão do encoder como entrada com pullup
  pinMode(SW_blue,INPUT_PULLUP);  // Define o botão do menu como entrada com pullup
  pinMode(SW_red,INPUT_PULLUP);   // Define o botão de parar/resumir como entrada com pullup
  delay(10);

  ///////////ads.begin();      // Inicia a comunicação I2C com o ADC
 // ads.startComparator_SingleEnded(2, ADS1015_REG_CONFIG_MODE_CONTIN);
  //ads.startComparator_SingleEnded(3, ADS1015_REG_CONFIG_MODE_CONTIN);
  delay(10);

  dac.begin(0x60);  // Inicia a comunicação I2C com o DAC (endereço do slave às vezes pode ser 0x60, 0x61 ou 0x62)
  delay(10);
  dac.setVoltage(0, false); // Tensão do DAC para 0V (MOSFET desligado)
  delay(10);  
  previousMillis = millis(); 

  debouncer.attach(SW_red);
  debouncer.interval(5); // Intervalo de debounce

}
/////////////////////////////////////////////////////////////////////////////
void loop() {
//===================== Botao Liga desliga ==============
    debouncer.update(); 
  if (debouncer.fell()) {   // Verifica se o botão foi pressionado
    tone(Buzzer, 1500, 200); // Emite som no buzzer
    pause = !pause;          // Inverte o estado da variável pause
    SW_red_status = true;  
  }
  if (debouncer.rose()) { // Verifica se o botão foi solto
    SW_red_status = false;
  }
  //====================================================
  if(Menu_level == 1) {
    if(!digitalRead(SW) && !SW_STATUS) {
      Rotary_counter = 0;
      //tone(Buzzer,2800, 20);
      if(Menu_row == 1){
        Menu_level = 2;//Resistencia
        Menu_row = 1;
      } else if(Menu_row == 2){
        Menu_level = 3;//Corrente
        Menu_row = 1;
      } else if(Menu_row == 3){
        Menu_level = 4;//Potencia
        Menu_row = 1;
      } else if(Menu_row == 4){
        Menu_level = 8;// Bateria
        Menu_row = 1;
      }
      SW_STATUS = true;
    }  
    if(digitalRead(SW) && SW_STATUS) {
      SW_STATUS = false;
    }
    if (Rotary_counter <= 3) {
      Menu_row = 1;
    } else if (Rotary_counter > 3 && Rotary_counter <= 6) {
      Menu_row = 2;
    } else if (Rotary_counter > 6 && Rotary_counter <= 9) {
      Menu_row = 3;
    } else if (Rotary_counter > 9 && Rotary_counter <= 12) {
      Menu_row = 4;
    }
    if(Rotary_counter < 0) {
      Rotary_counter = 0;
    }
    if(Rotary_counter > 12) {
      Rotary_counter = 12;
    }   
    currentMillis = millis();
    if(currentMillis - previousMillis >= Delay){
      previousMillis += Delay;
      if(Menu_row == 1) {

        //===================== Menus ====================
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.write(0); lcd.print(" Constant Resist.");
        lcd.setCursor(2,1);
        lcd.print("Constant Current");
        lcd.setCursor(2,2);       
        lcd.print("Constant Power");
        lcd.setCursor(2,3); 
        lcd.print("Battery Test");
      } else if(Menu_row == 2) {
        lcd.clear();
        lcd.setCursor(2,0);
        lcd.print("Constant Resist.");
        lcd.setCursor(0,1);
        lcd.write(0);lcd.print(" Constant Current");
        lcd.setCursor(2,2);
        lcd.print("Constant Power");
        lcd.setCursor(2,3); 
        lcd.print("Battery Test");   
      } else if(Menu_row == 3) {
        lcd.clear();
        lcd.setCursor(2,0);
        lcd.print("Constant Resist.");
        lcd.setCursor(2,1);
        lcd.print("Constant Current");
        lcd.setCursor(0,2);  
        lcd.write(0);lcd.print(" Constant Power");
        lcd.setCursor(2,3); 
        lcd.print("Battery Test");  
      } else if(Menu_row == 4) {
        lcd.clear();
        lcd.setCursor(2,0);
        lcd.print("Constant Resist.");
        lcd.setCursor(2,1);
        lcd.print("Constant Current");
        lcd.setCursor(1,2);  
        lcd.print(" Constant Power");
        lcd.setCursor(0,3);
        lcd.write(0); lcd.print(" Battery Test");  
      }   
    }
  }
//============================ Menu resistencia =========================
 if (Menu_level == 2) { 
  if (Rotary_counter < 0) {
      Rotary_counter = 0;
  }
  
  if (!digitalRead(SW) && !SW_STATUS) {
    //tone(Buzzer, 500, 10);
    push_count_ON+=1;
    push_count_OFF = 0;
    if (push_count_ON > 20) {
      Menu_level = 5;
      pause = true;
      ohm_setpoint = Rotary_counter / 1000.0; // Divide para obter 0.000
      Rotary_counter = 0;
      SW_STATUS = true;
      push_count_ON = 0;
    }      
  }
  
  if (digitalRead(SW) && SW_STATUS) {
    push_count_ON = 0; 
    push_count_OFF++; 
    if (push_count_OFF > 20) {
      SW_STATUS = false;
      push_count_OFF = 0;
    }    
  }
  int stepSize = 1;// Incremento de passos de 1
  currentMillis = millis();
  if (currentMillis - previousMillis >= Delay) {
    previousMillis += Delay;
    lcd.clear();
    lcd.setCursor(0, 0);   
    lcd.print("Ohms: ");
    lcd.print(Rotary_counter / 1000.0, 3); // Exibe como 0.000, 0.001, 0.002
  }

//=========================== BT Voltar =======
    if(!digitalRead(SW_blue)){
      Menu_level = 1;
      Menu_row = 1;
      Rotary_counter = 0;
      Rotary_counter_prev = 0;
      dac.setVoltage(0, false);
      previousMillis = millis();
      SW_STATUS = true;
      ohm_setpoint = 0;
      tone(Buzzer, 500, 10);  
    }
  }
//========================== Menu Corrente =================================
 if(Menu_level == 3) {

  if (Rotary_counter < 0) {
    Rotary_counter = 0;
  }
  if (!digitalRead(SW) && !SW_STATUS) {
    //tone(Buzzer, 500, 10);
    push_count_ON++;
    push_count_OFF = 0;
    if (push_count_ON > 20) {
      Menu_level = 6;
      pause = true;
      mA_setpoint = Rotary_counter / 1000.0; // Divide para obter 0.000
      Rotary_counter = 0;
      SW_STATUS = true;
      push_count_ON = 0;
    }      
  }
  if (digitalRead(SW) && SW_STATUS) {
    push_count_ON = 0; 
    push_count_OFF++; 
    if (push_count_OFF > 20) {
      SW_STATUS = false;
      push_count_OFF = 0;
    }    
  }
  currentMillis = millis();
  if (currentMillis - previousMillis >= Delay) {
    previousMillis += Delay;
    lcd.clear();
    lcd.setCursor(0, 0);  
    lcd.print("Amps: ");
    lcd.print(Rotary_counter / 1000.0, 3); // Exibe como 0.000, 0.001, etc.
  }
//============================= BT Voltar ===
    if(!digitalRead(SW_blue)){
      Menu_level = 1;
      Menu_row = 1;
      Rotary_counter = 0;
      Rotary_counter_prev = 0;
      dac.setVoltage(0, false);
      previousMillis = millis();
      SW_STATUS = true;
      mA_setpoint = 0;  
      tone(Buzzer, 500, 10);       
    }     
  }
  //===================== Menu Potencia ======================
  if(Menu_level == 4){

    if (Rotary_counter < 0) {
    Rotary_counter = 0;
  }
  if (!digitalRead(SW) && !SW_STATUS) {
    //tone(Buzzer, 500, 10);
    push_count_ON++;
    push_count_OFF = 0;
    if (push_count_ON > 20) {
      Menu_level = 7;
      pause = true;//Mantem a carga desligda
      mW_setpoint = Rotary_counter / 1000.0; // Divide para obter 0.000
      Rotary_counter = 0;
      SW_STATUS = true;
      push_count_ON = 0;
    }      
  }
  if (digitalRead(SW) && SW_STATUS) {
    push_count_ON = 0; 
    push_count_OFF++; 
    if (push_count_OFF > 20) {
      SW_STATUS = false;
      push_count_OFF = 0;
    }    
  }
  currentMillis = millis();
  if (currentMillis - previousMillis >= Delay) {
    previousMillis += Delay;
    lcd.clear();
    lcd.setCursor(0, 0); 
    lcd.print("Wats: ");
    lcd.print(Rotary_counter / 1000.0, 3); // Exibe como 0.000, 0.001, etc.
  }
//=========================== BT Voltar ==
    if(!digitalRead(SW_blue)){
      Menu_level = 1;
      Menu_row = 1;
      Rotary_counter = 0;
      Rotary_counter_prev = 0;
      dac.setVoltage(0, false);
      previousMillis = millis();
      SW_STATUS = true;
      mW_setpoint = 0;
      tone(Buzzer, 500, 10);  
    }
  }
 //======================== Resitencia Constante =======================
if(Menu_level == 5){

    if(Rotary_counter > Rotary_counter_prev)
    {
        ohm_setpoint = ohm_setpoint + 0.001;
        Rotary_counter_prev = Rotary_counter;     
    }
    if(Rotary_counter < Rotary_counter_prev)
    {
        ohm_setpoint = ohm_setpoint - 0.001;
        Rotary_counter_prev = Rotary_counter;    
    }
    // Evita de chegar a valores negativos
    if(ohm_setpoint < 0.000)
    {
        ohm_setpoint = 0.000;
    }
    ohm_setpoint = round(ohm_setpoint * 1000.0) / 1000.0;

    //=======================SENSORES===========================
    float voltage_on_load, sensosed_voltage, voltage_read, power_read;  
    ////////voltage_on_load = ads.readADC_Differential_0_1();      //Read DIFFERENTIAL voltage between ADC0 and ADC1. (the load is 1ohm, so this is equal to the current)
    voltage_on_load = (voltage_on_load * multiplier)*1000;

    ///////voltage_read = ads.readADC_SingleEnded(2);
    voltage_read = (voltage_read * multiplier_A2);
    
    /////sensosed_voltage = ads.readADC_SingleEnded(3);
    /////sensosed_voltage = (sensosed_voltage * multiplier);
    
    power_read = voltage_on_load * voltage_read;

    float setpoint_current = (voltage_read / ohm_setpoint) * 1000;

    float error = abs(setpoint_current - voltage_on_load);
    
    if (error > (setpoint_current*0.8))
    {
      if(setpoint_current > voltage_on_load){
        dac_value = dac_value + 300;
      }

      if(setpoint_current < voltage_on_load){
        dac_value = dac_value - 300;
      }
    }

    else if (error > (setpoint_current*0.6))
    {
      if(setpoint_current > voltage_on_load){
        dac_value = dac_value + 170;
      }

      if(setpoint_current < voltage_on_load){
        dac_value = dac_value - 170;
      }
    }

    else if (error > (setpoint_current*0.4))
    {
      if(setpoint_current > voltage_on_load){
        dac_value = dac_value + 120;
      }

      if(setpoint_current < voltage_on_load){
        dac_value = dac_value - 120;
      }
    }
    else if (error > (setpoint_current*0.3))
    {
      if(setpoint_current > voltage_on_load){
        dac_value = dac_value + 60;
      }

      if(setpoint_current < voltage_on_load){
        dac_value = dac_value - 60;
      }
    }
    else if (error > (setpoint_current*0.2))
    {
      if(setpoint_current > voltage_on_load){
        dac_value = dac_value + 40;
      }

      if(setpoint_current < voltage_on_load){
        dac_value = dac_value - 40;
      }
    }
    else if (error > (setpoint_current*0.1))
    {
      if(setpoint_current > voltage_on_load){
        dac_value = dac_value + 30;
      }

      if(setpoint_current < voltage_on_load){
        dac_value = dac_value - 30;
      }
    }
    else
    {
      if(setpoint_current > voltage_on_load){
        dac_value = dac_value + 1;
      }

      if(setpoint_current < voltage_on_load){
        dac_value = dac_value - 1;
      }
    } 
    if(dac_value > 4095)
    {
      dac_value = 4095;
    }
    //==================== Liga desliga ==============
    if(!pause){// Se pause for verdadeiro desliga
      dac.setVoltage(dac_value, false);
      pause_string = "ON";
      digitalWrite(Led, HIGH); 
    }
    else{
      dac.setVoltage(0, false);
      pause_string = "OFF";
      digitalWrite(Led, LOW); 
    }   
    //==========================
    currentMillis = millis();
    if(currentMillis - previousMillis >= Delay){
      previousMillis += Delay;
      lcd.clear();
      lcd.setCursor(0,0); 
      lcd.print("Const. Load = ");lcd.print(pause_string);  
      lcd.setCursor(0,1);
      lcd.print("V:"); lcd.print(voltage_read,3);lcd.print("    ");lcd.print("A:");lcd.print(voltage_on_load,0);
      lcd.setCursor(0,2);    
      lcd.print("W:");lcd.print(power_read,0);
      lcd.setCursor(0,3); 
      lcd.print("Set R = ");lcd.print(ohm_setpoint,3); lcd.write(1);  
    } 
    if(!digitalRead(SW_blue)){//Botao Voltar
      Menu_level = 1;
      Menu_row = 1;
      Rotary_counter = 0;
      Rotary_counter_prev = 0;
      dac.setVoltage(0, false);
      digitalWrite(Led, LOW); 
      previousMillis = millis();
      SW_STATUS = true;  
      ohm_setpoint = 0;  
      tone(Buzzer, 500, 10); 
    }
  }
  //================================== Corrente Constante =======================
  if(Menu_level == 6){

    if(Rotary_counter > Rotary_counter_prev)
    {
        mA_setpoint = mA_setpoint + 0.001;
        Rotary_counter_prev = Rotary_counter;     
    }
    if(Rotary_counter < Rotary_counter_prev)
    {
        mA_setpoint = mA_setpoint - 0.001;
        Rotary_counter_prev = Rotary_counter;    
    }
    // Evita de chegar a valores negativos
    if(mA_setpoint < 0.000)
    {
        mA_setpoint = 0.000;
    }
    mA_setpoint = round(mA_setpoint * 1000.0) / 1000.0;
//=========================SENSORES=================================
    float voltage_on_load, sensosed_voltage, voltage_read, power_read;
      
    ///////voltage_on_load = ads.readADC_Differential_0_1();      //Read DIFFERENTIAL voltage between ADC0 and ADC1
    voltage_on_load = (voltage_on_load * multiplier)*1000;

    ///////voltage_read = ads.readADC_SingleEnded(2);
    voltage_read = (voltage_read * multiplier_A2);
    
    ////sensosed_voltage = ads.readADC_SingleEnded(3);
    /////sensosed_voltage = (sensosed_voltage * multiplier);
    
    power_read = voltage_on_load * voltage_read;

    float error = abs(mA_setpoint - voltage_on_load);
    
    if (error > (mA_setpoint*0.8))
    {
      if(mA_setpoint > voltage_on_load){
        dac_value = dac_value + 300;
      }
      if(mA_setpoint < voltage_on_load){
        dac_value = dac_value - 300;
      }
    }
   else if (error > (mA_setpoint*0.6))
    {
      if(mA_setpoint > voltage_on_load){
        dac_value = dac_value + 170;
      }
      if(mA_setpoint < voltage_on_load){
        dac_value = dac_value - 170;
      }
    }
    else if (error > (mA_setpoint*0.4))
    {
      if(mA_setpoint > voltage_on_load){
        dac_value = dac_value + 120;
      }
      if(mA_setpoint < voltage_on_load){
        dac_value = dac_value - 120;
      }
    }
    else if (error > (mA_setpoint*0.3))
    {
      if(mA_setpoint > voltage_on_load){
        dac_value = dac_value + 60;
      }
      if(mA_setpoint < voltage_on_load){
        dac_value = dac_value - 60;
      }
    }
    else if (error > (mA_setpoint*0.2))
    {
      if(mA_setpoint > voltage_on_load){
        dac_value = dac_value + 40;
      }
      if(mA_setpoint < voltage_on_load){
        dac_value = dac_value - 40;
      }
    }    
    else if (error > (mA_setpoint*0.1))
    {
      if(mA_setpoint > voltage_on_load){
        dac_value = dac_value + 30;
      }
      if(mA_setpoint < voltage_on_load){
        dac_value = dac_value - 30;
      }
    }
    else
    {
      if(mA_setpoint > voltage_on_load){
        dac_value = dac_value + 1;
      }
      if(mA_setpoint < voltage_on_load){
        dac_value = dac_value - 1;
      }
    }   
    if(dac_value > 4095)
    {
      dac_value = 4095;
    }//=====================Liga desliga ================
   if(!pause){// Se pause for verdadeiro desliga
      dac.setVoltage(dac_value, false);
      pause_string = "ON";
      digitalWrite(Led, HIGH); 
    }
    else{
      dac.setVoltage(0, false);
      pause_string = "OFF";
      digitalWrite(Led, LOW); 
    }  
    //==========================================
    currentMillis = millis();
    if(currentMillis - previousMillis >= Delay){
    previousMillis += Delay;
    lcd.clear();
    lcd.setCursor(0,0); 
    lcd.print("Const. Current = "); lcd.print(pause_string); 
    lcd.setCursor(0,1);
    lcd.print("V:"); lcd.print(voltage_read,3); lcd.print("    "); lcd.print("A:"); lcd.print(voltage_on_load,0);
    lcd.setCursor(0,2);    
    lcd.print("W:"); lcd.print(power_read,0);
    lcd.setCursor(0,3); 
    lcd.print("Set A = ");lcd.print(mA_setpoint,3);lcd.print(" Amps"); 
   }
    if(!digitalRead(SW_blue)){//Botao voltar
      Menu_level = 1;
      Menu_row = 1;
      Rotary_counter = 0;
      Rotary_counter_prev = 0;
      dac.setVoltage(0, false);
      digitalWrite(Led, LOW); 
      previousMillis = millis();
      SW_STATUS = true;
      mA_setpoint = 0;  
      tone(Buzzer, 500, 10);          
    }      
  }
  //========================== Potencia Constante =======================
 if(Menu_level == 7){

    if(Rotary_counter > Rotary_counter_prev)
    {
        mW_setpoint = mW_setpoint + 0.001;
        Rotary_counter_prev = Rotary_counter;     
    }
    if(Rotary_counter < Rotary_counter_prev)
    {
        mW_setpoint = mW_setpoint - 0.001;
        Rotary_counter_prev = Rotary_counter;    
    }
    // Evita de chegar a valores negativos
    if(mW_setpoint < 0.000)
    {
        mW_setpoint = 0.000;
    }
    mW_setpoint = round(mW_setpoint * 1000.0) / 1000.0;
    
   //=====================SENSORES=================================== 
    float voltage_on_load, sensosed_voltage, voltage_read, power_read;
      
    /////////voltage_on_load = ads.readADC_Differential_0_1();      //Read DIFFERENTIAL voltage between ADC0 and ADC1
    voltage_on_load = (voltage_on_load * multiplier)*1000;

    ////////voltage_read = ads.readADC_SingleEnded(2);
    voltage_read = (voltage_read * multiplier_A2);
    
    ////////sensosed_voltage = ads.readADC_SingleEnded(3);
    /////////sensosed_voltage = (sensosed_voltage * multiplier);
    
    power_read = voltage_on_load * voltage_read;

    float error = abs(mW_setpoint - power_read);    
    if (error > (mW_setpoint*0.8))
    {
      if(mW_setpoint > power_read){
        dac_value = dac_value + 300;
      }
      if(mW_setpoint < power_read){
        dac_value = dac_value - 300;
      }
    }
    else if (error > (mW_setpoint*0.6))
    {
      if(mW_setpoint > power_read){
        dac_value = dac_value + 170;
      }
      if(mW_setpoint < power_read){
        dac_value = dac_value - 170;
      }
    }
    else if (error > (mW_setpoint*0.4))
    {
      if(mW_setpoint > power_read){
        dac_value = dac_value + 120;
      }
      if(mW_setpoint < power_read){
        dac_value = dac_value - 120;
      }
    }
    else if (error > (mW_setpoint*0.3))
    {
      if(mW_setpoint > power_read){
        dac_value = dac_value + 60;
      }
      if(mW_setpoint < power_read){
        dac_value = dac_value - 60;
      }
    }
    else if (error > (mW_setpoint*0.2))
    {
      if(mW_setpoint > power_read){
        dac_value = dac_value + 40;
      }
      if(mW_setpoint < power_read){
        dac_value = dac_value - 40;
      }
    }
    else if (error > (mW_setpoint*0.1))
    {
      if(mW_setpoint > power_read){
        dac_value = dac_value + 30;
      }
      if(mW_setpoint < power_read){
        dac_value = dac_value - 30;
      }
    }
    else
    {
      if(mW_setpoint > power_read){
        dac_value = dac_value + 1;
      }
      if(mW_setpoint < power_read){
        dac_value = dac_value - 1;
      }
    }    
    if(dac_value > 4095)
    {
      dac_value = 4095;
    } //===============LIGA DESLIGA ===============  
    if(!pause){// Se pause for verdadeiro desliga
      dac.setVoltage(dac_value, false);
      pause_string = "ON";
      digitalWrite(Led, HIGH); 
    }
    else{
      dac.setVoltage(0, false);
      pause_string = "OFF";
      digitalWrite(Led, LOW); 
    }
    //==============================
    currentMillis = millis();
    if(currentMillis - previousMillis >= Delay){
      previousMillis += Delay;
      lcd.clear();
      lcd.setCursor(0,0); 
      lcd.print("Const. Power = ");lcd.print(pause_string);    
      lcd.setCursor(0,1);
      lcd.print("V:"); lcd.print(voltage_read,3);lcd.print("    ");lcd.print("A:");lcd.print(voltage_on_load,0);
      lcd.setCursor(0,2);    
      lcd.print("W:");lcd.print(power_read,0);
      lcd.setCursor(0,3); 
      lcd.print("Set A = ");lcd.print(mW_setpoint,3); lcd.print(" Wats");
     }
    if(!digitalRead(SW_blue)){ 
      Menu_level = 1;
      Menu_row = 1;
      Rotary_counter = 0;
      Rotary_counter_prev = 0;
      dac.setVoltage(0, false);//Desliga a carga
      digitalWrite(Led, LOW);
      previousMillis = millis();
      SW_STATUS = true;
      mW_setpoint = 0; 
      tone(Buzzer, 500, 10);     
    }      
}
//======================= Teste Bateria ===============
if(Menu_level == 8){
   currentMillis = millis();
   if(currentMillis - previousMillis >= Delay){
      previousMillis += Delay;
      lcd.clear();
      lcd.setCursor(3,0); 
      lcd.print("Battery Teste");
      lcd.setCursor(1,2); 
      lcd.print("Em Desenvolvimento");
   }
   if(!digitalRead(SW_blue)){ 
      Menu_level = 1;
      Menu_row = 1;
      Rotary_counter = 0;
      Rotary_counter_prev = 0;
      dac.setVoltage(0, false); // Desliga a carga
      digitalWrite(Led, LOW);
      previousMillis = millis();
      SW_STATUS = true;
      // mW_setpoint = 0; 
      tone(Buzzer, 500, 10);     
   }      
 }
}

// ==================== Encoder =====================
ISR(PCINT0_vect){  
  cli(); // stop interrupts happening before we read pin values
  clk_State = (PINB & B00000100); // pin 10 state? 
  dt_State  = (PINB & B00000010); 
  if (clk_State != Last_State){
    // If the outputB state is different to the outputA state, that means the encoder is rotating clockwise
    if (dt_State != clk_State){ 
      Rotary_counter ++;    
      tone(Buzzer, 3200, 5);
      Last_State = clk_State; // Updates the previous state of the outputA with the current state
      sei(); // restart interrupts
    }
    else {
      Rotary_counter --;  
      tone(Buzzer, 3100, 5); 
      Last_State = clk_State; // Updates the previous state of the outputA with the current state    
      sei(); // restart interrupts
    } 
  }  
}