// https://www.instructables.com/id/IoT-Water-Alarm/
 
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <util/delay.h>

// Watchdog timer prescaler definitions for deep_sleep
#define WDT_16ms        0
#define WDT_32ms        1
#define WDT_64ms        2
#define WDT_125ms       3
#define WDT_250ms       4
#define WDT_500ms       5
#define WDT_1s          6
#define WDT_2s          7
#define WDT_4s          32
#define WDT_8s          33

#define BATT_THRESHOLD      932                         // battery threshold ~ 2.30 V = 932/1024*2.56*0.987(correction)
#define SENSOR_THRESHOLD    102                         // water sensor threshold ~10% of Vcc

#define BATT_LED_PIN    PB4                             // battery LED pin
#define ESP_EN_PIN      PB1                             // ESP8266 module power pin
#define BUZZ_PIN        PB0                             // buzzer power pin
#define BATT_CHECK      1<<REFS2|1<<REFS1|1<<MUX0       // ADMUX config for battery pin voltage
#define SENSOR_CHECK    1<<MUX1|1<<MUX0                 // ADMUX config for sensor pin voltage

volatile uint8_t armed_flag = 1;                        // alarm armed flag

uint16_t read_volt(uint8_t admux_config) {
    ADMUX = admux_config;                               // measure pin and reference (page 135)
    
    ADCSRA |= (1 << ADEN) | (1 << ADIE);                // enable ADC, & ADC conversion complete interrupt
    for (uint8_t k = 0; k < 60; k++) {                  // Wait for bandgap reference to stabilize
        __asm__ __volatile__ ("nop"); }
    
    MCUCR &= ~(1 << SM1);
    MCUCR |= (1 << SM0);                                // set ADC noise-reduction sleep mode
    
    sleep_enable();;                                    // MCUCR |= (1 << SE)
    sei();                                              // Enable all interrupts
    sleep_cpu();                                        // Trigger sleep and do first conversion (result not used)
    sleep_cpu();                                        // Sleep again to repeat conversion
    cli();                                              // Disable all interrupts
    sleep_disable();                                    // MCUCR &= ~(1 << SE);
    
    ADCSRA &= ~(1 << ADIE);                             // disable ADC conversion complete interrupt
    ADCSRA &= ~(1 << ADEN);                             // disable ADC
    
    return ADC;                                         // alternatively, repeat measurement and average prior to returning
}

void deep_sleep(uint8_t WDT_config) {
    WDTCR = 1<<WDCE | 1<<WDE;                           // enable watchdog timer configuration changes
    WDTCR = WDT_config;                                 // set the watchdog timer prescaler and clear WDE (interrupt mode only)
    
    MCUCR &= ~(1 << SM0);
    MCUCR |= (1 << SM1);                                // select power-down sleep mode, same as set_sleep_mode(SLEEP_MODE_PWR_DOWN)
    WDTCR |= (1 << WDIE);                               // enable watchdog interrupt mode
    
    sleep_enable();;                                    // MCUCR |= (1 << SE)
    sei();                                              // Enable all interrupts
    sleep_cpu();                                        // Trigger sleep
    cli();                                              // Disable all interrupts
    sleep_disable();                                    // MCUCR &= ~(1 << SE);
}

void blink_led(void) {
    //DDRB |= 1<<BATT_LED_PIN;                            // LED pin in normal output mode
    PORTB = 1<<BATT_LED_PIN;                            // LED on
    for (uint8_t k = 0; k < 80; k++) {                  // delay ~240 cycles
        __asm__ __volatile__ ("nop"); }
    PORTB = 0;                                          // LED off
    //DDRB &= ~(1<<BATT_LED_PIN);                         // LED pin in high impedance mode (because ESP can sink 2 mA of current through this pin)
    
}

void low_batt_notification(void) {
    for (uint8_t k = 0; k<10; k++) {                    // ~40 seconds
        PORTB = 1<<BATT_LED_PIN | 1<<ESP_EN_PIN | 1<<BUZZ_PIN; // buzzer on, ESP8266 + LED on
        _delay_ms(300);
        PORTB = 1<<BATT_LED_PIN | 1<<ESP_EN_PIN;           // buzzer off, ESP8266 + LED still on
        _delay_ms(3700);
    }
    PORTB = 0;                                          // LED, ESP8266 and Buzzer off
}

void activate_alarm(void) {
    for (uint8_t k = 0; k<30; k++) {                    // ~60 seconds
        PORTB = 1<<ESP_EN_PIN | 1<<BUZZ_PIN;               // ESP8266 + buzzer
        _delay_ms(700);
        PORTB = 1<<ESP_EN_PIN;                             // ESP8266 only
        _delay_ms(1300);
    }
    PORTB = 0;                                          // LED, ESP8266 and Buzzer off
}

int main(void) {
    cli();                                              // disable interrupts
    DDRB = 1<<BATT_LED_PIN | 1<<ESP_EN_PIN | 1<<BUZZ_PIN;  // set output pins
    PORTB = 1<<ESP_EN_PIN;                              // ESP8266 enable for 10 ms
    _delay_ms(300);
    PORTB = 0;                                          // no pull-ups, no output
    
    MCUSR &= ~(1 << WDRF);                              // reset watchdog system reset status flag (affects WDTCR[WDE])
    
    ADCSRA |= 1<<ADPS2;                                 // set ADC prescaler to 16
    
    while (1) {
        deep_sleep(WDT_8s);
        
        if (armed_flag) {
            if (read_volt(BATT_CHECK) > BATT_THRESHOLD) {       // measure PB2 against internal ref 2.56V (page 135), blink LED
                blink_led();
            }
            else {
                low_batt_notification();                        // batteries too low, send notification
                armed_flag = 0;                                 // disarm  alarm
            }
            
            if (read_volt(SENSOR_CHECK) > SENSOR_THRESHOLD) {   // measure PB3 against Vcc
                activate_alarm();                               // activate alarm
                armed_flag = 0;                                 // disarm alarm
            }
        }
    }
    return 0; // never reached
}

// dummy ADC interrupt routine
EMPTY_INTERRUPT(ADC_vect);

// dummy watchdog timer interrupt routine
EMPTY_INTERRUPT(WDT_vect);