/*
Simple Deep Sleep with Timer Wake Up
=====================================
ESP32 offers a deep sleep mode for effective power
saving as power is an important factor for IoT
applications. In this mode CPUs, most of the RAM,
and all the digital peripherals which are clocked
from APB_CLK are powered off. The only parts of
the chip which can still be powered on are:
RTC controller, RTC peripherals ,and RTC memories

This code displays the most basic deep sleep with
a timer to wake it up and how to store data in
RTC memory to use it over reboots

This code is under Public Domain License.

Author:
Pranav Cherukupalli <[email protected]>
*/

#define uS_TO_S_FACTOR 1000000  /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP  10       /* Time ESP32 will go to sleep (in seconds) */

RTC_DATA_ATTR int bootCount = 0;
// the number of the LED pin
const int ledPin = 2;//2 dev kit//16;  // 16 corresponds to GPIO16
const int PinVF = 4;
const int PinNF = 12;
// setting PWM properties
const int freq = 500;
const int resolution = 8;

const int VFfreq = 5000;


const int NFfreq = 1000;

const int PWM_CHANNEL0 = 7;
const int PWM_CHANNEL1 = 1;
const int PWM_CHANNEL2 =3;

/*
Method to print the reason by which ESP32
has been awaken from sleep
*/
static void print_wakeup_reason() {
    esp_sleep_wakeup_cause_t wakeup_reason;

    wakeup_reason = esp_sleep_get_wakeup_cause();

    switch (wakeup_reason)
    {
    case ESP_SLEEP_WAKEUP_EXT0: Serial.println("Wakeup caused by external signal using RTC_IO"); break;
    case ESP_SLEEP_WAKEUP_EXT1: Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
    case ESP_SLEEP_WAKEUP_TIMER: Serial.println("Wakeup caused by timer"); break;
    case ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println("Wakeup caused by touchpad"); break;
    case ESP_SLEEP_WAKEUP_ULP: Serial.println("Wakeup caused by ULP program"); break;
    default: Serial.printf("Wakeup was not caused by deep sleep: %d\n", wakeup_reason); break;
    }
}

void setup() {
    Serial.begin(115200);
    delay(1000); //Take some time to open up the Serial Monitor
  // configure LED PWM
   ledcAttach(ledPin, freq, resolution );
  ledcAttach(PinVF, VFfreq, resolution);
  ledcAttach(PinNF, NFfreq, resolution);
    
 delay(50);
 Serial.println("4a");
    
        // increase the LED brightness
        for (int dutyCycle = 0; dutyCycle <= 2; dutyCycle++) {
            // changing the LED brightness with PWM
            ledcWriteChannel(PWM_CHANNEL0, dutyCycle);            
            ledcWriteChannel(PWM_CHANNEL1, dutyCycle);            
            ledcWriteChannel(PWM_CHANNEL2, dutyCycle);                     
        }
        Serial.println("Up ok");
        // decrease the LED brightness
        for (int dutyCycle = ; dutyCycle >= 0; dutyCycle--) {
            // changing the LED brightness with PWM
            ledcWrite(PWM_CHANNEL0, dutyCycle);
            ledcWrite(PWM_CHANNEL1, dutyCycle);
            ledcWrite(PWM_CHANNEL2, dutyCycle);
            delay(50);
        }
            Serial.println("Down ok");
            //Increment boot number and print it every reboot
            ++bootCount;
            Serial.println("Boot number: " + String(bootCount));

            //Print the wakeup reason for ESP32
            print_wakeup_reason();

            /*
            First we configure the wake up source
            We set our ESP32 to wake up every 5 seconds
            */
            esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
            Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) +
                " Seconds");

            /*
            Next we decide what all peripherals to shut down/keep on
            By default, ESP32 will automatically power down the peripherals
            not needed by the wakeup source, but if you want to be a poweruser
            this is for you. Read in detail at the API docs
            http://esp-idf.readthedocs.io/en/latest/api-reference/system/deep_sleep.html
            Left the line commented as an example of how to configure peripherals.
            The line below turns off all RTC peripherals in deep sleep.
            */
            //esp_deep_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
            //Serial.println("Configured all RTC Peripherals to be powered down in sleep");

            /*
            Now that we have setup a wake cause and if needed setup the
            peripherals state in deep sleep, we can now start going to
            deep sleep.
            In the case that no wake up sources were provided but deep
            sleep was started, it will sleep forever unless hardware
            reset occurs.
            */
            Serial.println("Going to sleep now");
            delay(1000);
            Serial.flush();
            esp_deep_sleep_start();
            Serial.println("This will never be printed");
        }

void loop() {
    //This is not going to be called
}